30#include "llvm/ADT/StringRef.h"
31#include "llvm/BinaryFormat/Minidump.h"
32#include "llvm/Support/ConvertUTF.h"
33#include "llvm/Support/Endian.h"
34#include "llvm/Support/Error.h"
35#include "llvm/TargetParser/Triple.h"
55using namespace llvm::minidump;
68 llvm::Triple::OSType::Linux)
72 std::vector<lldb::ThreadSP> threads =
74 for (
const ThreadSP &thread_sp : threads) {
75 StopInfoSP stop_info_sp = thread_sp->GetStopInfo();
77 const StopReason &stop_reason = stop_info_sp->GetStopReason();
89 "Failed to fill in header and directory "
90 "sections. Written / Expected (%" PRIx64
" / %" PRIx64
")",
100 uint64_t stream_size) {
105 "Unable to add directory for stream type "
106 "%x, offset is greater then 32 bit limit.",
113 "Unable to add directory for stream type %x, exceeded expected number "
114 "of directories %zu.",
119 LocationDescriptor loc;
120 loc.DataSize =
static_cast<llvm::support::ulittle32_t
>(stream_size);
125 dir.Type =
static_cast<llvm::support::little_t<StreamType>
>(type);
134 StreamType type = StreamType::LLDBGenerated;
140 const llvm::Triple &target_triple =
141 m_process_sp->GetTarget().GetArchitecture().GetTriple();
143 AddDirectory(StreamType::SystemInfo,
sizeof(llvm::minidump::SystemInfo));
147 llvm::minidump::ProcessorArchitecture arch;
148 switch (target_triple.getArch()) {
149 case llvm::Triple::ArchType::x86_64:
150 arch = ProcessorArchitecture::AMD64;
152 case llvm::Triple::ArchType::x86:
153 arch = ProcessorArchitecture::X86;
155 case llvm::Triple::ArchType::arm:
156 arch = ProcessorArchitecture::ARM;
158 case llvm::Triple::ArchType::aarch64:
159 arch = ProcessorArchitecture::ARM64;
161 case llvm::Triple::ArchType::mips64:
162 case llvm::Triple::ArchType::mips64el:
163 case llvm::Triple::ArchType::mips:
164 case llvm::Triple::ArchType::mipsel:
165 arch = ProcessorArchitecture::MIPS;
167 case llvm::Triple::ArchType::ppc64:
168 case llvm::Triple::ArchType::ppc:
169 case llvm::Triple::ArchType::ppc64le:
170 arch = ProcessorArchitecture::PPC;
174 "Architecture %s not supported.",
175 target_triple.getArchName().str().c_str());
179 llvm::support::little_t<OSPlatform> platform_id;
180 switch (target_triple.getOS()) {
181 case llvm::Triple::OSType::Linux:
182 if (target_triple.getEnvironment() ==
183 llvm::Triple::EnvironmentType::Android)
184 platform_id = OSPlatform::Android;
186 platform_id = OSPlatform::Linux;
188 case llvm::Triple::OSType::Win32:
189 platform_id = OSPlatform::Win32NT;
191 case llvm::Triple::OSType::MacOSX:
192 platform_id = OSPlatform::MacOSX;
194 case llvm::Triple::OSType::IOS:
195 platform_id = OSPlatform::IOS;
199 "OS %s not supported.", target_triple.getOSName().str().c_str());
203 llvm::minidump::SystemInfo sys_info;
204 sys_info.ProcessorArch =
205 static_cast<llvm::support::little_t<ProcessorArchitecture>
>(arch);
207 sys_info.CSDVersionRVA =
static_cast<llvm::support::ulittle32_t
>(
209 sys_info.PlatformId = platform_id;
212 std::string csd_string;
228 llvm::StringRef to_write_ref(to_write.c_str(), to_write.size() + 1);
229 llvm::SmallVector<llvm::UTF16, 128> to_write_utf16;
231 bool converted = convertUTF8ToUTF16String(to_write_ref, to_write_utf16);
234 "Unable to convert the string to UTF16. Failed to convert %s",
241 llvm::support::ulittle32_t to_write_size(to_write_utf16.size_in_bytes() - 2);
243 buffer->
AppendData(&to_write_size,
sizeof(llvm::support::ulittle32_t));
244 buffer->
AppendData(to_write_utf16.data(), to_write_utf16.size_in_bytes());
252 uint64_t SizeOfImage = 0;
253 if (mod->GetObjectFile()->CalculateType() == ObjectFile::Type::eTypeJIT) {
254 for (
const auto §ion : *mod->GetObjectFile()->GetSectionList()) {
255 SizeOfImage += section->GetByteSize();
259 SectionSP sect_sp = mod->GetObjectFile()->GetBaseAddress().GetSection();
262 return llvm::createStringError(std::errc::operation_not_supported,
263 "Couldn't obtain the section information.");
265 lldb::addr_t sect_addr = sect_sp->GetLoadBaseAddress(&target);
272 mod->GetObjectFile()->GetBaseAddress().GetLoadAddress(&target) -
274 SizeOfImage = sect_size - base_sect_offset;
279 while (next_sect_sp &&
280 next_sect_sp->GetLoadBaseAddress(&target) == next_sect_addr) {
281 sect_size = sect_sp->GetByteSize();
282 SizeOfImage += sect_size;
283 next_sect_addr += sect_size;
297 constexpr size_t minidump_module_size =
sizeof(llvm::minidump::Module);
302 llvm::support::ulittle32_t modules_count =
303 static_cast<llvm::support::ulittle32_t
>(modules.
GetSize());
313 size_t module_stream_size =
314 sizeof(llvm::support::ulittle32_t) + modules_count * minidump_module_size;
328 for (
size_t i = 0; i < modules_count; ++i) {
330 std::string module_name = mod->GetSpecificationDescription();
332 if (!maybe_mod_size) {
333 llvm::Error mod_size_err = maybe_mod_size.takeError();
334 llvm::handleAllErrors(std::move(mod_size_err),
335 [&](
const llvm::ErrorInfoBase &E) {
337 "Unable to get the size of module %s: %s.",
338 module_name.c_str(), E.message().c_str());
343 uint64_t mod_size = std::move(*maybe_mod_size);
345 llvm::support::ulittle32_t signature =
346 static_cast<llvm::support::ulittle32_t
>(
347 static_cast<uint32_t
>(minidump::CvSignature::ElfBuildId));
348 auto uuid = mod->GetUUID().GetBytes();
350 VSFixedFileInfo info;
351 info.Signature =
static_cast<llvm::support::ulittle32_t
>(0u);
352 info.StructVersion =
static_cast<llvm::support::ulittle32_t
>(0u);
353 info.FileVersionHigh =
static_cast<llvm::support::ulittle32_t
>(0u);
354 info.FileVersionLow =
static_cast<llvm::support::ulittle32_t
>(0u);
355 info.ProductVersionHigh =
static_cast<llvm::support::ulittle32_t
>(0u);
356 info.ProductVersionLow =
static_cast<llvm::support::ulittle32_t
>(0u);
357 info.FileFlagsMask =
static_cast<llvm::support::ulittle32_t
>(0u);
358 info.FileFlags =
static_cast<llvm::support::ulittle32_t
>(0u);
359 info.FileOS =
static_cast<llvm::support::ulittle32_t
>(0u);
360 info.FileType =
static_cast<llvm::support::ulittle32_t
>(0u);
361 info.FileSubtype =
static_cast<llvm::support::ulittle32_t
>(0u);
362 info.FileDateHigh =
static_cast<llvm::support::ulittle32_t
>(0u);
363 info.FileDateLow =
static_cast<llvm::support::ulittle32_t
>(0u);
365 LocationDescriptor ld;
366 ld.DataSize =
static_cast<llvm::support::ulittle32_t
>(0u);
367 ld.RVA =
static_cast<llvm::support::ulittle32_t
>(0u);
371 LocationDescriptor ld_cv;
372 ld_cv.DataSize =
static_cast<llvm::support::ulittle32_t
>(
373 sizeof(llvm::support::ulittle32_t) + uuid.size());
374 ld_cv.RVA =
static_cast<llvm::support::ulittle32_t
>(
375 size_before + module_stream_size + helper_data.
GetByteSize());
377 helper_data.
AppendData(&signature,
sizeof(llvm::support::ulittle32_t));
378 helper_data.
AppendData(uuid.begin(), uuid.size());
380 llvm::minidump::Module m;
381 m.BaseOfImage =
static_cast<llvm::support::ulittle64_t
>(
382 mod->GetObjectFile()->GetBaseAddress().GetLoadAddress(&target));
383 m.SizeOfImage =
static_cast<llvm::support::ulittle32_t
>(mod_size);
384 m.Checksum =
static_cast<llvm::support::ulittle32_t
>(0);
386 static_cast<llvm::support::ulittle32_t
>(std::time(
nullptr));
387 m.ModuleNameRVA =
static_cast<llvm::support::ulittle32_t
>(
388 size_before + module_stream_size + helper_data.
GetByteSize());
389 m.VersionInfo = info;
406 llvm::StringRef reg_name) {
411 bool success = reg_ctx->
ReadRegister(reg_info, reg_value);
418 llvm::StringRef reg_name) {
423 bool success = reg_ctx->
ReadRegister(reg_info, reg_value);
430 llvm::StringRef reg_name) {
435 bool success = reg_ctx->
ReadRegister(reg_info, reg_value);
442 llvm::StringRef reg_name) {
443 return static_cast<llvm::support::ulittle16_t
>(
448 llvm::StringRef reg_name) {
449 return static_cast<llvm::support::ulittle32_t
>(
454 llvm::StringRef reg_name) {
455 return static_cast<llvm::support::ulittle64_t
>(
468 if (bytes_copied == 16)
513 return thread_context;
520 minidump::RegisterContextMinidump_ARM64::Flags::ARM64_Flag |
521 minidump::RegisterContextMinidump_ARM64::Flags::Integer |
522 minidump::RegisterContextMinidump_ARM64::Flags::FloatingPoint);
524 for (uint32_t i = 0; i < 31; ++i) {
525 snprintf(reg_name,
sizeof(reg_name),
"x%u", i);
535 for (uint32_t i = 0; i < 32; ++i) {
536 snprintf(reg_name,
sizeof(reg_name),
"v%u", i);
539 return thread_context;
554 case llvm::Triple::ArchType::x86_64:
557 case llvm::Triple::ArchType::aarch64:
570 case llvm::Triple::ArchType::x86_64:
572 case llvm::Triple::ArchType::aarch64:
573 return sizeof(
arm64);
589 const llvm::minidump::Thread &thread = pair.second;
590 size_t bytes_to_write =
sizeof(llvm::minidump::Thread);
591 size_t bytes_written = bytes_to_write;
593 if (
error.Fail() || bytes_to_write != bytes_written) {
595 "Wrote incorrect number of bytes to minidump file. (written %zd/%zd)",
596 bytes_written, bytes_to_write);
605 constexpr size_t minidump_thread_size =
sizeof(llvm::minidump::Thread);
606 std::vector<ThreadSP> thread_list =
611 size_t thread_stream_size =
sizeof(llvm::support::ulittle32_t) +
612 thread_list.size() * minidump_thread_size;
620 llvm::support::ulittle32_t thread_count =
621 static_cast<llvm::support::ulittle32_t
>(thread_list.size());
629 for (
const ThreadSP &thread_sp : thread_list) {
642 "architecture %s not supported.",
643 arch.
GetTriple().getArchName().str().c_str());
647 uint64_t
sp = reg_ctx->
GetSP();
652 MemoryDescriptor stack;
653 LocationDescriptor empty_label;
654 empty_label.DataSize = 0;
656 stack.Memory = empty_label;
657 stack.StartOfMemoryRange = 0;
658 LocationDescriptor thread_context_memory_locator;
659 thread_context_memory_locator.DataSize =
660 static_cast<llvm::support::ulittle32_t
>(thread_context.
size());
661 thread_context_memory_locator.RVA =
static_cast<llvm::support::ulittle32_t
>(
662 size_before + thread_stream_size + helper_data.
GetByteSize());
666 LLDB_LOGF(log,
"AddThreadList for thread %d: thread_context %zu bytes",
667 thread_sp->GetIndexID(), thread_context.
size());
670 llvm::minidump::Thread t;
671 t.ThreadId =
static_cast<llvm::support::ulittle32_t
>(thread_sp->GetID());
672 t.SuspendCount =
static_cast<llvm::support::ulittle32_t
>(
673 (thread_sp->GetState() == StateType::eStateSuspended) ? 1 : 0);
674 t.PriorityClass =
static_cast<llvm::support::ulittle32_t
>(0);
675 t.Priority =
static_cast<llvm::support::ulittle32_t
>(0);
676 t.EnvironmentBlock =
static_cast<llvm::support::ulittle64_t
>(0);
677 t.Stack = stack, t.Context = thread_context_memory_locator;
684 LLDB_LOGF(log,
"AddThreadList(): total helper_data %" PRIx64
" bytes",
691 std::vector<ThreadSP> thread_list =
694 for (
const ThreadSP &thread_sp : thread_list) {
695 StopInfoSP stop_info_sp = thread_sp->GetStopInfo();
701 constexpr size_t minidump_exception_size =
702 sizeof(llvm::minidump::ExceptionStream);
709 exp_record.ExceptionCode =
710 static_cast<llvm::support::ulittle32_t
>(stop_info_sp->GetValue());
711 exp_record.ExceptionFlags =
712 static_cast<llvm::support::ulittle32_t
>(Exception::LLDB_FLAG);
713 exp_record.ExceptionRecord =
static_cast<llvm::support::ulittle64_t
>(0);
714 exp_record.ExceptionAddress = reg_ctx_sp->GetPC();
715 exp_record.NumberParameters =
static_cast<llvm::support::ulittle32_t
>(1);
716 std::string description = stop_info_sp->GetDescription();
719 memcpy(&exp_record.ExceptionInformation, description.c_str(),
720 std::max(description.size(), Exception::MaxParameterBytes));
721 exp_record.UnusedAlignment =
static_cast<llvm::support::ulittle32_t
>(0);
722 ExceptionStream exp_stream;
723 exp_stream.ThreadId =
724 static_cast<llvm::support::ulittle32_t
>(thread_sp->GetID());
725 exp_stream.UnusedAlignment =
static_cast<llvm::support::ulittle32_t
>(0);
726 exp_stream.ExceptionRecord = exp_record;
729 exp_stream.ThreadContext = Iter->second;
731 exp_stream.ThreadContext.DataSize = 0;
732 exp_stream.ThreadContext.RVA = 0;
748 misc_info.
size =
static_cast<llvm::support::ulittle32_t
>(
752 misc_info.
flags1 =
static_cast<llvm::support::ulittle32_t
>(0);
759 static_cast<llvm::support::ulittle32_t
>(
static_cast<uint32_t
>(
762 static_cast<llvm::support::ulittle32_t
>(process_info.
GetProcessID());
770std::unique_ptr<llvm::MemoryBuffer>
772 auto maybe_stream = llvm::MemoryBuffer::getFileAsStream(path);
775 return std::move(maybe_stream.get());
781 if (
m_process_sp->GetTarget().GetArchitecture().GetTriple().getOS() !=
785 std::vector<std::pair<StreamType, std::string>> files_with_stream_types = {
786 {StreamType::LinuxCPUInfo,
"/proc/cpuinfo"},
787 {StreamType::LinuxLSBRelease,
"/etc/lsb-release"},
794 std::string pid_str = std::to_string(pid);
795 files_with_stream_types.push_back(
796 {StreamType::LinuxProcStatus,
"/proc/" + pid_str +
"/status"});
797 files_with_stream_types.push_back(
798 {StreamType::LinuxCMDLine,
"/proc/" + pid_str +
"/cmdline"});
799 files_with_stream_types.push_back(
800 {StreamType::LinuxEnviron,
"/proc/" + pid_str +
"/environ"});
801 files_with_stream_types.push_back(
802 {StreamType::LinuxAuxv,
"/proc/" + pid_str +
"/auxv"});
803 files_with_stream_types.push_back(
804 {StreamType::LinuxMaps,
"/proc/" + pid_str +
"/maps"});
805 files_with_stream_types.push_back(
806 {StreamType::LinuxProcStat,
"/proc/" + pid_str +
"/stat"});
807 files_with_stream_types.push_back(
808 {StreamType::LinuxProcFD,
"/proc/" + pid_str +
"/fd"});
811 for (
const auto &entry : files_with_stream_types) {
812 StreamType stream = entry.first;
813 std::string path = entry.second;
817 size_t size = memory_buffer->getBufferSize();
837 std::vector<CoreFileMemoryRange> ranges_32;
838 std::vector<CoreFileMemoryRange> ranges_64;
841 all_core_memory_ranges);
847 all_core_memory_ranges.
GetSize());
848 std::vector<CoreFileMemoryRange> all_core_memory_vec;
851 for (
const auto &core_range : all_core_memory_ranges)
852 all_core_memory_vec.push_back(core_range.data);
857 auto iterator = all_core_memory_vec.begin();
858 while (iterator != all_core_memory_vec.end()) {
861 ranges_32.push_back(*iterator);
863 iterator->range.size() +
sizeof(llvm::minidump::MemoryDescriptor);
864 iterator = all_core_memory_vec.erase(iterator);
872 "Unable to write minidump. Stack memory "
873 "exceeds 32b limit. (Num Stacks %zu)",
884 if (!all_core_memory_vec.empty())
885 total_size += 256 + (all_core_memory_vec.size() *
886 sizeof(llvm::minidump::MemoryDescriptor_64));
888 for (
const auto &core_range : all_core_memory_vec) {
889 const addr_t range_size = core_range.range.size();
893 ranges_32.push_back(core_range);
894 total_size += range_size;
896 ranges_64.push_back(core_range);
905 if (!ranges_64.empty()) {
916 llvm::minidump::Header header;
917 header.Signature =
static_cast<llvm::support::ulittle32_t
>(
918 llvm::minidump::Header::MagicSignature);
919 header.Version =
static_cast<llvm::support::ulittle32_t
>(
920 llvm::minidump::Header::MagicVersion);
921 header.NumberOfStreams =
922 static_cast<llvm::support::ulittle32_t
>(
m_directories.size());
924 header.StreamDirectoryRVA =
925 static_cast<llvm::support::ulittle32_t
>(
HEADER_SIZE);
926 header.Checksum =
static_cast<llvm::support::ulittle32_t
>(
928 header.TimeDateStamp =
929 static_cast<llvm::support::ulittle32_t
>(std::time(
nullptr));
931 static_cast<llvm::support::ulittle64_t
>(0u);
934 size_t bytes_written;
942 "Unable to write the minidump header (written %zd/%zd)",
955 size_t bytes_written;
963 "unable to write the directory (written %zd/%zd)", bytes_written,
974 uint64_t max_size = 0;
975 for (
const auto &core_range : ranges)
976 max_size = std::max(max_size, core_range.range.size());
983 std::vector<MemoryDescriptor> descriptors;
985 if (ranges.size() == 0)
989 size_t region_index = 0;
992 for (
const auto &core_range : ranges) {
995 const addr_t addr = core_range.range.start();
996 const addr_t size = core_range.range.size();
997 const addr_t end = core_range.range.end();
1000 "AddMemoryList %zu/%zu reading memory for region "
1001 "(%" PRIx64
" bytes) [%" PRIx64
", %" PRIx64
")",
1002 region_index, ranges.size(), size, addr, addr + size);
1005 progress.
Increment(1,
"Adding Memory Range " + core_range.Dump());
1006 const size_t bytes_read =
1008 if (
error.Fail() || bytes_read == 0) {
1009 LLDB_LOGF(log,
"Failed to read memory region. Bytes read: %zu, error: %s",
1010 bytes_read,
error.AsCString());
1013 }
else if (bytes_read != size) {
1015 log,
"Memory region at: %" PRIx64
" failed to read %" PRIx64
" bytes",
1019 MemoryDescriptor descriptor;
1020 descriptor.StartOfMemoryRange =
1021 static_cast<llvm::support::ulittle64_t
>(addr);
1022 descriptor.Memory.DataSize =
1023 static_cast<llvm::support::ulittle32_t
>(bytes_read);
1024 descriptor.Memory.RVA =
1025 static_cast<llvm::support::ulittle32_t
>(offset_for_data);
1026 descriptors.push_back(descriptor);
1040 sizeof(llvm::minidump::MemoryListHeader) +
1041 descriptors.size() *
1042 sizeof(llvm::minidump::MemoryDescriptor));
1046 llvm::minidump::MemoryListHeader list_header;
1047 llvm::support::ulittle32_t memory_ranges_num =
1048 static_cast<llvm::support::ulittle32_t
>(descriptors.size());
1049 list_header.NumberOfMemoryRanges = memory_ranges_num;
1054 descriptors.size() *
sizeof(MemoryDescriptor));
1067 (
sizeof(llvm::support::ulittle64_t) * 2) +
1069 sizeof(llvm::minidump::MemoryDescriptor_64));
1073 llvm::minidump::Memory64ListHeader list_header;
1074 llvm::support::ulittle64_t memory_ranges_num =
1075 static_cast<llvm::support::ulittle64_t
>(ranges.size());
1076 list_header.NumberOfMemoryRanges = memory_ranges_num;
1085 (ranges.size() *
sizeof(llvm::minidump::MemoryDescriptor_64));
1086 llvm::support::ulittle64_t memory_ranges_base_rva =
1087 static_cast<llvm::support::ulittle64_t
>(base_rva);
1088 list_header.BaseRVA = memory_ranges_base_rva;
1089 m_data.
AppendData(&list_header,
sizeof(llvm::minidump::Memory64ListHeader));
1091 bool cleanup_required =
false;
1092 std::vector<MemoryDescriptor_64> descriptors;
1095 for (
const auto core_range : ranges) {
1097 MemoryDescriptor_64 memory_desc;
1098 memory_desc.StartOfMemoryRange =
1099 static_cast<llvm::support::ulittle64_t
>(core_range.range.start());
1100 memory_desc.DataSize =
1101 static_cast<llvm::support::ulittle64_t
>(core_range.range.size());
1102 descriptors.push_back(memory_desc);
1108 size_t region_index = 0;
1111 for (
const auto &core_range : ranges) {
1112 const addr_t addr = core_range.range.start();
1113 const addr_t size = core_range.range.size();
1116 "AddMemoryList_64 %zu/%zu reading memory for region "
1117 "(%" PRIx64
"bytes) "
1118 "[%" PRIx64
", %" PRIx64
")",
1119 region_index, ranges.size(), size, addr, addr + size);
1122 progress.
Increment(1,
"Adding Memory Range " + core_range.Dump());
1123 const size_t bytes_read =
1126 LLDB_LOGF(log,
"Failed to read memory region. Bytes read: %zu, error: %s",
1127 bytes_read,
error.AsCString());
1129 cleanup_required =
true;
1130 descriptors[region_index].DataSize = 0;
1132 if (bytes_read != size) {
1134 log,
"Memory region at: %" PRIx64
" failed to read %" PRIx64
" bytes",
1136 cleanup_required =
true;
1137 descriptors[region_index].DataSize = bytes_read;
1147 if (!cleanup_required) {
1154 size_t bytes_written =
sizeof(MemoryDescriptor_64) * descriptors.size();
1157 bytes_written !=
sizeof(MemoryDescriptor_64) * descriptors.size()) {
1159 "unable to write the memory descriptors (written %zd/%zd)",
1160 bytes_written,
sizeof(MemoryDescriptor_64) * descriptors.size());
1186 addr_t remaining_bytes = starting_size;
1189 while (remaining_bytes > 0) {
1190 size_t bytes_written = remaining_bytes;
1196 "Wrote incorrect number of bytes to minidump file. (written %" PRIx64
1198 starting_size - remaining_bytes, starting_size);
1202 offset += bytes_written;
1203 remaining_bytes -= bytes_written;
1237 LLDB_LOGF(log,
"Failed to close minidump file: %s",
error.AsCString());
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)
static uint64_t GetLargestRangeSize(const std::vector< CoreFileMemoryRange > &ranges)
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)
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 AddExceptions()
std::unordered_map< lldb::tid_t, llvm::minidump::LocationDescriptor > m_tid_to_reg_ctx
lldb_private::Status AddLLDBGeneratedStream()
lldb_private::Status AddThreadList()
lldb_private::Status AddHeaderAndCalculateDirectories()
uint64_t m_saved_data_size
static constexpr size_t DIRECTORY_SIZE
lldb_private::DataBufferHeap m_data
lldb_private::Status AddSystemInfo()
lldb_private::Status AddMemoryList()
std::unordered_map< lldb::addr_t, llvm::minidump::Thread > m_thread_by_range_end
lldb_private::Status AddData(const void *data, uint64_t size)
lldb_private::Status DumpFile()
lldb_private::SaveCoreOptions m_save_core_options
lldb_private::Status FlushBufferToDisk()
size_t m_expected_directories
lldb::offset_t m_thread_list_start
static constexpr size_t MAX_WRITE_CHUNK_SIZE
lldb_private::Status AddDirectory(llvm::minidump::StreamType type, uint64_t stream_size)
lldb_private::Status FixThreadStacks()
void DeleteFile() noexcept
lldb::ProcessSP m_process_sp
static constexpr size_t HEADER_SIZE
lldb::offset_t GetCurrentDataEndOffset() const
lldb_private::Status AddMemoryList_32(std::vector< lldb_private::CoreFileMemoryRange > &ranges, lldb_private::Progress &progress)
std::vector< llvm::minidump::Directory > m_directories
lldb_private::Status DumpDirectories() const
lldb_private::Status AddLinuxFileStreams()
lldb_private::Status AddModuleList()
lldb_private::Status AddMiscInfo()
lldb_private::Status DumpHeader() const
lldb_private::Status AddMemoryList_64(std::vector< lldb_private::CoreFileMemoryRange > &ranges, lldb_private::Progress &progress)
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)
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
A Progress indicator helper class.
void Increment(uint64_t amount=1, std::optional< std::string > updated_detail={})
Increment the progress and send a notification to the installed callback.
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
static Status FromErrorStringWithFormat(const char *format,...) __attribute__((format(printf
static Status FromErrorString(const char *str)
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
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::shared_ptr< lldb_private::StopInfo > StopInfoSP
std::shared_ptr< lldb_private::Section > SectionSP
StopReason
Thread stop reasons.
std::shared_ptr< lldb_private::RegisterContext > RegisterContextSP
std::shared_ptr< lldb_private::Module > ModuleSP
BaseType GetRangeEnd() 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 gs_base
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 fs_base
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