LLDB  mainline
MinidumpParser.cpp
Go to the documentation of this file.
1 //===-- MinidumpParser.cpp ------------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "MinidumpParser.h"
10 #include "NtStructures.h"
12 
15 #include "lldb/Utility/Log.h"
16 
17 // C includes
18 // C++ includes
19 #include <algorithm>
20 #include <map>
21 #include <vector>
22 #include <utility>
23 
24 using namespace lldb_private;
25 using namespace minidump;
26 
27 llvm::Expected<MinidumpParser>
28 MinidumpParser::Create(const lldb::DataBufferSP &data_sp) {
29  auto ExpectedFile = llvm::object::MinidumpFile::create(
30  llvm::MemoryBufferRef(toStringRef(data_sp->GetData()), "minidump"));
31  if (!ExpectedFile)
32  return ExpectedFile.takeError();
33 
34  return MinidumpParser(data_sp, std::move(*ExpectedFile));
35 }
36 
37 MinidumpParser::MinidumpParser(lldb::DataBufferSP data_sp,
38  std::unique_ptr<llvm::object::MinidumpFile> file)
39  : m_data_sp(std::move(data_sp)), m_file(std::move(file)) {}
40 
41 llvm::ArrayRef<uint8_t> MinidumpParser::GetData() {
42  return llvm::ArrayRef<uint8_t>(m_data_sp->GetBytes(),
43  m_data_sp->GetByteSize());
44 }
45 
46 llvm::ArrayRef<uint8_t> MinidumpParser::GetStream(StreamType stream_type) {
47  return m_file->getRawStream(stream_type)
48  .getValueOr(llvm::ArrayRef<uint8_t>());
49 }
50 
51 UUID MinidumpParser::GetModuleUUID(const minidump::Module *module) {
52  auto cv_record =
53  GetData().slice(module->CvRecord.RVA, module->CvRecord.DataSize);
54 
55  // Read the CV record signature
56  const llvm::support::ulittle32_t *signature = nullptr;
57  Status error = consumeObject(cv_record, signature);
58  if (error.Fail())
59  return UUID();
60 
61  const CvSignature cv_signature =
62  static_cast<CvSignature>(static_cast<uint32_t>(*signature));
63 
64  if (cv_signature == CvSignature::Pdb70) {
65  const CvRecordPdb70 *pdb70_uuid = nullptr;
66  Status error = consumeObject(cv_record, pdb70_uuid);
67  if (error.Fail())
68  return UUID();
69 
70  CvRecordPdb70 swapped;
71  if (!GetArchitecture().GetTriple().isOSBinFormatELF()) {
72  // LLDB's UUID class treats the data as a sequence of bytes, but breakpad
73  // interprets it as a sequence of little-endian fields, which it converts
74  // to big-endian when converting to text. Swap the bytes to big endian so
75  // that the string representation comes out right.
76  swapped = *pdb70_uuid;
77  llvm::sys::swapByteOrder(swapped.Uuid.Data1);
78  llvm::sys::swapByteOrder(swapped.Uuid.Data2);
79  llvm::sys::swapByteOrder(swapped.Uuid.Data3);
80  llvm::sys::swapByteOrder(swapped.Age);
81  pdb70_uuid = &swapped;
82  }
83  if (pdb70_uuid->Age != 0)
84  return UUID::fromOptionalData(pdb70_uuid, sizeof(*pdb70_uuid));
85  return UUID::fromOptionalData(&pdb70_uuid->Uuid, sizeof(pdb70_uuid->Uuid));
86  } else if (cv_signature == CvSignature::ElfBuildId)
87  return UUID::fromOptionalData(cv_record);
88 
89  return UUID();
90 }
91 
92 llvm::ArrayRef<minidump::Thread> MinidumpParser::GetThreads() {
93  auto ExpectedThreads = GetMinidumpFile().getThreadList();
94  if (ExpectedThreads)
95  return *ExpectedThreads;
96 
98  ExpectedThreads.takeError(),
99  "Failed to read thread list: {0}");
100  return {};
101 }
102 
103 llvm::ArrayRef<uint8_t>
104 MinidumpParser::GetThreadContext(const LocationDescriptor &location) {
105  if (location.RVA + location.DataSize > GetData().size())
106  return {};
107  return GetData().slice(location.RVA, location.DataSize);
108 }
109 
110 llvm::ArrayRef<uint8_t>
111 MinidumpParser::GetThreadContext(const minidump::Thread &td) {
112  return GetThreadContext(td.Context);
113 }
114 
115 llvm::ArrayRef<uint8_t>
116 MinidumpParser::GetThreadContextWow64(const minidump::Thread &td) {
117  // On Windows, a 32-bit process can run on a 64-bit machine under WOW64. If
118  // the minidump was captured with a 64-bit debugger, then the CONTEXT we just
119  // grabbed from the mini_dump_thread is the one for the 64-bit "native"
120  // process rather than the 32-bit "guest" process we care about. In this
121  // case, we can get the 32-bit CONTEXT from the TEB (Thread Environment
122  // Block) of the 64-bit process.
123  auto teb_mem = GetMemory(td.EnvironmentBlock, sizeof(TEB64));
124  if (teb_mem.empty())
125  return {};
126 
127  const TEB64 *wow64teb;
128  Status error = consumeObject(teb_mem, wow64teb);
129  if (error.Fail())
130  return {};
131 
132  // Slot 1 of the thread-local storage in the 64-bit TEB points to a structure
133  // that includes the 32-bit CONTEXT (after a ULONG). See:
134  // https://msdn.microsoft.com/en-us/library/ms681670.aspx
135  auto context =
136  GetMemory(wow64teb->tls_slots[1] + 4, sizeof(MinidumpContext_x86_32));
137  if (context.size() < sizeof(MinidumpContext_x86_32))
138  return {};
139 
140  return context;
141  // NOTE: We don't currently use the TEB for anything else. If we
142  // need it in the future, the 32-bit TEB is located according to the address
143  // stored in the first slot of the 64-bit TEB (wow64teb.Reserved1[0]).
144 }
145 
147  if (m_arch.IsValid())
148  return m_arch;
149 
150  // Set the architecture in m_arch
151  llvm::Expected<const SystemInfo &> system_info = m_file->getSystemInfo();
152 
153  if (!system_info) {
155  system_info.takeError(),
156  "Failed to read SystemInfo stream: {0}");
157  return m_arch;
158  }
159 
160  // TODO what to do about big endiand flavors of arm ?
161  // TODO set the arm subarch stuff if the minidump has info about it
162 
163  llvm::Triple triple;
164  triple.setVendor(llvm::Triple::VendorType::UnknownVendor);
165 
166  switch (system_info->ProcessorArch) {
167  case ProcessorArchitecture::X86:
168  triple.setArch(llvm::Triple::ArchType::x86);
169  break;
170  case ProcessorArchitecture::AMD64:
171  triple.setArch(llvm::Triple::ArchType::x86_64);
172  break;
173  case ProcessorArchitecture::ARM:
174  triple.setArch(llvm::Triple::ArchType::arm);
175  break;
176  case ProcessorArchitecture::ARM64:
177  case ProcessorArchitecture::BP_ARM64:
178  triple.setArch(llvm::Triple::ArchType::aarch64);
179  break;
180  default:
181  triple.setArch(llvm::Triple::ArchType::UnknownArch);
182  break;
183  }
184 
185  // TODO add all of the OSes that Minidump/breakpad distinguishes?
186  switch (system_info->PlatformId) {
187  case OSPlatform::Win32S:
188  case OSPlatform::Win32Windows:
189  case OSPlatform::Win32NT:
190  case OSPlatform::Win32CE:
191  triple.setOS(llvm::Triple::OSType::Win32);
192  triple.setVendor(llvm::Triple::VendorType::PC);
193  break;
194  case OSPlatform::Linux:
195  triple.setOS(llvm::Triple::OSType::Linux);
196  break;
197  case OSPlatform::MacOSX:
198  triple.setOS(llvm::Triple::OSType::MacOSX);
199  triple.setVendor(llvm::Triple::Apple);
200  break;
201  case OSPlatform::IOS:
202  triple.setOS(llvm::Triple::OSType::IOS);
203  triple.setVendor(llvm::Triple::Apple);
204  break;
205  case OSPlatform::Android:
206  triple.setOS(llvm::Triple::OSType::Linux);
207  triple.setEnvironment(llvm::Triple::EnvironmentType::Android);
208  break;
209  default: {
210  triple.setOS(llvm::Triple::OSType::UnknownOS);
211  auto ExpectedCSD = m_file->getString(system_info->CSDVersionRVA);
212  if (!ExpectedCSD) {
214  ExpectedCSD.takeError(),
215  "Failed to CSD Version string: {0}");
216  } else {
217  if (ExpectedCSD->find("Linux") != std::string::npos)
218  triple.setOS(llvm::Triple::OSType::Linux);
219  }
220  break;
221  }
222  }
223  m_arch.SetTriple(triple);
224  return m_arch;
225 }
226 
228  llvm::ArrayRef<uint8_t> data = GetStream(StreamType::MiscInfo);
229 
230  if (data.size() == 0)
231  return nullptr;
232 
233  return MinidumpMiscInfo::Parse(data);
234 }
235 
236 llvm::Optional<LinuxProcStatus> MinidumpParser::GetLinuxProcStatus() {
237  llvm::ArrayRef<uint8_t> data = GetStream(StreamType::LinuxProcStatus);
238 
239  if (data.size() == 0)
240  return llvm::None;
241 
242  return LinuxProcStatus::Parse(data);
243 }
244 
245 llvm::Optional<lldb::pid_t> MinidumpParser::GetPid() {
246  const MinidumpMiscInfo *misc_info = GetMiscInfo();
247  if (misc_info != nullptr) {
248  return misc_info->GetPid();
249  }
250 
251  llvm::Optional<LinuxProcStatus> proc_status = GetLinuxProcStatus();
252  if (proc_status.hasValue()) {
253  return proc_status->GetPid();
254  }
255 
256  return llvm::None;
257 }
258 
259 llvm::ArrayRef<minidump::Module> MinidumpParser::GetModuleList() {
260  auto ExpectedModules = GetMinidumpFile().getModuleList();
261  if (ExpectedModules)
262  return *ExpectedModules;
263 
265  ExpectedModules.takeError(),
266  "Failed to read module list: {0}");
267  return {};
268 }
269 
270 std::vector<const minidump::Module *> MinidumpParser::GetFilteredModuleList() {
272  auto ExpectedModules = GetMinidumpFile().getModuleList();
273  if (!ExpectedModules) {
274  LLDB_LOG_ERROR(log, ExpectedModules.takeError(),
275  "Failed to read module list: {0}");
276  return {};
277  }
278 
279  // map module_name -> filtered_modules index
280  typedef llvm::StringMap<size_t> MapType;
281  MapType module_name_to_filtered_index;
282 
283  std::vector<const minidump::Module *> filtered_modules;
284 
285  for (const auto &module : *ExpectedModules) {
286  auto ExpectedName = m_file->getString(module.ModuleNameRVA);
287  if (!ExpectedName) {
288  LLDB_LOG_ERROR(log, ExpectedName.takeError(),
289  "Failed to get module name: {0}");
290  continue;
291  }
292 
293  MapType::iterator iter;
294  bool inserted;
295  // See if we have inserted this module aready into filtered_modules. If we
296  // haven't insert an entry into module_name_to_filtered_index with the
297  // index where we will insert it if it isn't in the vector already.
298  std::tie(iter, inserted) = module_name_to_filtered_index.try_emplace(
299  *ExpectedName, filtered_modules.size());
300 
301  if (inserted) {
302  // This module has not been seen yet, insert it into filtered_modules at
303  // the index that was inserted into module_name_to_filtered_index using
304  // "filtered_modules.size()" above.
305  filtered_modules.push_back(&module);
306  } else {
307  // This module has been seen. Modules are sometimes mentioned multiple
308  // times when they are mapped discontiguously, so find the module with
309  // the lowest "base_of_image" and use that as the filtered module.
310  auto dup_module = filtered_modules[iter->second];
311  if (module.BaseOfImage < dup_module->BaseOfImage)
312  filtered_modules[iter->second] = &module;
313  }
314  }
315  return filtered_modules;
316 }
317 
318 const minidump::ExceptionStream *MinidumpParser::GetExceptionStream() {
319  auto ExpectedStream = GetMinidumpFile().getExceptionStream();
320  if (ExpectedStream)
321  return &*ExpectedStream;
322 
324  ExpectedStream.takeError(),
325  "Failed to read minidump exception stream: {0}");
326  return nullptr;
327 }
328 
329 llvm::Optional<minidump::Range>
331  llvm::ArrayRef<uint8_t> data64 = GetStream(StreamType::Memory64List);
333 
334  auto ExpectedMemory = GetMinidumpFile().getMemoryList();
335  if (!ExpectedMemory) {
336  LLDB_LOG_ERROR(log, ExpectedMemory.takeError(),
337  "Failed to read memory list: {0}");
338  } else {
339  for (const auto &memory_desc : *ExpectedMemory) {
340  const LocationDescriptor &loc_desc = memory_desc.Memory;
341  const lldb::addr_t range_start = memory_desc.StartOfMemoryRange;
342  const size_t range_size = loc_desc.DataSize;
343 
344  if (loc_desc.RVA + loc_desc.DataSize > GetData().size())
345  return llvm::None;
346 
347  if (range_start <= addr && addr < range_start + range_size) {
348  auto ExpectedSlice = GetMinidumpFile().getRawData(loc_desc);
349  if (!ExpectedSlice) {
350  LLDB_LOG_ERROR(log, ExpectedSlice.takeError(),
351  "Failed to get memory slice: {0}");
352  return llvm::None;
353  }
354  return minidump::Range(range_start, *ExpectedSlice);
355  }
356  }
357  }
358 
359  // Some Minidumps have a Memory64ListStream that captures all the heap memory
360  // (full-memory Minidumps). We can't exactly use the same loop as above,
361  // because the Minidump uses slightly different data structures to describe
362  // those
363 
364  if (!data64.empty()) {
365  llvm::ArrayRef<MinidumpMemoryDescriptor64> memory64_list;
366  uint64_t base_rva;
367  std::tie(memory64_list, base_rva) =
369 
370  if (memory64_list.empty())
371  return llvm::None;
372 
373  for (const auto &memory_desc64 : memory64_list) {
374  const lldb::addr_t range_start = memory_desc64.start_of_memory_range;
375  const size_t range_size = memory_desc64.data_size;
376 
377  if (base_rva + range_size > GetData().size())
378  return llvm::None;
379 
380  if (range_start <= addr && addr < range_start + range_size) {
381  return minidump::Range(range_start,
382  GetData().slice(base_rva, range_size));
383  }
384  base_rva += range_size;
385  }
386  }
387 
388  return llvm::None;
389 }
390 
391 llvm::ArrayRef<uint8_t> MinidumpParser::GetMemory(lldb::addr_t addr,
392  size_t size) {
393  // I don't have a sense of how frequently this is called or how many memory
394  // ranges a Minidump typically has, so I'm not sure if searching for the
395  // appropriate range linearly each time is stupid. Perhaps we should build
396  // an index for faster lookups.
397  llvm::Optional<minidump::Range> range = FindMemoryRange(addr);
398  if (!range)
399  return {};
400 
401  // There's at least some overlap between the beginning of the desired range
402  // (addr) and the current range. Figure out where the overlap begins and how
403  // much overlap there is.
404 
405  const size_t offset = addr - range->start;
406 
407  if (addr < range->start || offset >= range->range_ref.size())
408  return {};
409 
410  const size_t overlap = std::min(size, range->range_ref.size() - offset);
411  return range->range_ref.slice(offset, overlap);
412 }
413 
414 static bool
416  std::vector<MemoryRegionInfo> &regions) {
417  auto data = parser.GetStream(StreamType::LinuxMaps);
418  if (data.empty())
419  return false;
420  ParseLinuxMapRegions(llvm::toStringRef(data),
421  [&](const lldb_private::MemoryRegionInfo &region,
422  const lldb_private::Status &status) -> bool {
423  if (status.Success())
424  regions.push_back(region);
425  return true;
426  });
427  return !regions.empty();
428 }
429 
430 static bool
432  std::vector<MemoryRegionInfo> &regions) {
434  auto ExpectedInfo = parser.GetMinidumpFile().getMemoryInfoList();
435  if (!ExpectedInfo) {
436  LLDB_LOG_ERROR(log, ExpectedInfo.takeError(),
437  "Failed to read memory info list: {0}");
438  return false;
439  }
440  constexpr auto yes = MemoryRegionInfo::eYes;
441  constexpr auto no = MemoryRegionInfo::eNo;
442  for (const MemoryInfo &entry : *ExpectedInfo) {
443  MemoryRegionInfo region;
444  region.GetRange().SetRangeBase(entry.BaseAddress);
445  region.GetRange().SetByteSize(entry.RegionSize);
446 
447  MemoryProtection prot = entry.Protect;
448  region.SetReadable(bool(prot & MemoryProtection::NoAccess) ? no : yes);
449  region.SetWritable(
450  bool(prot & (MemoryProtection::ReadWrite | MemoryProtection::WriteCopy |
451  MemoryProtection::ExecuteReadWrite |
452  MemoryProtection::ExeciteWriteCopy))
453  ? yes
454  : no);
455  region.SetExecutable(
456  bool(prot & (MemoryProtection::Execute | MemoryProtection::ExecuteRead |
457  MemoryProtection::ExecuteReadWrite |
458  MemoryProtection::ExeciteWriteCopy))
459  ? yes
460  : no);
461  region.SetMapped(entry.State != MemoryState::Free ? yes : no);
462  regions.push_back(region);
463  }
464  return !regions.empty();
465 }
466 
467 static bool
469  std::vector<MemoryRegionInfo> &regions) {
471  auto ExpectedMemory = parser.GetMinidumpFile().getMemoryList();
472  if (!ExpectedMemory) {
473  LLDB_LOG_ERROR(log, ExpectedMemory.takeError(),
474  "Failed to read memory list: {0}");
475  return false;
476  }
477  regions.reserve(ExpectedMemory->size());
478  for (const MemoryDescriptor &memory_desc : *ExpectedMemory) {
479  if (memory_desc.Memory.DataSize == 0)
480  continue;
481  MemoryRegionInfo region;
482  region.GetRange().SetRangeBase(memory_desc.StartOfMemoryRange);
483  region.GetRange().SetByteSize(memory_desc.Memory.DataSize);
486  regions.push_back(region);
487  }
488  regions.shrink_to_fit();
489  return !regions.empty();
490 }
491 
492 static bool
494  std::vector<MemoryRegionInfo> &regions) {
495  llvm::ArrayRef<uint8_t> data =
496  parser.GetStream(StreamType::Memory64List);
497  if (data.empty())
498  return false;
499  llvm::ArrayRef<MinidumpMemoryDescriptor64> memory64_list;
500  uint64_t base_rva;
501  std::tie(memory64_list, base_rva) =
503 
504  if (memory64_list.empty())
505  return false;
506 
507  regions.reserve(memory64_list.size());
508  for (const auto &memory_desc : memory64_list) {
509  if (memory_desc.data_size == 0)
510  continue;
511  MemoryRegionInfo region;
512  region.GetRange().SetRangeBase(memory_desc.start_of_memory_range);
513  region.GetRange().SetByteSize(memory_desc.data_size);
516  regions.push_back(region);
517  }
518  regions.shrink_to_fit();
519  return !regions.empty();
520 }
521 
522 std::pair<MemoryRegionInfos, bool> MinidumpParser::BuildMemoryRegions() {
523  // We create the region cache using the best source. We start with
524  // the linux maps since they are the most complete and have names for the
525  // regions. Next we try the MemoryInfoList since it has
526  // read/write/execute/map data, and then fall back to the MemoryList and
527  // Memory64List to just get a list of the memory that is mapped in this
528  // core file
529  MemoryRegionInfos result;
530  const auto &return_sorted = [&](bool is_complete) {
531  llvm::sort(result);
532  return std::make_pair(std::move(result), is_complete);
533  };
534  if (CreateRegionsCacheFromLinuxMaps(*this, result))
535  return return_sorted(true);
536  if (CreateRegionsCacheFromMemoryInfoList(*this, result))
537  return return_sorted(true);
538  if (CreateRegionsCacheFromMemoryList(*this, result))
539  return return_sorted(false);
540  CreateRegionsCacheFromMemory64List(*this, result);
541  return return_sorted(false);
542 }
543 
544 #define ENUM_TO_CSTR(ST) \
545  case StreamType::ST: \
546  return #ST
547 
548 llvm::StringRef
549 MinidumpParser::GetStreamTypeAsString(StreamType stream_type) {
550  switch (stream_type) {
551  ENUM_TO_CSTR(Unused);
554  ENUM_TO_CSTR(MemoryList);
555  ENUM_TO_CSTR(Exception);
556  ENUM_TO_CSTR(SystemInfo);
557  ENUM_TO_CSTR(ThreadExList);
558  ENUM_TO_CSTR(Memory64List);
559  ENUM_TO_CSTR(CommentA);
560  ENUM_TO_CSTR(CommentW);
561  ENUM_TO_CSTR(HandleData);
562  ENUM_TO_CSTR(FunctionTable);
563  ENUM_TO_CSTR(UnloadedModuleList);
564  ENUM_TO_CSTR(MiscInfo);
565  ENUM_TO_CSTR(MemoryInfoList);
566  ENUM_TO_CSTR(ThreadInfoList);
567  ENUM_TO_CSTR(HandleOperationList);
569  ENUM_TO_CSTR(JavascriptData);
570  ENUM_TO_CSTR(SystemMemoryInfo);
571  ENUM_TO_CSTR(ProcessVMCounters);
572  ENUM_TO_CSTR(LastReserved);
573  ENUM_TO_CSTR(BreakpadInfo);
574  ENUM_TO_CSTR(AssertionInfo);
575  ENUM_TO_CSTR(LinuxCPUInfo);
577  ENUM_TO_CSTR(LinuxLSBRelease);
578  ENUM_TO_CSTR(LinuxCMDLine);
579  ENUM_TO_CSTR(LinuxEnviron);
580  ENUM_TO_CSTR(LinuxAuxv);
581  ENUM_TO_CSTR(LinuxMaps);
582  ENUM_TO_CSTR(LinuxDSODebug);
583  ENUM_TO_CSTR(LinuxProcStat);
584  ENUM_TO_CSTR(LinuxProcUptime);
585  ENUM_TO_CSTR(LinuxProcFD);
586  ENUM_TO_CSTR(FacebookAppCustomData);
587  ENUM_TO_CSTR(FacebookBuildID);
588  ENUM_TO_CSTR(FacebookAppVersionName);
589  ENUM_TO_CSTR(FacebookJavaStack);
590  ENUM_TO_CSTR(FacebookDalvikInfo);
591  ENUM_TO_CSTR(FacebookUnwindSymbols);
592  ENUM_TO_CSTR(FacebookDumpErrorLog);
593  ENUM_TO_CSTR(FacebookAppStateLog);
594  ENUM_TO_CSTR(FacebookAbortReason);
595  ENUM_TO_CSTR(FacebookThreadName);
596  ENUM_TO_CSTR(FacebookLogcat);
597  }
598  return "unknown stream type";
599 }
llvm::support::ulittle64_t tls_slots[64]
#define LIBLLDB_LOG_PROCESS
Definition: Logging.h:15
A class that represents a running process on the host machine.
void SetExecutable(OptionalBool val)
llvm::ArrayRef< uint8_t > GetStream(StreamType stream_type)
llvm::Optional< LinuxProcStatus > GetLinuxProcStatus()
bool SetTriple(const llvm::Triple &triple)
Architecture triple setter.
Definition: ArchSpec.cpp:786
llvm::ArrayRef< uint8_t > GetMemory(lldb::addr_t addr, size_t size)
llvm::support::ulittle16_t Data2
Definition: MinidumpTypes.h:48
static UUID fromOptionalData(const void *bytes, uint32_t num_bytes)
Creates a UUID from the data pointed to by the bytes argument.
Definition: UUID.h:40
An architecture specification class.
Definition: ArchSpec.h:33
llvm::ArrayRef< minidump::Module > GetModuleList()
llvm::support::ulittle32_t Data1
Definition: MinidumpTypes.h:47
void SetMapped(OptionalBool val)
#define LIBLLDB_LOG_MODULES
Definition: Logging.h:35
llvm::Optional< Range > FindMemoryRange(lldb::addr_t addr)
void ParseLinuxMapRegions(llvm::StringRef linux_map, LinuxMapCallback const &callback)
bool IsValid() const
Tests if this ArchSpec is valid.
Definition: ArchSpec.h:332
std::unique_ptr< llvm::object::MinidumpFile > m_file
#define LLDB_LOG_ERROR(log, error,...)
Definition: Log.h:265
const MinidumpMiscInfo * GetMiscInfo()
llvm::Triple & GetTriple()
Architecture triple accessor.
Definition: ArchSpec.h:434
llvm::ArrayRef< uint8_t > GetData()
llvm::Optional< lldb::pid_t > GetPid() const
llvm::ArrayRef< uint8_t > GetThreadContextWow64(const minidump::Thread &td)
llvm::Optional< lldb::pid_t > GetPid()
llvm::ArrayRef< minidump::Thread > GetThreads()
A collection class for Module objects.
Definition: ModuleList.h:71
#define LIBLLDB_LOG_THREAD
Definition: Logging.h:16
struct lldb_private::minidump::CvRecordPdb70::@79 Uuid
llvm::ArrayRef< uint8_t > GetThreadContext(const LocationDescriptor &location)
std::vector< const minidump::Module * > GetFilteredModuleList()
bool Success() const
Test for success condition.
Definition: Status.cpp:288
Status consumeObject(llvm::ArrayRef< uint8_t > &Buffer, const T *&Object)
Definition: MinidumpTypes.h:65
static bool CreateRegionsCacheFromMemoryInfoList(MinidumpParser &parser, std::vector< MemoryRegionInfo > &regions)
static bool CreateRegionsCacheFromLinuxMaps(MinidumpParser &parser, std::vector< MemoryRegionInfo > &regions)
static llvm::StringRef GetStreamTypeAsString(StreamType stream_type)
static std::pair< llvm::ArrayRef< MinidumpMemoryDescriptor64 >, uint64_t > ParseMemory64List(llvm::ArrayRef< uint8_t > &data)
static bool CreateRegionsCacheFromMemory64List(MinidumpParser &parser, std::vector< MemoryRegionInfo > &regions)
void SetByteSize(SizeType s)
Definition: RangeMap.h:73
llvm::support::ulittle16_t Data3
Definition: MinidumpTypes.h:49
uint64_t addr_t
Definition: lldb-types.h:83
void SetReadable(OptionalBool val)
static llvm::Expected< MinidumpParser > Create(const lldb::DataBufferSP &data_buf_sp)
bool Fail() const
Test for error condition.
Definition: Status.cpp:182
Log * GetLogIfAnyCategoriesSet(uint32_t mask)
Definition: Logging.cpp:62
std::pair< MemoryRegionInfos, bool > BuildMemoryRegions()
Returns a list of memory regions and a flag indicating whether the list is complete (includes all reg...
#define ENUM_TO_CSTR(ST)
UUID GetModuleUUID(const minidump::Module *module)
llvm::support::ulittle32_t Age
Definition: MinidumpTypes.h:52
void SetRangeBase(BaseType b)
Definition: RangeMap.h:48
void SetWritable(OptionalBool val)
static const MinidumpMiscInfo * Parse(llvm::ArrayRef< uint8_t > &data)
static llvm::Optional< LinuxProcStatus > Parse(llvm::ArrayRef< uint8_t > &data)
const llvm::minidump::ExceptionStream * GetExceptionStream()
static bool CreateRegionsCacheFromMemoryList(MinidumpParser &parser, std::vector< MemoryRegionInfo > &regions)
llvm::object::MinidumpFile & GetMinidumpFile()
MinidumpParser(lldb::DataBufferSP data_sp, std::unique_ptr< llvm::object::MinidumpFile > file)
An error handling class.
Definition: Status.h:44