27#include "llvm/ADT/StringRef.h"
28#include "llvm/BinaryFormat/Minidump.h"
29#include "llvm/Support/ConvertUTF.h"
30#include "llvm/Support/Error.h"
38using namespace llvm::minidump;
41 LocationDescriptor loc;
42 loc.DataSize =
static_cast<llvm::support::ulittle32_t
>(stream_size);
47 dir.Type =
static_cast<llvm::support::little_t<StreamType>
>(type);
55 AddDirectory(StreamType::SystemInfo,
sizeof(llvm::minidump::SystemInfo));
57 llvm::minidump::ProcessorArchitecture arch;
58 switch (target_triple.getArch()) {
59 case llvm::Triple::ArchType::x86_64:
60 arch = ProcessorArchitecture::AMD64;
62 case llvm::Triple::ArchType::x86:
63 arch = ProcessorArchitecture::X86;
65 case llvm::Triple::ArchType::arm:
66 arch = ProcessorArchitecture::ARM;
68 case llvm::Triple::ArchType::aarch64:
69 arch = ProcessorArchitecture::ARM64;
71 case llvm::Triple::ArchType::mips64:
72 case llvm::Triple::ArchType::mips64el:
73 case llvm::Triple::ArchType::mips:
74 case llvm::Triple::ArchType::mipsel:
75 arch = ProcessorArchitecture::MIPS;
77 case llvm::Triple::ArchType::ppc64:
78 case llvm::Triple::ArchType::ppc:
79 case llvm::Triple::ArchType::ppc64le:
80 arch = ProcessorArchitecture::PPC;
83 error.SetErrorStringWithFormat(
"Architecture %s not supported.",
84 target_triple.getArchName().str().c_str());
88 llvm::support::little_t<OSPlatform> platform_id;
89 switch (target_triple.getOS()) {
90 case llvm::Triple::OSType::Linux:
91 if (target_triple.getEnvironment() ==
92 llvm::Triple::EnvironmentType::Android)
93 platform_id = OSPlatform::Android;
95 platform_id = OSPlatform::Linux;
97 case llvm::Triple::OSType::Win32:
98 platform_id = OSPlatform::Win32NT;
100 case llvm::Triple::OSType::MacOSX:
101 platform_id = OSPlatform::MacOSX;
103 case llvm::Triple::OSType::IOS:
104 platform_id = OSPlatform::IOS;
107 error.SetErrorStringWithFormat(
"OS %s not supported.",
108 target_triple.getOSName().str().c_str());
112 llvm::minidump::SystemInfo sys_info;
113 sys_info.ProcessorArch =
114 static_cast<llvm::support::little_t<ProcessorArchitecture>
>(arch);
116 sys_info.CSDVersionRVA =
static_cast<llvm::support::ulittle32_t
>(
118 sys_info.PlatformId = platform_id;
121 std::string csd_string;
125 error.SetErrorString(
"Unable to convert the csd string to UTF16.");
136 llvm::StringRef to_write_ref(to_write.c_str(), to_write.size() + 1);
137 llvm::SmallVector<llvm::UTF16, 128> to_write_utf16;
139 bool converted = convertUTF8ToUTF16String(to_write_ref, to_write_utf16);
141 error.SetErrorStringWithFormat(
142 "Unable to convert the string to UTF16. Failed to convert %s",
149 llvm::support::ulittle32_t to_write_size(to_write_utf16.size_in_bytes() - 2);
151 buffer->
AppendData(&to_write_size,
sizeof(llvm::support::ulittle32_t));
152 buffer->
AppendData(to_write_utf16.data(), to_write_utf16.size_in_bytes());
160 uint64_t SizeOfImage = 0;
161 if (mod->GetObjectFile()->CalculateType() == ObjectFile::Type::eTypeJIT) {
162 for (
const auto §ion : *mod->GetObjectFile()->GetSectionList()) {
163 SizeOfImage += section->GetByteSize();
168 SectionSP sect_sp = mod->GetObjectFile()->GetBaseAddress().GetSection();
171 return llvm::createStringError(std::errc::operation_not_supported,
172 "Couldn't obtain the section information.");
174 lldb::addr_t sect_addr = sect_sp->GetLoadBaseAddress(&target);
181 mod->GetObjectFile()->GetBaseAddress().GetLoadAddress(&target) -
183 SizeOfImage = sect_size - base_sect_offset;
188 while (next_sect_sp &&
189 next_sect_sp->GetLoadBaseAddress(&target) == next_sect_addr) {
190 sect_size = sect_sp->GetByteSize();
191 SizeOfImage += sect_size;
192 next_sect_addr += sect_size;
206 constexpr size_t minidump_module_size =
sizeof(llvm::minidump::Module);
210 llvm::support::ulittle32_t modules_count =
211 static_cast<llvm::support::ulittle32_t
>(modules.
GetSize());
221 size_t module_stream_size =
222 sizeof(llvm::support::ulittle32_t) + modules_count * minidump_module_size;
225 AddDirectory(StreamType::ModuleList, module_stream_size);
234 for (
size_t i = 0; i < modules_count; ++i) {
236 std::string module_name = mod->GetSpecificationDescription();
238 if (!maybe_mod_size) {
239 llvm::Error mod_size_err = maybe_mod_size.takeError();
240 llvm::handleAllErrors(std::move(mod_size_err),
241 [&](
const llvm::ErrorInfoBase &E) {
242 error.SetErrorStringWithFormat(
243 "Unable to get the size of module %s: %s.",
244 module_name.c_str(), E.message().c_str());
249 uint64_t mod_size = std::move(*maybe_mod_size);
251 llvm::support::ulittle32_t signature =
252 static_cast<llvm::support::ulittle32_t
>(
253 static_cast<uint32_t
>(minidump::CvSignature::ElfBuildId));
254 auto uuid = mod->GetUUID().GetBytes();
256 VSFixedFileInfo info;
257 info.Signature =
static_cast<llvm::support::ulittle32_t
>(0u);
258 info.StructVersion =
static_cast<llvm::support::ulittle32_t
>(0u);
259 info.FileVersionHigh =
static_cast<llvm::support::ulittle32_t
>(0u);
260 info.FileVersionLow =
static_cast<llvm::support::ulittle32_t
>(0u);
261 info.ProductVersionHigh =
static_cast<llvm::support::ulittle32_t
>(0u);
262 info.ProductVersionLow =
static_cast<llvm::support::ulittle32_t
>(0u);
263 info.FileFlagsMask =
static_cast<llvm::support::ulittle32_t
>(0u);
264 info.FileFlags =
static_cast<llvm::support::ulittle32_t
>(0u);
265 info.FileOS =
static_cast<llvm::support::ulittle32_t
>(0u);
266 info.FileType =
static_cast<llvm::support::ulittle32_t
>(0u);
267 info.FileSubtype =
static_cast<llvm::support::ulittle32_t
>(0u);
268 info.FileDateHigh =
static_cast<llvm::support::ulittle32_t
>(0u);
269 info.FileDateLow =
static_cast<llvm::support::ulittle32_t
>(0u);
271 LocationDescriptor ld;
272 ld.DataSize =
static_cast<llvm::support::ulittle32_t
>(0u);
273 ld.RVA =
static_cast<llvm::support::ulittle32_t
>(0u);
277 LocationDescriptor ld_cv;
278 ld_cv.DataSize =
static_cast<llvm::support::ulittle32_t
>(
279 sizeof(llvm::support::ulittle32_t) + uuid.size());
280 ld_cv.RVA =
static_cast<llvm::support::ulittle32_t
>(
281 size_before + module_stream_size + helper_data.
GetByteSize());
283 helper_data.
AppendData(&signature,
sizeof(llvm::support::ulittle32_t));
284 helper_data.
AppendData(uuid.begin(), uuid.size());
286 llvm::minidump::Module m;
287 m.BaseOfImage =
static_cast<llvm::support::ulittle64_t
>(
288 mod->GetObjectFile()->GetBaseAddress().GetLoadAddress(&target));
289 m.SizeOfImage =
static_cast<llvm::support::ulittle32_t
>(mod_size);
290 m.Checksum =
static_cast<llvm::support::ulittle32_t
>(0);
292 static_cast<llvm::support::ulittle32_t
>(std::time(
nullptr));
293 m.ModuleNameRVA =
static_cast<llvm::support::ulittle32_t
>(
294 size_before + module_stream_size + helper_data.
GetByteSize());
295 m.VersionInfo = info;
312 llvm::StringRef reg_name) {
317 bool success = reg_ctx->
ReadRegister(reg_info, reg_value);
324 llvm::StringRef reg_name) {
329 bool success = reg_ctx->
ReadRegister(reg_info, reg_value);
336 llvm::StringRef reg_name) {
341 bool success = reg_ctx->
ReadRegister(reg_info, reg_value);
348 llvm::StringRef reg_name) {
349 return static_cast<llvm::support::ulittle16_t
>(
354 llvm::StringRef reg_name) {
355 return static_cast<llvm::support::ulittle32_t
>(
360 llvm::StringRef reg_name) {
361 return static_cast<llvm::support::ulittle64_t
>(
374 if (bytes_copied == 16)
414 return thread_context;
421 minidump::RegisterContextMinidump_ARM64::Flags::ARM64_Flag |
422 minidump::RegisterContextMinidump_ARM64::Flags::Integer |
423 minidump::RegisterContextMinidump_ARM64::Flags::FloatingPoint);
425 for (uint32_t i = 0; i < 31; ++i) {
426 snprintf(reg_name,
sizeof(reg_name),
"x%u", i);
436 for (uint32_t i = 0; i < 32; ++i) {
437 snprintf(reg_name,
sizeof(reg_name),
"v%u", i);
440 return thread_context;
455 case llvm::Triple::ArchType::x86_64:
458 case llvm::Triple::ArchType::aarch64:
471 case llvm::Triple::ArchType::x86_64:
473 case llvm::Triple::ArchType::aarch64:
474 return sizeof(
arm64);
484llvm::Expected<std::pair<addr_t, addr_t>>
490 return llvm::createStringError(
491 std::errc::not_supported,
492 "unable to load stack segment of the process");
498 return llvm::createStringError(std::errc::not_supported,
499 "stack segment of the process is empty");
501 return std::make_pair(addr, size);
505 constexpr size_t minidump_thread_size =
sizeof(llvm::minidump::Thread);
510 size_t thread_stream_size =
sizeof(llvm::support::ulittle32_t) +
511 thread_list.
GetSize() * minidump_thread_size;
515 AddDirectory(StreamType::ThreadList, thread_stream_size);
517 llvm::support::ulittle32_t thread_count =
518 static_cast<llvm::support::ulittle32_t
>(thread_list.
GetSize());
523 const uint32_t num_threads = thread_list.
GetSize();
525 for (uint32_t thread_idx = 0; thread_idx < num_threads; ++thread_idx) {
531 error.SetErrorString(
"Unable to get the register context.");
535 Target &target = process_sp->GetTarget();
539 error.SetErrorStringWithFormat(
540 "architecture %s not supported.",
541 arch.
GetTriple().getArchName().str().c_str());
544 uint64_t
sp = reg_ctx->
GetSP();
547 if (!expected_address_range) {
548 consumeError(expected_address_range.takeError());
549 error.SetErrorString(
"Unable to get the stack address.");
553 std::pair<uint64_t, uint64_t> range = std::move(*expected_address_range);
554 uint64_t addr = range.first;
555 uint64_t size = range.second;
557 auto data_up = std::make_unique<DataBufferHeap>(size, 0);
558 const size_t stack_bytes_read =
559 process_sp->ReadMemory(addr, data_up->GetBytes(), size,
error);
564 LocationDescriptor stack_memory;
565 stack_memory.DataSize =
566 static_cast<llvm::support::ulittle32_t
>(stack_bytes_read);
567 stack_memory.RVA =
static_cast<llvm::support::ulittle32_t
>(
568 size_before + thread_stream_size + helper_data.
GetByteSize());
570 MemoryDescriptor stack;
571 stack.StartOfMemoryRange =
static_cast<llvm::support::ulittle64_t
>(addr);
572 stack.Memory = stack_memory;
574 helper_data.
AppendData(data_up->GetBytes(), stack_bytes_read);
576 LocationDescriptor thread_context_memory_locator;
577 thread_context_memory_locator.DataSize =
578 static_cast<llvm::support::ulittle32_t
>(thread_context.
size());
579 thread_context_memory_locator.RVA =
static_cast<llvm::support::ulittle32_t
>(
580 size_before + thread_stream_size + helper_data.
GetByteSize());
586 llvm::minidump::Thread t;
587 t.ThreadId =
static_cast<llvm::support::ulittle32_t
>(thread_sp->GetID());
588 t.SuspendCount =
static_cast<llvm::support::ulittle32_t
>(
589 (thread_sp->GetState() == StateType::eStateSuspended) ? 1 : 0);
590 t.PriorityClass =
static_cast<llvm::support::ulittle32_t
>(0);
591 t.Priority =
static_cast<llvm::support::ulittle32_t
>(0);
592 t.EnvironmentBlock =
static_cast<llvm::support::ulittle64_t
>(0);
593 t.Stack = stack, t.Context = thread_context_memory_locator;
605 const uint32_t num_threads = thread_list.
GetSize();
606 for (uint32_t thread_idx = 0; thread_idx < num_threads; ++thread_idx) {
608 StopInfoSP stop_info_sp = thread_sp->GetStopInfo();
609 bool add_exception =
false;
611 switch (stop_info_sp->GetStopReason()) {
614 add_exception =
true;
621 constexpr size_t minidump_exception_size =
622 sizeof(llvm::minidump::ExceptionStream);
623 AddDirectory(StreamType::Exception, minidump_exception_size);
624 StopInfoSP stop_info_sp = thread_sp->GetStopInfo();
627 exp_record.ExceptionCode =
628 static_cast<llvm::support::ulittle32_t
>(stop_info_sp->GetValue());
629 exp_record.ExceptionFlags =
static_cast<llvm::support::ulittle32_t
>(0);
630 exp_record.ExceptionRecord =
static_cast<llvm::support::ulittle64_t
>(0);
631 exp_record.ExceptionAddress = reg_ctx_sp->GetPC();
632 exp_record.NumberParameters =
static_cast<llvm::support::ulittle32_t
>(0);
633 exp_record.UnusedAlignment =
static_cast<llvm::support::ulittle32_t
>(0);
636 ExceptionStream exp_stream;
637 exp_stream.ThreadId =
638 static_cast<llvm::support::ulittle32_t
>(thread_sp->GetID());
639 exp_stream.UnusedAlignment =
static_cast<llvm::support::ulittle32_t
>(0);
640 exp_stream.ExceptionRecord = exp_record;
643 exp_stream.ThreadContext = Iter->second;
645 exp_stream.ThreadContext.DataSize = 0;
646 exp_stream.ThreadContext.RVA = 0;
658 error = process_sp->CalculateCoreFileSaveRanges(core_style, core_ranges);
660 error.SetErrorString(
"Process doesn't support getting memory region info.");
665 std::vector<MemoryDescriptor> mem_descriptors;
666 for (
const auto &core_range : core_ranges) {
668 if (core_range.range.empty())
670 const addr_t addr = core_range.range.start();
671 const addr_t size = core_range.range.size();
672 auto data_up = std::make_unique<DataBufferHeap>(size, 0);
673 const size_t bytes_read =
674 process_sp->ReadMemory(addr, data_up->GetBytes(), size,
error);
677 LLDB_LOGF(log,
"Failed to read memory region. Bytes read: %zu, error: %s",
678 bytes_read,
error.AsCString());
684 LocationDescriptor memory_dump;
685 memory_dump.DataSize =
static_cast<llvm::support::ulittle32_t
>(bytes_read);
688 MemoryDescriptor memory_desc;
689 memory_desc.StartOfMemoryRange =
690 static_cast<llvm::support::ulittle64_t
>(addr);
691 memory_desc.Memory = memory_dump;
692 mem_descriptors.push_back(memory_desc);
697 sizeof(llvm::support::ulittle32_t) +
698 mem_descriptors.size() *
699 sizeof(llvm::minidump::MemoryDescriptor));
700 llvm::support::ulittle32_t memory_ranges_num(mem_descriptors.size());
703 for (
auto memory_descriptor : mem_descriptors) {
705 sizeof(llvm::minidump::MemoryDescriptor));
716 misc_info.
size =
static_cast<llvm::support::ulittle32_t
>(
720 misc_info.
flags1 =
static_cast<llvm::support::ulittle32_t
>(0);
723 process_sp->GetProcessInfo(process_info);
727 static_cast<llvm::support::ulittle32_t
>(
static_cast<uint32_t
>(
730 static_cast<llvm::support::ulittle32_t
>(process_info.
GetProcessID());
737std::unique_ptr<llvm::MemoryBuffer>
739 auto maybe_stream = llvm::MemoryBuffer::getFileAsStream(path);
742 return std::move(maybe_stream.get());
747 std::vector<std::pair<StreamType, std::string>> files_with_stream_types = {
748 {StreamType::LinuxCPUInfo,
"/proc/cpuinfo"},
749 {StreamType::LinuxLSBRelease,
"/etc/lsb-release"},
753 process_sp->GetProcessInfo(process_info);
756 std::string pid_str = std::to_string(pid);
757 files_with_stream_types.push_back(
758 {StreamType::LinuxProcStatus,
"/proc/" + pid_str +
"/status"});
759 files_with_stream_types.push_back(
760 {StreamType::LinuxCMDLine,
"/proc/" + pid_str +
"/cmdline"});
761 files_with_stream_types.push_back(
762 {StreamType::LinuxEnviron,
"/proc/" + pid_str +
"/environ"});
763 files_with_stream_types.push_back(
764 {StreamType::LinuxAuxv,
"/proc/" + pid_str +
"/auxv"});
765 files_with_stream_types.push_back(
766 {StreamType::LinuxMaps,
"/proc/" + pid_str +
"/maps"});
767 files_with_stream_types.push_back(
768 {StreamType::LinuxProcStat,
"/proc/" + pid_str +
"/stat"});
769 files_with_stream_types.push_back(
770 {StreamType::LinuxProcFD,
"/proc/" + pid_str +
"/fd"});
773 for (
const auto &entry : files_with_stream_types) {
774 StreamType stream = entry.first;
775 std::string path = entry.second;
779 size_t size = memory_buffer->getBufferSize();
789 constexpr size_t header_size =
sizeof(llvm::minidump::Header);
790 constexpr size_t directory_size =
sizeof(llvm::minidump::Directory);
793 llvm::minidump::Header header;
794 header.Signature =
static_cast<llvm::support::ulittle32_t
>(
795 llvm::minidump::Header::MagicSignature);
796 header.Version =
static_cast<llvm::support::ulittle32_t
>(
797 llvm::minidump::Header::MagicVersion);
798 header.NumberOfStreams =
800 header.StreamDirectoryRVA =
802 header.Checksum =
static_cast<llvm::support::ulittle32_t
>(
804 header.TimeDateStamp =
805 static_cast<llvm::support::ulittle32_t
>(std::time(
nullptr));
807 static_cast<llvm::support::ulittle64_t
>(0u);
810 size_t bytes_written;
812 bytes_written = header_size;
813 error = core_file->Write(&header, bytes_written);
814 if (
error.Fail() || bytes_written != header_size) {
815 if (bytes_written != header_size)
816 error.SetErrorStringWithFormat(
817 "unable to write the header (written %zd/%zd)", bytes_written,
827 error.SetErrorStringWithFormat(
828 "unable to write the data (written %zd/%" PRIu64
")", bytes_written,
835 bytes_written = directory_size;
836 error = core_file->Write(&dir, bytes_written);
837 if (
error.Fail() || bytes_written != directory_size) {
838 if (bytes_written != directory_size)
839 error.SetErrorStringWithFormat(
840 "unable to write the directory (written %zd/%zd)", bytes_written,
static llvm::raw_ostream & error(Stream &strm)
#define LLDB_LOGF(log,...)
llvm::support::ulittle16_t read_register_u16(RegisterContext *reg_ctx, llvm::StringRef reg_name)
uint64_t read_register_u64_raw(RegisterContext *reg_ctx, llvm::StringRef reg_name)
Status WriteString(const std::string &to_write, lldb_private::DataBufferHeap *buffer)
lldb_private::minidump::MinidumpContext_x86_64 GetThreadContext_x86_64(RegisterContext *reg_ctx)
llvm::Expected< uint64_t > getModuleFileSize(Target &target, const ModuleSP &mod)
uint16_t read_register_u16_raw(RegisterContext *reg_ctx, llvm::StringRef reg_name)
llvm::support::ulittle32_t read_register_u32(RegisterContext *reg_ctx, llvm::StringRef reg_name)
void read_register_u128(RegisterContext *reg_ctx, llvm::StringRef reg_name, uint8_t *dst)
std::unique_ptr< llvm::MemoryBuffer > getFileStreamHelper(const std::string &path)
llvm::support::ulittle64_t read_register_u64(RegisterContext *reg_ctx, llvm::StringRef reg_name)
minidump::RegisterContextMinidump_ARM64::Context GetThreadContext_ARM64(RegisterContext *reg_ctx)
llvm::Expected< std::pair< addr_t, addr_t > > findStackHelper(const lldb::ProcessSP &process_sp, uint64_t rsp)
uint32_t read_register_u32_raw(RegisterContext *reg_ctx, llvm::StringRef reg_name)
Structure holding data neccessary for minidump file creation.
lldb_private::Status WriteString(const std::string &to_write, lldb_private::DataBufferHeap *buffer)
const void * data() const
llvm::Triple::ArchType m_arch
lldb_private::minidump::MinidumpContext_x86_64 x86_64
lldb_private::minidump::RegisterContextMinidump_ARM64::Context arm64
bool prepareRegisterContext(RegisterContext *reg_ctx)
ArchThreadContexts(llvm::Triple::ArchType arch)
lldb_private::Status Dump(lldb::FileUP &core_file) const
size_t GetCurrentDataEndOffset() const
lldb_private::Status AddModuleList(lldb_private::Target &target)
void AddExceptions(const lldb::ProcessSP &process_sp)
lldb_private::DataBufferHeap m_data
void AddLinuxFileStreams(const lldb::ProcessSP &process_sp)
void AddMiscInfo(const lldb::ProcessSP &process_sp)
size_t GetDirectoriesNum() const
lldb_private::Status AddSystemInfo(const llvm::Triple &target_triple)
lldb_private::Status AddMemoryList(const lldb::ProcessSP &process_sp, lldb::SaveCoreStyle core_style)
std::map< lldb::tid_t, llvm::minidump::LocationDescriptor > m_tid_to_reg_ctx
std::vector< llvm::minidump::Directory > m_directories
lldb_private::Status AddThreadList(const lldb::ProcessSP &process_sp)
void AddDirectory(llvm::minidump::StreamType type, size_t stream_size)
A section + offset based address class.
lldb::SectionSP GetSection() const
Get const accessor for the section.
An architecture specification class.
llvm::Triple & GetTriple()
Architecture triple accessor.
llvm::Triple::ArchType GetMachine() const
Returns a machine family for the current architecture.
A subclass of DataBuffer that stores a data buffer on the heap.
lldb::offset_t GetByteSize() const override
Get the number of bytes in the data buffer.
void AppendData(const void *src, uint64_t src_len)
uint32_t GetLLDBPermissions() const
A collection class for Module objects.
lldb::ModuleSP GetModuleAtIndex(size_t idx) const
Get the module shared pointer for the module at index idx.
size_t GetSize() const
Gets the size of the module list.
bool ProcessIDIsValid() const
lldb::pid_t GetProcessID() const
std::vector< CoreFileMemoryRange > CoreFileMemoryRanges
uint64_t GetSP(uint64_t fail_value=LLDB_INVALID_ADDRESS)
const RegisterInfo * GetRegisterInfoByName(llvm::StringRef reg_name, uint32_t start_idx=0)
virtual bool ReadRegister(const RegisterInfo *reg_info, RegisterValue ®_value)=0
uint16_t GetAsUInt16(uint16_t fail_value=UINT16_MAX, bool *success_ptr=nullptr) const
uint32_t GetAsMemoryData(const RegisterInfo ®_info, void *dst, uint32_t dst_len, lldb::ByteOrder dst_byte_order, Status &error) const
uint64_t GetAsUInt64(uint64_t fail_value=UINT64_MAX, bool *success_ptr=nullptr) const
uint32_t GetAsUInt32(uint32_t fail_value=UINT32_MAX, bool *success_ptr=nullptr) const
bool ResolveLoadAddress(lldb::addr_t load_addr, Address &so_addr, uint32_t stop_id=SectionLoadHistory::eStopIDNow)
const ModuleList & GetImages() const
Get accessor for the images for this process.
const ArchSpec & GetArchitecture() const
uint32_t GetSize(bool can_update=true)
lldb::ThreadSP GetThreadAtIndex(uint32_t idx, bool can_update=true)
uint8_t * GetBytes()
Get a pointer to the data.
A class that represents a running process on the host machine.
Log * GetLog(Cat mask)
Retrieve the Log object for the channel associated with the given log enum.
std::shared_ptr< lldb_private::Thread > ThreadSP
std::unique_ptr< lldb_private::File > FileUP
std::shared_ptr< lldb_private::Process > ProcessSP
std::shared_ptr< lldb_private::StopInfo > StopInfoSP
std::shared_ptr< lldb_private::Section > SectionSP
std::shared_ptr< lldb_private::RegisterContext > RegisterContextSP
std::shared_ptr< lldb_private::Module > ModuleSP
BaseType GetRangeBase() const
SizeType GetByteSize() const
Every register is described in detail including its name, alternate name (optional),...
llvm::support::ulittle16_t fs
llvm::support::ulittle64_t rdx
llvm::support::ulittle16_t cs
llvm::support::ulittle64_t rsp
llvm::support::ulittle16_t ss
llvm::support::ulittle64_t rbx
llvm::support::ulittle16_t ds
llvm::support::ulittle64_t r8
llvm::support::ulittle16_t gs
llvm::support::ulittle64_t rcx
llvm::support::ulittle64_t r10
llvm::support::ulittle64_t r15
llvm::support::ulittle64_t rbp
llvm::support::ulittle64_t r13
llvm::support::ulittle64_t r12
llvm::support::ulittle64_t rsi
llvm::support::ulittle64_t p1_home
llvm::support::ulittle64_t rax
llvm::support::ulittle32_t context_flags
llvm::support::ulittle64_t rdi
llvm::support::ulittle64_t r14
llvm::support::ulittle32_t eflags
llvm::support::ulittle64_t r9
llvm::support::ulittle64_t rip
llvm::support::ulittle64_t r11
llvm::support::ulittle32_t process_id
llvm::support::ulittle32_t flags1
llvm::support::ulittle32_t size