• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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"
11 #include "RegisterContextMinidump_x86_32.h"
12 
13 #include "Plugins/Process/Utility/LinuxProcMaps.h"
14 #include "lldb/Utility/LLDBAssert.h"
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>
Create(const lldb::DataBufferSP & data_sp)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 
MinidumpParser(lldb::DataBufferSP data_sp,std::unique_ptr<llvm::object::MinidumpFile> file)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 
GetData()41 llvm::ArrayRef<uint8_t> MinidumpParser::GetData() {
42   return llvm::ArrayRef<uint8_t>(m_data_sp->GetBytes(),
43                                  m_data_sp->GetByteSize());
44 }
45 
GetStream(StreamType stream_type)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 
GetModuleUUID(const minidump::Module * module)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 UUID::CvRecordPdb70 *pdb70_uuid = nullptr;
66     Status error = consumeObject(cv_record, pdb70_uuid);
67     if (error.Fail())
68       return UUID();
69     if (GetArchitecture().GetTriple().isOSBinFormatELF()) {
70       if (pdb70_uuid->Age != 0)
71         return UUID::fromOptionalData(pdb70_uuid, sizeof(*pdb70_uuid));
72       return UUID::fromOptionalData(&pdb70_uuid->Uuid,
73                                     sizeof(pdb70_uuid->Uuid));
74     }
75     return UUID::fromCvRecord(*pdb70_uuid);
76   } else if (cv_signature == CvSignature::ElfBuildId)
77     return UUID::fromOptionalData(cv_record);
78 
79   return UUID();
80 }
81 
GetThreads()82 llvm::ArrayRef<minidump::Thread> MinidumpParser::GetThreads() {
83   auto ExpectedThreads = GetMinidumpFile().getThreadList();
84   if (ExpectedThreads)
85     return *ExpectedThreads;
86 
87   LLDB_LOG_ERROR(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD),
88                  ExpectedThreads.takeError(),
89                  "Failed to read thread list: {0}");
90   return {};
91 }
92 
93 llvm::ArrayRef<uint8_t>
GetThreadContext(const LocationDescriptor & location)94 MinidumpParser::GetThreadContext(const LocationDescriptor &location) {
95   if (location.RVA + location.DataSize > GetData().size())
96     return {};
97   return GetData().slice(location.RVA, location.DataSize);
98 }
99 
100 llvm::ArrayRef<uint8_t>
GetThreadContext(const minidump::Thread & td)101 MinidumpParser::GetThreadContext(const minidump::Thread &td) {
102   return GetThreadContext(td.Context);
103 }
104 
105 llvm::ArrayRef<uint8_t>
GetThreadContextWow64(const minidump::Thread & td)106 MinidumpParser::GetThreadContextWow64(const minidump::Thread &td) {
107   // On Windows, a 32-bit process can run on a 64-bit machine under WOW64. If
108   // the minidump was captured with a 64-bit debugger, then the CONTEXT we just
109   // grabbed from the mini_dump_thread is the one for the 64-bit "native"
110   // process rather than the 32-bit "guest" process we care about.  In this
111   // case, we can get the 32-bit CONTEXT from the TEB (Thread Environment
112   // Block) of the 64-bit process.
113   auto teb_mem = GetMemory(td.EnvironmentBlock, sizeof(TEB64));
114   if (teb_mem.empty())
115     return {};
116 
117   const TEB64 *wow64teb;
118   Status error = consumeObject(teb_mem, wow64teb);
119   if (error.Fail())
120     return {};
121 
122   // Slot 1 of the thread-local storage in the 64-bit TEB points to a structure
123   // that includes the 32-bit CONTEXT (after a ULONG). See:
124   // https://msdn.microsoft.com/en-us/library/ms681670.aspx
125   auto context =
126       GetMemory(wow64teb->tls_slots[1] + 4, sizeof(MinidumpContext_x86_32));
127   if (context.size() < sizeof(MinidumpContext_x86_32))
128     return {};
129 
130   return context;
131   // NOTE:  We don't currently use the TEB for anything else.  If we
132   // need it in the future, the 32-bit TEB is located according to the address
133   // stored in the first slot of the 64-bit TEB (wow64teb.Reserved1[0]).
134 }
135 
GetArchitecture()136 ArchSpec MinidumpParser::GetArchitecture() {
137   if (m_arch.IsValid())
138     return m_arch;
139 
140   // Set the architecture in m_arch
141   llvm::Expected<const SystemInfo &> system_info = m_file->getSystemInfo();
142 
143   if (!system_info) {
144     LLDB_LOG_ERROR(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS),
145                    system_info.takeError(),
146                    "Failed to read SystemInfo stream: {0}");
147     return m_arch;
148   }
149 
150   // TODO what to do about big endiand flavors of arm ?
151   // TODO set the arm subarch stuff if the minidump has info about it
152 
153   llvm::Triple triple;
154   triple.setVendor(llvm::Triple::VendorType::UnknownVendor);
155 
156   switch (system_info->ProcessorArch) {
157   case ProcessorArchitecture::X86:
158     triple.setArch(llvm::Triple::ArchType::x86);
159     break;
160   case ProcessorArchitecture::AMD64:
161     triple.setArch(llvm::Triple::ArchType::x86_64);
162     break;
163   case ProcessorArchitecture::ARM:
164     triple.setArch(llvm::Triple::ArchType::arm);
165     break;
166   case ProcessorArchitecture::ARM64:
167   case ProcessorArchitecture::BP_ARM64:
168     triple.setArch(llvm::Triple::ArchType::aarch64);
169     break;
170   default:
171     triple.setArch(llvm::Triple::ArchType::UnknownArch);
172     break;
173   }
174 
175   // TODO add all of the OSes that Minidump/breakpad distinguishes?
176   switch (system_info->PlatformId) {
177   case OSPlatform::Win32S:
178   case OSPlatform::Win32Windows:
179   case OSPlatform::Win32NT:
180   case OSPlatform::Win32CE:
181     triple.setOS(llvm::Triple::OSType::Win32);
182     triple.setVendor(llvm::Triple::VendorType::PC);
183     break;
184   case OSPlatform::Linux:
185     triple.setOS(llvm::Triple::OSType::Linux);
186     break;
187   case OSPlatform::MacOSX:
188     triple.setOS(llvm::Triple::OSType::MacOSX);
189     triple.setVendor(llvm::Triple::Apple);
190     break;
191   case OSPlatform::IOS:
192     triple.setOS(llvm::Triple::OSType::IOS);
193     triple.setVendor(llvm::Triple::Apple);
194     break;
195   case OSPlatform::Android:
196     triple.setOS(llvm::Triple::OSType::Linux);
197     triple.setEnvironment(llvm::Triple::EnvironmentType::Android);
198     break;
199   default: {
200     triple.setOS(llvm::Triple::OSType::UnknownOS);
201     auto ExpectedCSD = m_file->getString(system_info->CSDVersionRVA);
202     if (!ExpectedCSD) {
203       LLDB_LOG_ERROR(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS),
204                      ExpectedCSD.takeError(),
205                      "Failed to CSD Version string: {0}");
206     } else {
207       if (ExpectedCSD->find("Linux") != std::string::npos)
208         triple.setOS(llvm::Triple::OSType::Linux);
209     }
210     break;
211   }
212   }
213   m_arch.SetTriple(triple);
214   return m_arch;
215 }
216 
GetMiscInfo()217 const MinidumpMiscInfo *MinidumpParser::GetMiscInfo() {
218   llvm::ArrayRef<uint8_t> data = GetStream(StreamType::MiscInfo);
219 
220   if (data.size() == 0)
221     return nullptr;
222 
223   return MinidumpMiscInfo::Parse(data);
224 }
225 
GetLinuxProcStatus()226 llvm::Optional<LinuxProcStatus> MinidumpParser::GetLinuxProcStatus() {
227   llvm::ArrayRef<uint8_t> data = GetStream(StreamType::LinuxProcStatus);
228 
229   if (data.size() == 0)
230     return llvm::None;
231 
232   return LinuxProcStatus::Parse(data);
233 }
234 
GetPid()235 llvm::Optional<lldb::pid_t> MinidumpParser::GetPid() {
236   const MinidumpMiscInfo *misc_info = GetMiscInfo();
237   if (misc_info != nullptr) {
238     return misc_info->GetPid();
239   }
240 
241   llvm::Optional<LinuxProcStatus> proc_status = GetLinuxProcStatus();
242   if (proc_status.hasValue()) {
243     return proc_status->GetPid();
244   }
245 
246   return llvm::None;
247 }
248 
GetModuleList()249 llvm::ArrayRef<minidump::Module> MinidumpParser::GetModuleList() {
250   auto ExpectedModules = GetMinidumpFile().getModuleList();
251   if (ExpectedModules)
252     return *ExpectedModules;
253 
254   LLDB_LOG_ERROR(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_MODULES),
255                  ExpectedModules.takeError(),
256                  "Failed to read module list: {0}");
257   return {};
258 }
259 
260 static bool
CreateRegionsCacheFromLinuxMaps(MinidumpParser & parser,std::vector<MemoryRegionInfo> & regions)261 CreateRegionsCacheFromLinuxMaps(MinidumpParser &parser,
262                                 std::vector<MemoryRegionInfo> &regions) {
263   auto data = parser.GetStream(StreamType::LinuxMaps);
264   if (data.empty())
265     return false;
266 
267   Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS);
268   ParseLinuxMapRegions(
269       llvm::toStringRef(data),
270       [&regions, &log](llvm::Expected<MemoryRegionInfo> region) -> bool {
271         if (region)
272           regions.push_back(*region);
273         else
274           LLDB_LOG_ERROR(log, region.takeError(),
275                          "Reading memory region from minidump failed: {0}");
276         return true;
277       });
278   return !regions.empty();
279 }
280 
281 /// Check for the memory regions starting at \a load_addr for a contiguous
282 /// section that has execute permissions that matches the module path.
283 ///
284 /// When we load a breakpad generated minidump file, we might have the
285 /// /proc/<pid>/maps text for a process that details the memory map of the
286 /// process that the minidump is describing. This checks the sorted memory
287 /// regions for a section that has execute permissions. A sample maps files
288 /// might look like:
289 ///
290 /// 00400000-00401000 r--p 00000000 fd:01 2838574           /tmp/a.out
291 /// 00401000-00402000 r-xp 00001000 fd:01 2838574           /tmp/a.out
292 /// 00402000-00403000 r--p 00002000 fd:01 2838574           /tmp/a.out
293 /// 00403000-00404000 r--p 00002000 fd:01 2838574           /tmp/a.out
294 /// 00404000-00405000 rw-p 00003000 fd:01 2838574           /tmp/a.out
295 /// ...
296 ///
297 /// This function should return true when given 0x00400000 and "/tmp/a.out"
298 /// is passed in as the path since it has a consecutive memory region for
299 /// "/tmp/a.out" that has execute permissions at 0x00401000. This will help us
300 /// differentiate if a file has been memory mapped into a process for reading
301 /// and breakpad ends up saving a minidump file that has two module entries for
302 /// a given file: one that is read only for the entire file, and then one that
303 /// is the real executable that is loaded into memory for execution. For memory
304 /// mapped files they will typically show up and r--p permissions and a range
305 /// matcning the entire range of the file on disk:
306 ///
307 /// 00800000-00805000 r--p 00000000 fd:01 2838574           /tmp/a.out
308 /// 00805000-00806000 r-xp 00001000 fd:01 1234567           /usr/lib/libc.so
309 ///
310 /// This function should return false when asked about 0x00800000 with
311 /// "/tmp/a.out" as the path.
312 ///
313 /// \param[in] path
314 ///   The path to the module to check for in the memory regions. Only sequential
315 ///   memory regions whose paths match this path will be considered when looking
316 ///   for execute permissions.
317 ///
318 /// \param[in] regions
319 ///   A sorted list of memory regions obtained from a call to
320 ///   CreateRegionsCacheFromLinuxMaps.
321 ///
322 /// \param[in] base_of_image
323 ///   The load address of this module from BaseOfImage in the modules list.
324 ///
325 /// \return
326 ///   True if a contiguous region of memory belonging to the module with a
327 ///   matching path exists that has executable permissions. Returns false if
328 ///   \a regions is empty or if there are no regions with execute permissions
329 ///   that match \a path.
330 
CheckForLinuxExecutable(ConstString path,const MemoryRegionInfos & regions,lldb::addr_t base_of_image)331 static bool CheckForLinuxExecutable(ConstString path,
332                                     const MemoryRegionInfos &regions,
333                                     lldb::addr_t base_of_image) {
334   if (regions.empty())
335     return false;
336   lldb::addr_t addr = base_of_image;
337   MemoryRegionInfo region = MinidumpParser::GetMemoryRegionInfo(regions, addr);
338   while (region.GetName() == path) {
339     if (region.GetExecutable() == MemoryRegionInfo::eYes)
340       return true;
341     addr += region.GetRange().GetByteSize();
342     region = MinidumpParser::GetMemoryRegionInfo(regions, addr);
343   }
344   return false;
345 }
346 
GetFilteredModuleList()347 std::vector<const minidump::Module *> MinidumpParser::GetFilteredModuleList() {
348   Log *log = GetLogIfAnyCategoriesSet(LIBLLDB_LOG_MODULES);
349   auto ExpectedModules = GetMinidumpFile().getModuleList();
350   if (!ExpectedModules) {
351     LLDB_LOG_ERROR(log, ExpectedModules.takeError(),
352                    "Failed to read module list: {0}");
353     return {};
354   }
355 
356   // Create memory regions from the linux maps only. We do this to avoid issues
357   // with breakpad generated minidumps where if someone has mmap'ed a shared
358   // library into memory to accesss its data in the object file, we can get a
359   // minidump with two mappings for a binary: one whose base image points to a
360   // memory region that is read + execute and one that is read only.
361   MemoryRegionInfos linux_regions;
362   if (CreateRegionsCacheFromLinuxMaps(*this, linux_regions))
363     llvm::sort(linux_regions);
364 
365   // map module_name -> filtered_modules index
366   typedef llvm::StringMap<size_t> MapType;
367   MapType module_name_to_filtered_index;
368 
369   std::vector<const minidump::Module *> filtered_modules;
370 
371   for (const auto &module : *ExpectedModules) {
372     auto ExpectedName = m_file->getString(module.ModuleNameRVA);
373     if (!ExpectedName) {
374       LLDB_LOG_ERROR(log, ExpectedName.takeError(),
375                      "Failed to get module name: {0}");
376       continue;
377     }
378 
379     MapType::iterator iter;
380     bool inserted;
381     // See if we have inserted this module aready into filtered_modules. If we
382     // haven't insert an entry into module_name_to_filtered_index with the
383     // index where we will insert it if it isn't in the vector already.
384     std::tie(iter, inserted) = module_name_to_filtered_index.try_emplace(
385         *ExpectedName, filtered_modules.size());
386 
387     if (inserted) {
388       // This module has not been seen yet, insert it into filtered_modules at
389       // the index that was inserted into module_name_to_filtered_index using
390       // "filtered_modules.size()" above.
391       filtered_modules.push_back(&module);
392     } else {
393       // We have a duplicate module entry. Check the linux regions to see if
394       // the module we already have is not really a mapped executable. If it
395       // isn't check to see if the current duplicate module entry is a real
396       // mapped executable, and if so, replace it. This can happen when a
397       // process mmap's in the file for an executable in order to read bytes
398       // from the executable file. A memory region mapping will exist for the
399       // mmap'ed version and for the loaded executable, but only one will have
400       // a consecutive region that is executable in the memory regions.
401       auto dup_module = filtered_modules[iter->second];
402       ConstString name(*ExpectedName);
403       if (!CheckForLinuxExecutable(name, linux_regions,
404                                    dup_module->BaseOfImage) &&
405           CheckForLinuxExecutable(name, linux_regions, module.BaseOfImage)) {
406         filtered_modules[iter->second] = &module;
407         continue;
408       }
409       // This module has been seen. Modules are sometimes mentioned multiple
410       // times when they are mapped discontiguously, so find the module with
411       // the lowest "base_of_image" and use that as the filtered module.
412       if (module.BaseOfImage < dup_module->BaseOfImage)
413         filtered_modules[iter->second] = &module;
414     }
415   }
416   return filtered_modules;
417 }
418 
GetExceptionStream()419 const minidump::ExceptionStream *MinidumpParser::GetExceptionStream() {
420   auto ExpectedStream = GetMinidumpFile().getExceptionStream();
421   if (ExpectedStream)
422     return &*ExpectedStream;
423 
424   LLDB_LOG_ERROR(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS),
425                  ExpectedStream.takeError(),
426                  "Failed to read minidump exception stream: {0}");
427   return nullptr;
428 }
429 
430 llvm::Optional<minidump::Range>
FindMemoryRange(lldb::addr_t addr)431 MinidumpParser::FindMemoryRange(lldb::addr_t addr) {
432   llvm::ArrayRef<uint8_t> data64 = GetStream(StreamType::Memory64List);
433   Log *log = GetLogIfAnyCategoriesSet(LIBLLDB_LOG_MODULES);
434 
435   auto ExpectedMemory = GetMinidumpFile().getMemoryList();
436   if (!ExpectedMemory) {
437     LLDB_LOG_ERROR(log, ExpectedMemory.takeError(),
438                    "Failed to read memory list: {0}");
439   } else {
440     for (const auto &memory_desc : *ExpectedMemory) {
441       const LocationDescriptor &loc_desc = memory_desc.Memory;
442       const lldb::addr_t range_start = memory_desc.StartOfMemoryRange;
443       const size_t range_size = loc_desc.DataSize;
444 
445       if (loc_desc.RVA + loc_desc.DataSize > GetData().size())
446         return llvm::None;
447 
448       if (range_start <= addr && addr < range_start + range_size) {
449         auto ExpectedSlice = GetMinidumpFile().getRawData(loc_desc);
450         if (!ExpectedSlice) {
451           LLDB_LOG_ERROR(log, ExpectedSlice.takeError(),
452                          "Failed to get memory slice: {0}");
453           return llvm::None;
454         }
455         return minidump::Range(range_start, *ExpectedSlice);
456       }
457     }
458   }
459 
460   // Some Minidumps have a Memory64ListStream that captures all the heap memory
461   // (full-memory Minidumps).  We can't exactly use the same loop as above,
462   // because the Minidump uses slightly different data structures to describe
463   // those
464 
465   if (!data64.empty()) {
466     llvm::ArrayRef<MinidumpMemoryDescriptor64> memory64_list;
467     uint64_t base_rva;
468     std::tie(memory64_list, base_rva) =
469         MinidumpMemoryDescriptor64::ParseMemory64List(data64);
470 
471     if (memory64_list.empty())
472       return llvm::None;
473 
474     for (const auto &memory_desc64 : memory64_list) {
475       const lldb::addr_t range_start = memory_desc64.start_of_memory_range;
476       const size_t range_size = memory_desc64.data_size;
477 
478       if (base_rva + range_size > GetData().size())
479         return llvm::None;
480 
481       if (range_start <= addr && addr < range_start + range_size) {
482         return minidump::Range(range_start,
483                                GetData().slice(base_rva, range_size));
484       }
485       base_rva += range_size;
486     }
487   }
488 
489   return llvm::None;
490 }
491 
GetMemory(lldb::addr_t addr,size_t size)492 llvm::ArrayRef<uint8_t> MinidumpParser::GetMemory(lldb::addr_t addr,
493                                                   size_t size) {
494   // I don't have a sense of how frequently this is called or how many memory
495   // ranges a Minidump typically has, so I'm not sure if searching for the
496   // appropriate range linearly each time is stupid.  Perhaps we should build
497   // an index for faster lookups.
498   llvm::Optional<minidump::Range> range = FindMemoryRange(addr);
499   if (!range)
500     return {};
501 
502   // There's at least some overlap between the beginning of the desired range
503   // (addr) and the current range.  Figure out where the overlap begins and how
504   // much overlap there is.
505 
506   const size_t offset = addr - range->start;
507 
508   if (addr < range->start || offset >= range->range_ref.size())
509     return {};
510 
511   const size_t overlap = std::min(size, range->range_ref.size() - offset);
512   return range->range_ref.slice(offset, overlap);
513 }
514 
515 static bool
CreateRegionsCacheFromMemoryInfoList(MinidumpParser & parser,std::vector<MemoryRegionInfo> & regions)516 CreateRegionsCacheFromMemoryInfoList(MinidumpParser &parser,
517                                      std::vector<MemoryRegionInfo> &regions) {
518   Log *log = GetLogIfAnyCategoriesSet(LIBLLDB_LOG_MODULES);
519   auto ExpectedInfo = parser.GetMinidumpFile().getMemoryInfoList();
520   if (!ExpectedInfo) {
521     LLDB_LOG_ERROR(log, ExpectedInfo.takeError(),
522                    "Failed to read memory info list: {0}");
523     return false;
524   }
525   constexpr auto yes = MemoryRegionInfo::eYes;
526   constexpr auto no = MemoryRegionInfo::eNo;
527   for (const MemoryInfo &entry : *ExpectedInfo) {
528     MemoryRegionInfo region;
529     region.GetRange().SetRangeBase(entry.BaseAddress);
530     region.GetRange().SetByteSize(entry.RegionSize);
531 
532     MemoryProtection prot = entry.Protect;
533     region.SetReadable(bool(prot & MemoryProtection::NoAccess) ? no : yes);
534     region.SetWritable(
535         bool(prot & (MemoryProtection::ReadWrite | MemoryProtection::WriteCopy |
536                      MemoryProtection::ExecuteReadWrite |
537                      MemoryProtection::ExeciteWriteCopy))
538             ? yes
539             : no);
540     region.SetExecutable(
541         bool(prot & (MemoryProtection::Execute | MemoryProtection::ExecuteRead |
542                      MemoryProtection::ExecuteReadWrite |
543                      MemoryProtection::ExeciteWriteCopy))
544             ? yes
545             : no);
546     region.SetMapped(entry.State != MemoryState::Free ? yes : no);
547     regions.push_back(region);
548   }
549   return !regions.empty();
550 }
551 
552 static bool
CreateRegionsCacheFromMemoryList(MinidumpParser & parser,std::vector<MemoryRegionInfo> & regions)553 CreateRegionsCacheFromMemoryList(MinidumpParser &parser,
554                                  std::vector<MemoryRegionInfo> &regions) {
555   Log *log = GetLogIfAnyCategoriesSet(LIBLLDB_LOG_MODULES);
556   auto ExpectedMemory = parser.GetMinidumpFile().getMemoryList();
557   if (!ExpectedMemory) {
558     LLDB_LOG_ERROR(log, ExpectedMemory.takeError(),
559                    "Failed to read memory list: {0}");
560     return false;
561   }
562   regions.reserve(ExpectedMemory->size());
563   for (const MemoryDescriptor &memory_desc : *ExpectedMemory) {
564     if (memory_desc.Memory.DataSize == 0)
565       continue;
566     MemoryRegionInfo region;
567     region.GetRange().SetRangeBase(memory_desc.StartOfMemoryRange);
568     region.GetRange().SetByteSize(memory_desc.Memory.DataSize);
569     region.SetReadable(MemoryRegionInfo::eYes);
570     region.SetMapped(MemoryRegionInfo::eYes);
571     regions.push_back(region);
572   }
573   regions.shrink_to_fit();
574   return !regions.empty();
575 }
576 
577 static bool
CreateRegionsCacheFromMemory64List(MinidumpParser & parser,std::vector<MemoryRegionInfo> & regions)578 CreateRegionsCacheFromMemory64List(MinidumpParser &parser,
579                                    std::vector<MemoryRegionInfo> &regions) {
580   llvm::ArrayRef<uint8_t> data =
581       parser.GetStream(StreamType::Memory64List);
582   if (data.empty())
583     return false;
584   llvm::ArrayRef<MinidumpMemoryDescriptor64> memory64_list;
585   uint64_t base_rva;
586   std::tie(memory64_list, base_rva) =
587       MinidumpMemoryDescriptor64::ParseMemory64List(data);
588 
589   if (memory64_list.empty())
590     return false;
591 
592   regions.reserve(memory64_list.size());
593   for (const auto &memory_desc : memory64_list) {
594     if (memory_desc.data_size == 0)
595       continue;
596     MemoryRegionInfo region;
597     region.GetRange().SetRangeBase(memory_desc.start_of_memory_range);
598     region.GetRange().SetByteSize(memory_desc.data_size);
599     region.SetReadable(MemoryRegionInfo::eYes);
600     region.SetMapped(MemoryRegionInfo::eYes);
601     regions.push_back(region);
602   }
603   regions.shrink_to_fit();
604   return !regions.empty();
605 }
606 
BuildMemoryRegions()607 std::pair<MemoryRegionInfos, bool> MinidumpParser::BuildMemoryRegions() {
608   // We create the region cache using the best source. We start with
609   // the linux maps since they are the most complete and have names for the
610   // regions. Next we try the MemoryInfoList since it has
611   // read/write/execute/map data, and then fall back to the MemoryList and
612   // Memory64List to just get a list of the memory that is mapped in this
613   // core file
614   MemoryRegionInfos result;
615   const auto &return_sorted = [&](bool is_complete) {
616     llvm::sort(result);
617     return std::make_pair(std::move(result), is_complete);
618   };
619   if (CreateRegionsCacheFromLinuxMaps(*this, result))
620     return return_sorted(true);
621   if (CreateRegionsCacheFromMemoryInfoList(*this, result))
622     return return_sorted(true);
623   if (CreateRegionsCacheFromMemoryList(*this, result))
624     return return_sorted(false);
625   CreateRegionsCacheFromMemory64List(*this, result);
626   return return_sorted(false);
627 }
628 
629 #define ENUM_TO_CSTR(ST)                                                       \
630   case StreamType::ST:                                                         \
631     return #ST
632 
633 llvm::StringRef
GetStreamTypeAsString(StreamType stream_type)634 MinidumpParser::GetStreamTypeAsString(StreamType stream_type) {
635   switch (stream_type) {
636     ENUM_TO_CSTR(Unused);
637     ENUM_TO_CSTR(ThreadList);
638     ENUM_TO_CSTR(ModuleList);
639     ENUM_TO_CSTR(MemoryList);
640     ENUM_TO_CSTR(Exception);
641     ENUM_TO_CSTR(SystemInfo);
642     ENUM_TO_CSTR(ThreadExList);
643     ENUM_TO_CSTR(Memory64List);
644     ENUM_TO_CSTR(CommentA);
645     ENUM_TO_CSTR(CommentW);
646     ENUM_TO_CSTR(HandleData);
647     ENUM_TO_CSTR(FunctionTable);
648     ENUM_TO_CSTR(UnloadedModuleList);
649     ENUM_TO_CSTR(MiscInfo);
650     ENUM_TO_CSTR(MemoryInfoList);
651     ENUM_TO_CSTR(ThreadInfoList);
652     ENUM_TO_CSTR(HandleOperationList);
653     ENUM_TO_CSTR(Token);
654     ENUM_TO_CSTR(JavascriptData);
655     ENUM_TO_CSTR(SystemMemoryInfo);
656     ENUM_TO_CSTR(ProcessVMCounters);
657     ENUM_TO_CSTR(LastReserved);
658     ENUM_TO_CSTR(BreakpadInfo);
659     ENUM_TO_CSTR(AssertionInfo);
660     ENUM_TO_CSTR(LinuxCPUInfo);
661     ENUM_TO_CSTR(LinuxProcStatus);
662     ENUM_TO_CSTR(LinuxLSBRelease);
663     ENUM_TO_CSTR(LinuxCMDLine);
664     ENUM_TO_CSTR(LinuxEnviron);
665     ENUM_TO_CSTR(LinuxAuxv);
666     ENUM_TO_CSTR(LinuxMaps);
667     ENUM_TO_CSTR(LinuxDSODebug);
668     ENUM_TO_CSTR(LinuxProcStat);
669     ENUM_TO_CSTR(LinuxProcUptime);
670     ENUM_TO_CSTR(LinuxProcFD);
671     ENUM_TO_CSTR(FacebookAppCustomData);
672     ENUM_TO_CSTR(FacebookBuildID);
673     ENUM_TO_CSTR(FacebookAppVersionName);
674     ENUM_TO_CSTR(FacebookJavaStack);
675     ENUM_TO_CSTR(FacebookDalvikInfo);
676     ENUM_TO_CSTR(FacebookUnwindSymbols);
677     ENUM_TO_CSTR(FacebookDumpErrorLog);
678     ENUM_TO_CSTR(FacebookAppStateLog);
679     ENUM_TO_CSTR(FacebookAbortReason);
680     ENUM_TO_CSTR(FacebookThreadName);
681     ENUM_TO_CSTR(FacebookLogcat);
682   }
683   return "unknown stream type";
684 }
685 
686 MemoryRegionInfo
GetMemoryRegionInfo(const MemoryRegionInfos & regions,lldb::addr_t load_addr)687 MinidumpParser::GetMemoryRegionInfo(const MemoryRegionInfos &regions,
688                                     lldb::addr_t load_addr) {
689   MemoryRegionInfo region;
690   auto pos = llvm::upper_bound(regions, load_addr);
691   if (pos != regions.begin() &&
692       std::prev(pos)->GetRange().Contains(load_addr)) {
693     return *std::prev(pos);
694   }
695 
696   if (pos == regions.begin())
697     region.GetRange().SetRangeBase(0);
698   else
699     region.GetRange().SetRangeBase(std::prev(pos)->GetRange().GetRangeEnd());
700 
701   if (pos == regions.end())
702     region.GetRange().SetRangeEnd(UINT64_MAX);
703   else
704     region.GetRange().SetRangeEnd(pos->GetRange().GetRangeBase());
705 
706   region.SetReadable(MemoryRegionInfo::eNo);
707   region.SetWritable(MemoryRegionInfo::eNo);
708   region.SetExecutable(MemoryRegionInfo::eNo);
709   region.SetMapped(MemoryRegionInfo::eNo);
710   return region;
711 }
712