1 //===-- MinidumpFileBuilder.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 "MinidumpFileBuilder.h"
10 
11 #include "Plugins/Process/minidump/RegisterContextMinidump_x86_64.h"
12 
13 #include "lldb/Core/Module.h"
14 #include "lldb/Core/ModuleList.h"
15 #include "lldb/Core/Section.h"
16 #include "lldb/Target/MemoryRegionInfo.h"
17 #include "lldb/Target/Process.h"
18 #include "lldb/Target/RegisterContext.h"
19 #include "lldb/Target/StopInfo.h"
20 #include "lldb/Target/ThreadList.h"
21 #include "lldb/Utility/DataExtractor.h"
22 #include "lldb/Utility/RegisterValue.h"
23 
24 #include "llvm/ADT/StringRef.h"
25 #include "llvm/BinaryFormat/Minidump.h"
26 #include "llvm/Support/ConvertUTF.h"
27 #include "llvm/Support/Error.h"
28 
29 #include "Plugins/Process/minidump/MinidumpTypes.h"
30 
31 #include <cinttypes>
32 
33 using namespace lldb;
34 using namespace lldb_private;
35 using namespace llvm::minidump;
36 
37 void MinidumpFileBuilder::AddDirectory(StreamType type, size_t stream_size) {
38   LocationDescriptor loc;
39   loc.DataSize = static_cast<llvm::support::ulittle32_t>(stream_size);
40   // Stream will begin at the current end of data section
41   loc.RVA = static_cast<llvm::support::ulittle32_t>(GetCurrentDataEndOffset());
42 
43   Directory dir;
44   dir.Type = static_cast<llvm::support::little_t<StreamType>>(type);
45   dir.Location = loc;
46 
47   m_directories.push_back(dir);
48 }
49 
50 Status MinidumpFileBuilder::AddSystemInfo(const llvm::Triple &target_triple) {
51   Status error;
52   AddDirectory(StreamType::SystemInfo, sizeof(llvm::minidump::SystemInfo));
53 
54   llvm::minidump::ProcessorArchitecture arch;
55   switch (target_triple.getArch()) {
56   case llvm::Triple::ArchType::x86_64:
57     arch = ProcessorArchitecture::AMD64;
58     break;
59   case llvm::Triple::ArchType::x86:
60     arch = ProcessorArchitecture::X86;
61     break;
62   case llvm::Triple::ArchType::arm:
63     arch = ProcessorArchitecture::ARM;
64     break;
65   case llvm::Triple::ArchType::aarch64:
66     arch = ProcessorArchitecture::ARM64;
67     break;
68   case llvm::Triple::ArchType::mips64:
69   case llvm::Triple::ArchType::mips64el:
70   case llvm::Triple::ArchType::mips:
71   case llvm::Triple::ArchType::mipsel:
72     arch = ProcessorArchitecture::MIPS;
73     break;
74   case llvm::Triple::ArchType::ppc64:
75   case llvm::Triple::ArchType::ppc:
76   case llvm::Triple::ArchType::ppc64le:
77     arch = ProcessorArchitecture::PPC;
78     break;
79   default:
80     error.SetErrorStringWithFormat("Architecture %s not supported.",
81                                    target_triple.getArchName().str().c_str());
82     return error;
83   };
84 
85   llvm::support::little_t<OSPlatform> platform_id;
86   switch (target_triple.getOS()) {
87   case llvm::Triple::OSType::Linux:
88     if (target_triple.getEnvironment() ==
89         llvm::Triple::EnvironmentType::Android)
90       platform_id = OSPlatform::Android;
91     else
92       platform_id = OSPlatform::Linux;
93     break;
94   case llvm::Triple::OSType::Win32:
95     platform_id = OSPlatform::Win32NT;
96     break;
97   case llvm::Triple::OSType::MacOSX:
98     platform_id = OSPlatform::MacOSX;
99     break;
100   case llvm::Triple::OSType::IOS:
101     platform_id = OSPlatform::IOS;
102     break;
103   default:
104     error.SetErrorStringWithFormat("OS %s not supported.",
105                                    target_triple.getOSName().str().c_str());
106     return error;
107   };
108 
109   llvm::minidump::SystemInfo sys_info;
110   sys_info.ProcessorArch =
111       static_cast<llvm::support::little_t<ProcessorArchitecture>>(arch);
112   // Global offset to beginning of a csd_string in a data section
113   sys_info.CSDVersionRVA = static_cast<llvm::support::ulittle32_t>(
114       GetCurrentDataEndOffset() + sizeof(llvm::minidump::SystemInfo));
115   sys_info.PlatformId = platform_id;
116   m_data.AppendData(&sys_info, sizeof(llvm::minidump::SystemInfo));
117 
118   std::string csd_string;
119 
120   error = WriteString(csd_string, &m_data);
121   if (error.Fail()) {
122     error.SetErrorString("Unable to convert the csd string to UTF16.");
123     return error;
124   }
125 
126   return error;
127 }
128 
129 Status WriteString(const std::string &to_write,
130                    lldb_private::DataBufferHeap *buffer) {
131   Status error;
132   // let the StringRef eat also null termination char
133   llvm::StringRef to_write_ref(to_write.c_str(), to_write.size() + 1);
134   llvm::SmallVector<llvm::UTF16, 128> to_write_utf16;
135 
136   bool converted = convertUTF8ToUTF16String(to_write_ref, to_write_utf16);
137   if (!converted) {
138     error.SetErrorStringWithFormat(
139         "Unable to convert the string to UTF16. Failed to convert %s",
140         to_write.c_str());
141     return error;
142   }
143 
144   // size of the UTF16 string should be written without the null termination
145   // character that is stored in 2 bytes
146   llvm::support::ulittle32_t to_write_size(to_write_utf16.size_in_bytes() - 2);
147 
148   buffer->AppendData(&to_write_size, sizeof(llvm::support::ulittle32_t));
149   buffer->AppendData(to_write_utf16.data(), to_write_utf16.size_in_bytes());
150 
151   return error;
152 }
153 
154 llvm::Expected<uint64_t> getModuleFileSize(Target &target,
155                                            const ModuleSP &mod) {
156   SectionSP sect_sp = mod->GetObjectFile()->GetBaseAddress().GetSection();
157   uint64_t SizeOfImage = 0;
158 
159   if (!sect_sp) {
160     return llvm::createStringError(std::errc::operation_not_supported,
161                                    "Couldn't obtain the section information.");
162   }
163   lldb::addr_t sect_addr = sect_sp->GetLoadBaseAddress(&target);
164   // Use memory size since zero fill sections, like ".bss", will be smaller on
165   // disk.
166   lldb::addr_t sect_size = sect_sp->GetByteSize();
167   // This will usually be zero, but make sure to calculate the BaseOfImage
168   // offset.
169   const lldb::addr_t base_sect_offset =
170       mod->GetObjectFile()->GetBaseAddress().GetLoadAddress(&target) -
171       sect_addr;
172   SizeOfImage = sect_size - base_sect_offset;
173   lldb::addr_t next_sect_addr = sect_addr + sect_size;
174   Address sect_so_addr;
175   target.ResolveLoadAddress(next_sect_addr, sect_so_addr);
176   lldb::SectionSP next_sect_sp = sect_so_addr.GetSection();
177   while (next_sect_sp &&
178          next_sect_sp->GetLoadBaseAddress(&target) == next_sect_addr) {
179     sect_size = sect_sp->GetByteSize();
180     SizeOfImage += sect_size;
181     next_sect_addr += sect_size;
182     target.ResolveLoadAddress(next_sect_addr, sect_so_addr);
183     next_sect_sp = sect_so_addr.GetSection();
184   }
185 
186   return SizeOfImage;
187 }
188 
189 // ModuleList stream consists of a number of modules, followed by an array
190 // of llvm::minidump::Module's structures. Every structure informs about a
191 // single module. Additional data of variable length, such as module's names,
192 // are stored just after the ModuleList stream. The llvm::minidump::Module
193 // structures point to this helper data by global offset.
194 Status MinidumpFileBuilder::AddModuleList(Target &target) {
195   constexpr size_t minidump_module_size = sizeof(llvm::minidump::Module);
196   Status error;
197 
198   const ModuleList &modules = target.GetImages();
199   llvm::support::ulittle32_t modules_count =
200       static_cast<llvm::support::ulittle32_t>(modules.GetSize());
201 
202   // This helps us with getting the correct global offset in minidump
203   // file later, when we will be setting up offsets from the
204   // the llvm::minidump::Module's structures into helper data
205   size_t size_before = GetCurrentDataEndOffset();
206 
207   // This is the size of the main part of the ModuleList stream.
208   // It consists of a module number and corresponding number of
209   // structs describing individual modules
210   size_t module_stream_size =
211       sizeof(llvm::support::ulittle32_t) + modules_count * minidump_module_size;
212 
213   // Adding directory describing this stream.
214   AddDirectory(StreamType::ModuleList, module_stream_size);
215 
216   m_data.AppendData(&modules_count, sizeof(llvm::support::ulittle32_t));
217 
218   // Temporary storage for the helper data (of variable length)
219   // as these cannot be dumped to m_data before dumping entire
220   // array of module structures.
221   DataBufferHeap helper_data;
222 
223   for (size_t i = 0; i < modules_count; ++i) {
224     ModuleSP mod = modules.GetModuleAtIndex(i);
225     std::string module_name = mod->GetSpecificationDescription();
226     auto maybe_mod_size = getModuleFileSize(target, mod);
227     if (!maybe_mod_size) {
228       error.SetErrorStringWithFormat("Unable to get the size of module %s.",
229                                      module_name.c_str());
230       return error;
231     }
232 
233     uint64_t mod_size = std::move(*maybe_mod_size);
234 
235     llvm::support::ulittle32_t signature =
236         static_cast<llvm::support::ulittle32_t>(
237             static_cast<uint32_t>(minidump::CvSignature::ElfBuildId));
238     auto uuid = mod->GetUUID().GetBytes();
239 
240     VSFixedFileInfo info;
241     info.Signature = static_cast<llvm::support::ulittle32_t>(0u);
242     info.StructVersion = static_cast<llvm::support::ulittle32_t>(0u);
243     info.FileVersionHigh = static_cast<llvm::support::ulittle32_t>(0u);
244     info.FileVersionLow = static_cast<llvm::support::ulittle32_t>(0u);
245     info.ProductVersionHigh = static_cast<llvm::support::ulittle32_t>(0u);
246     info.ProductVersionLow = static_cast<llvm::support::ulittle32_t>(0u);
247     info.FileFlagsMask = static_cast<llvm::support::ulittle32_t>(0u);
248     info.FileFlags = static_cast<llvm::support::ulittle32_t>(0u);
249     info.FileOS = static_cast<llvm::support::ulittle32_t>(0u);
250     info.FileType = static_cast<llvm::support::ulittle32_t>(0u);
251     info.FileSubtype = static_cast<llvm::support::ulittle32_t>(0u);
252     info.FileDateHigh = static_cast<llvm::support::ulittle32_t>(0u);
253     info.FileDateLow = static_cast<llvm::support::ulittle32_t>(0u);
254 
255     LocationDescriptor ld;
256     ld.DataSize = static_cast<llvm::support::ulittle32_t>(0u);
257     ld.RVA = static_cast<llvm::support::ulittle32_t>(0u);
258 
259     // Setting up LocationDescriptor for uuid string. The global offset into
260     // minidump file is calculated.
261     LocationDescriptor ld_cv;
262     ld_cv.DataSize = static_cast<llvm::support::ulittle32_t>(
263         sizeof(llvm::support::ulittle32_t) + uuid.size());
264     ld_cv.RVA = static_cast<llvm::support::ulittle32_t>(
265         size_before + module_stream_size + helper_data.GetByteSize());
266 
267     helper_data.AppendData(&signature, sizeof(llvm::support::ulittle32_t));
268     helper_data.AppendData(uuid.begin(), uuid.size());
269 
270     llvm::minidump::Module m;
271     m.BaseOfImage = static_cast<llvm::support::ulittle64_t>(
272         mod->GetObjectFile()->GetBaseAddress().GetLoadAddress(&target));
273     m.SizeOfImage = static_cast<llvm::support::ulittle32_t>(mod_size);
274     m.Checksum = static_cast<llvm::support::ulittle32_t>(0);
275     m.TimeDateStamp =
276         static_cast<llvm::support::ulittle32_t>(std::time(nullptr));
277     m.ModuleNameRVA = static_cast<llvm::support::ulittle32_t>(
278         size_before + module_stream_size + helper_data.GetByteSize());
279     m.VersionInfo = info;
280     m.CvRecord = ld_cv;
281     m.MiscRecord = ld;
282 
283     error = WriteString(module_name, &helper_data);
284 
285     if (error.Fail())
286       return error;
287 
288     m_data.AppendData(&m, sizeof(llvm::minidump::Module));
289   }
290 
291   m_data.AppendData(helper_data.GetBytes(), helper_data.GetByteSize());
292   return error;
293 }
294 
295 uint16_t read_register_u16_raw(RegisterContext *reg_ctx,
296                                const std::string &reg_name) {
297   const RegisterInfo *reg_info = reg_ctx->GetRegisterInfoByName(reg_name);
298   if (!reg_info)
299     return 0;
300   lldb_private::RegisterValue reg_value;
301   bool success = reg_ctx->ReadRegister(reg_info, reg_value);
302   if (!success)
303     return 0;
304   return reg_value.GetAsUInt16();
305 }
306 
307 uint32_t read_register_u32_raw(RegisterContext *reg_ctx,
308                                const std::string &reg_name) {
309   const RegisterInfo *reg_info = reg_ctx->GetRegisterInfoByName(reg_name);
310   if (!reg_info)
311     return 0;
312   lldb_private::RegisterValue reg_value;
313   bool success = reg_ctx->ReadRegister(reg_info, reg_value);
314   if (!success)
315     return 0;
316   return reg_value.GetAsUInt32();
317 }
318 
319 uint64_t read_register_u64_raw(RegisterContext *reg_ctx,
320                                const std::string &reg_name) {
321   const RegisterInfo *reg_info = reg_ctx->GetRegisterInfoByName(reg_name);
322   if (!reg_info)
323     return 0;
324   lldb_private::RegisterValue reg_value;
325   bool success = reg_ctx->ReadRegister(reg_info, reg_value);
326   if (!success)
327     return 0;
328   return reg_value.GetAsUInt64();
329 }
330 
331 llvm::support::ulittle16_t read_register_u16(RegisterContext *reg_ctx,
332                                              const std::string &reg_name) {
333   return static_cast<llvm::support::ulittle16_t>(
334       read_register_u16_raw(reg_ctx, reg_name));
335 }
336 
337 llvm::support::ulittle32_t read_register_u32(RegisterContext *reg_ctx,
338                                              const std::string &reg_name) {
339   return static_cast<llvm::support::ulittle32_t>(
340       read_register_u32_raw(reg_ctx, reg_name));
341 }
342 
343 llvm::support::ulittle64_t read_register_u64(RegisterContext *reg_ctx,
344                                              const std::string &reg_name) {
345   return static_cast<llvm::support::ulittle64_t>(
346       read_register_u64_raw(reg_ctx, reg_name));
347 }
348 
349 lldb_private::minidump::MinidumpContext_x86_64
350 GetThreadContext_64(RegisterContext *reg_ctx) {
351   lldb_private::minidump::MinidumpContext_x86_64 thread_context = {};
352   thread_context.p1_home = {};
353   thread_context.context_flags = static_cast<uint32_t>(
354       lldb_private::minidump::MinidumpContext_x86_64_Flags::x86_64_Flag |
355       lldb_private::minidump::MinidumpContext_x86_64_Flags::Control |
356       lldb_private::minidump::MinidumpContext_x86_64_Flags::Segments |
357       lldb_private::minidump::MinidumpContext_x86_64_Flags::Integer);
358   thread_context.rax = read_register_u64(reg_ctx, "rax");
359   thread_context.rbx = read_register_u64(reg_ctx, "rbx");
360   thread_context.rcx = read_register_u64(reg_ctx, "rcx");
361   thread_context.rdx = read_register_u64(reg_ctx, "rdx");
362   thread_context.rdi = read_register_u64(reg_ctx, "rdi");
363   thread_context.rsi = read_register_u64(reg_ctx, "rsi");
364   thread_context.rbp = read_register_u64(reg_ctx, "rbp");
365   thread_context.rsp = read_register_u64(reg_ctx, "rsp");
366   thread_context.r8 = read_register_u64(reg_ctx, "r8");
367   thread_context.r9 = read_register_u64(reg_ctx, "r9");
368   thread_context.r10 = read_register_u64(reg_ctx, "r10");
369   thread_context.r11 = read_register_u64(reg_ctx, "r11");
370   thread_context.r12 = read_register_u64(reg_ctx, "r12");
371   thread_context.r13 = read_register_u64(reg_ctx, "r13");
372   thread_context.r14 = read_register_u64(reg_ctx, "r14");
373   thread_context.r15 = read_register_u64(reg_ctx, "r15");
374   thread_context.rip = read_register_u64(reg_ctx, "rip");
375   thread_context.eflags = read_register_u32(reg_ctx, "rflags");
376   thread_context.cs = read_register_u16(reg_ctx, "cs");
377   thread_context.fs = read_register_u16(reg_ctx, "fs");
378   thread_context.gs = read_register_u16(reg_ctx, "gs");
379   thread_context.ss = read_register_u16(reg_ctx, "ss");
380   thread_context.ds = read_register_u16(reg_ctx, "ds");
381   return thread_context;
382 }
383 
384 // Function returns start and size of the memory region that contains
385 // memory location pointed to by the current stack pointer.
386 llvm::Expected<std::pair<addr_t, addr_t>>
387 findStackHelper(const lldb::ProcessSP &process_sp, uint64_t rsp) {
388   MemoryRegionInfo range_info;
389   Status error = process_sp->GetMemoryRegionInfo(rsp, range_info);
390   // Skip failed memory region requests or any regions with no permissions.
391   if (error.Fail() || range_info.GetLLDBPermissions() == 0)
392     return llvm::createStringError(
393         std::errc::not_supported,
394         "unable to load stack segment of the process");
395 
396   const addr_t addr = range_info.GetRange().GetRangeBase();
397   const addr_t size = range_info.GetRange().GetByteSize();
398 
399   if (size == 0)
400     return llvm::createStringError(std::errc::not_supported,
401                                    "stack segment of the process is empty");
402 
403   return std::make_pair(addr, size);
404 }
405 
406 Status MinidumpFileBuilder::AddThreadList(const lldb::ProcessSP &process_sp) {
407   constexpr size_t minidump_thread_size = sizeof(llvm::minidump::Thread);
408   lldb_private::ThreadList thread_list = process_sp->GetThreadList();
409 
410   // size of the entire thread stream consists of:
411   // number of threads and threads array
412   size_t thread_stream_size = sizeof(llvm::support::ulittle32_t) +
413                               thread_list.GetSize() * minidump_thread_size;
414   // save for the ability to set up RVA
415   size_t size_before = GetCurrentDataEndOffset();
416 
417   AddDirectory(StreamType::ThreadList, thread_stream_size);
418 
419   llvm::support::ulittle32_t thread_count =
420       static_cast<llvm::support::ulittle32_t>(thread_list.GetSize());
421   m_data.AppendData(&thread_count, sizeof(llvm::support::ulittle32_t));
422 
423   DataBufferHeap helper_data;
424 
425   const uint32_t num_threads = thread_list.GetSize();
426 
427   for (uint32_t thread_idx = 0; thread_idx < num_threads; ++thread_idx) {
428     ThreadSP thread_sp(thread_list.GetThreadAtIndex(thread_idx));
429     RegisterContextSP reg_ctx_sp(thread_sp->GetRegisterContext());
430     Status error;
431 
432     if (!reg_ctx_sp) {
433       error.SetErrorString("Unable to get the register context.");
434       return error;
435     }
436     RegisterContext *reg_ctx = reg_ctx_sp.get();
437     auto thread_context = GetThreadContext_64(reg_ctx);
438     uint64_t rsp = read_register_u64_raw(reg_ctx, "rsp");
439     auto expected_address_range = findStackHelper(process_sp, rsp);
440 
441     if (!expected_address_range) {
442       error.SetErrorString("Unable to get the stack address.");
443       return error;
444     }
445 
446     std::pair<uint64_t, uint64_t> range = std::move(*expected_address_range);
447     uint64_t addr = range.first;
448     uint64_t size = range.second;
449 
450     auto data_up = std::make_unique<DataBufferHeap>(size, 0);
451     const size_t stack_bytes_read =
452         process_sp->ReadMemory(addr, data_up->GetBytes(), size, error);
453 
454     if (error.Fail())
455       return error;
456 
457     LocationDescriptor stack_memory;
458     stack_memory.DataSize =
459         static_cast<llvm::support::ulittle32_t>(stack_bytes_read);
460     stack_memory.RVA = static_cast<llvm::support::ulittle32_t>(
461         size_before + thread_stream_size + helper_data.GetByteSize());
462 
463     MemoryDescriptor stack;
464     stack.StartOfMemoryRange = static_cast<llvm::support::ulittle64_t>(addr);
465     stack.Memory = stack_memory;
466 
467     helper_data.AppendData(data_up->GetBytes(), stack_bytes_read);
468 
469     LocationDescriptor thread_context_memory_locator;
470     thread_context_memory_locator.DataSize =
471         static_cast<llvm::support::ulittle32_t>(sizeof(thread_context));
472     thread_context_memory_locator.RVA = static_cast<llvm::support::ulittle32_t>(
473         size_before + thread_stream_size + helper_data.GetByteSize());
474 
475     helper_data.AppendData(
476         &thread_context,
477         sizeof(lldb_private::minidump::MinidumpContext_x86_64));
478 
479     llvm::minidump::Thread t;
480     t.ThreadId = static_cast<llvm::support::ulittle32_t>(thread_sp->GetID());
481     t.SuspendCount = static_cast<llvm::support::ulittle32_t>(
482         (thread_sp->GetState() == StateType::eStateSuspended) ? 1 : 0);
483     t.PriorityClass = static_cast<llvm::support::ulittle32_t>(0);
484     t.Priority = static_cast<llvm::support::ulittle32_t>(0);
485     t.EnvironmentBlock = static_cast<llvm::support::ulittle64_t>(0);
486     t.Stack = stack, t.Context = thread_context_memory_locator;
487 
488     m_data.AppendData(&t, sizeof(llvm::minidump::Thread));
489   }
490 
491   m_data.AppendData(helper_data.GetBytes(), helper_data.GetByteSize());
492   return Status();
493 }
494 
495 Status MinidumpFileBuilder::AddException(const lldb::ProcessSP &process_sp) {
496   Status error;
497   lldb_private::ThreadList thread_list = process_sp->GetThreadList();
498 
499   const uint32_t num_threads = thread_list.GetSize();
500   uint32_t stop_reason_thread_idx = 0;
501   for (stop_reason_thread_idx = 0; stop_reason_thread_idx < num_threads;
502        ++stop_reason_thread_idx) {
503     ThreadSP thread_sp(thread_list.GetThreadAtIndex(stop_reason_thread_idx));
504     StopInfoSP stop_info_sp = thread_sp->GetStopInfo();
505 
506     if (stop_info_sp && stop_info_sp->IsValid())
507       break;
508   }
509 
510   if (stop_reason_thread_idx == num_threads) {
511     error.SetErrorString("No stop reason thread found.");
512     return error;
513   }
514 
515   constexpr size_t minidump_exception_size =
516       sizeof(llvm::minidump::ExceptionStream);
517   AddDirectory(StreamType::Exception, minidump_exception_size);
518   size_t size_before = GetCurrentDataEndOffset();
519 
520   ThreadSP thread_sp(thread_list.GetThreadAtIndex(stop_reason_thread_idx));
521   RegisterContextSP reg_ctx_sp(thread_sp->GetRegisterContext());
522   RegisterContext *reg_ctx = reg_ctx_sp.get();
523   auto thread_context = GetThreadContext_64(reg_ctx);
524   StopInfoSP stop_info_sp = thread_sp->GetStopInfo();
525 
526   DataBufferHeap helper_data;
527 
528   LocationDescriptor thread_context_memory_locator;
529   thread_context_memory_locator.DataSize =
530       static_cast<llvm::support::ulittle32_t>(sizeof(thread_context));
531   thread_context_memory_locator.RVA = static_cast<llvm::support::ulittle32_t>(
532       size_before + minidump_exception_size + helper_data.GetByteSize());
533 
534   helper_data.AppendData(
535       &thread_context, sizeof(lldb_private::minidump::MinidumpContext_x86_64));
536 
537   Exception exp_record = {};
538   exp_record.ExceptionCode =
539       static_cast<llvm::support::ulittle32_t>(stop_info_sp->GetValue());
540   exp_record.ExceptionFlags = static_cast<llvm::support::ulittle32_t>(0);
541   exp_record.ExceptionRecord = static_cast<llvm::support::ulittle64_t>(0);
542   exp_record.ExceptionAddress = read_register_u64(reg_ctx, "rip");
543   exp_record.NumberParameters = static_cast<llvm::support::ulittle32_t>(0);
544   exp_record.UnusedAlignment = static_cast<llvm::support::ulittle32_t>(0);
545   // exp_record.ExceptionInformation;
546 
547   ExceptionStream exp_stream;
548   exp_stream.ThreadId =
549       static_cast<llvm::support::ulittle32_t>(thread_sp->GetID());
550   exp_stream.UnusedAlignment = static_cast<llvm::support::ulittle32_t>(0);
551   exp_stream.ExceptionRecord = exp_record;
552   exp_stream.ThreadContext = thread_context_memory_locator;
553 
554   m_data.AppendData(&exp_stream, minidump_exception_size);
555   m_data.AppendData(helper_data.GetBytes(), helper_data.GetByteSize());
556   return error;
557 }
558 
559 lldb_private::Status
560 MinidumpFileBuilder::AddMemoryList(const lldb::ProcessSP &process_sp) {
561   Status error;
562 
563   if (error.Fail()) {
564     error.SetErrorString("Process doesn't support getting memory region info.");
565     return error;
566   }
567 
568   // Get interesting addresses
569   std::vector<size_t> interesting_addresses;
570   auto thread_list = process_sp->GetThreadList();
571   for (size_t i = 0; i < thread_list.GetSize(); ++i) {
572     ThreadSP thread_sp(thread_list.GetThreadAtIndex(i));
573     RegisterContextSP reg_ctx_sp(thread_sp->GetRegisterContext());
574     RegisterContext *reg_ctx = reg_ctx_sp.get();
575 
576     interesting_addresses.push_back(read_register_u64(reg_ctx, "rsp"));
577     interesting_addresses.push_back(read_register_u64(reg_ctx, "rip"));
578   }
579 
580   DataBufferHeap helper_data;
581   std::vector<MemoryDescriptor> mem_descriptors;
582 
583   std::set<addr_t> visited_region_base_addresses;
584   for (size_t interesting_address : interesting_addresses) {
585     MemoryRegionInfo range_info;
586     error = process_sp->GetMemoryRegionInfo(interesting_address, range_info);
587     // Skip failed memory region requests or any regions with no permissions.
588     if (error.Fail() || range_info.GetLLDBPermissions() == 0)
589       continue;
590     const addr_t addr = range_info.GetRange().GetRangeBase();
591     // Skip any regions we have already saved out.
592     if (visited_region_base_addresses.insert(addr).second == false)
593       continue;
594     const addr_t size = range_info.GetRange().GetByteSize();
595     if (size == 0)
596       continue;
597     auto data_up = std::make_unique<DataBufferHeap>(size, 0);
598     const size_t bytes_read =
599         process_sp->ReadMemory(addr, data_up->GetBytes(), size, error);
600     if (bytes_read == 0)
601       continue;
602     // We have a good memory region with valid bytes to store.
603     LocationDescriptor memory_dump;
604     memory_dump.DataSize = static_cast<llvm::support::ulittle32_t>(bytes_read);
605     memory_dump.RVA =
606         static_cast<llvm::support::ulittle32_t>(GetCurrentDataEndOffset());
607     MemoryDescriptor memory_desc;
608     memory_desc.StartOfMemoryRange =
609         static_cast<llvm::support::ulittle64_t>(addr);
610     memory_desc.Memory = memory_dump;
611     mem_descriptors.push_back(memory_desc);
612     m_data.AppendData(data_up->GetBytes(), bytes_read);
613   }
614 
615   AddDirectory(StreamType::MemoryList,
616                sizeof(llvm::support::ulittle32_t) +
617                    mem_descriptors.size() *
618                        sizeof(llvm::minidump::MemoryDescriptor));
619   llvm::support::ulittle32_t memory_ranges_num(mem_descriptors.size());
620 
621   m_data.AppendData(&memory_ranges_num, sizeof(llvm::support::ulittle32_t));
622   for (auto memory_descriptor : mem_descriptors) {
623     m_data.AppendData(&memory_descriptor,
624                       sizeof(llvm::minidump::MemoryDescriptor));
625   }
626 
627   return error;
628 }
629 
630 void MinidumpFileBuilder::AddMiscInfo(const lldb::ProcessSP &process_sp) {
631   AddDirectory(StreamType::MiscInfo,
632                sizeof(lldb_private::minidump::MinidumpMiscInfo));
633 
634   lldb_private::minidump::MinidumpMiscInfo misc_info;
635   misc_info.size = static_cast<llvm::support::ulittle32_t>(
636       sizeof(lldb_private::minidump::MinidumpMiscInfo));
637   // Default set flags1 to 0, in case that we will not be able to
638   // get any information
639   misc_info.flags1 = static_cast<llvm::support::ulittle32_t>(0);
640 
641   lldb_private::ProcessInstanceInfo process_info;
642   process_sp->GetProcessInfo(process_info);
643   if (process_info.ProcessIDIsValid()) {
644     // Set flags1 to reflect that PID is filled in
645     misc_info.flags1 =
646         static_cast<llvm::support::ulittle32_t>(static_cast<uint32_t>(
647             lldb_private::minidump::MinidumpMiscInfoFlags::ProcessID));
648     misc_info.process_id =
649         static_cast<llvm::support::ulittle32_t>(process_info.GetProcessID());
650   }
651 
652   m_data.AppendData(&misc_info,
653                     sizeof(lldb_private::minidump::MinidumpMiscInfo));
654 }
655 
656 std::unique_ptr<llvm::MemoryBuffer>
657 getFileStreamHelper(const std::string &path) {
658   auto maybe_stream = llvm::MemoryBuffer::getFileAsStream(path);
659   if (!maybe_stream)
660     return nullptr;
661   return std::move(maybe_stream.get());
662 }
663 
664 void MinidumpFileBuilder::AddLinuxFileStreams(
665     const lldb::ProcessSP &process_sp) {
666   std::vector<std::pair<StreamType, std::string>> files_with_stream_types = {
667       {StreamType::LinuxCPUInfo, "/proc/cpuinfo"},
668       {StreamType::LinuxLSBRelease, "/etc/lsb-release"},
669   };
670 
671   lldb_private::ProcessInstanceInfo process_info;
672   process_sp->GetProcessInfo(process_info);
673   if (process_info.ProcessIDIsValid()) {
674     lldb::pid_t pid = process_info.GetProcessID();
675     std::string pid_str = std::to_string(pid);
676     files_with_stream_types.push_back(
677         {StreamType::LinuxProcStatus, "/proc/" + pid_str + "/status"});
678     files_with_stream_types.push_back(
679         {StreamType::LinuxCMDLine, "/proc/" + pid_str + "/cmdline"});
680     files_with_stream_types.push_back(
681         {StreamType::LinuxEnviron, "/proc/" + pid_str + "/environ"});
682     files_with_stream_types.push_back(
683         {StreamType::LinuxAuxv, "/proc/" + pid_str + "/auxv"});
684     files_with_stream_types.push_back(
685         {StreamType::LinuxMaps, "/proc/" + pid_str + "/maps"});
686     files_with_stream_types.push_back(
687         {StreamType::LinuxProcStat, "/proc/" + pid_str + "/stat"});
688     files_with_stream_types.push_back(
689         {StreamType::LinuxProcFD, "/proc/" + pid_str + "/fd"});
690   }
691 
692   for (const auto &entry : files_with_stream_types) {
693     StreamType stream = entry.first;
694     std::string path = entry.second;
695     auto memory_buffer = getFileStreamHelper(path);
696 
697     if (memory_buffer) {
698       size_t size = memory_buffer->getBufferSize();
699       if (size == 0)
700         continue;
701       AddDirectory(stream, size);
702       m_data.AppendData(memory_buffer->getBufferStart(), size);
703     }
704   }
705 }
706 
707 Status MinidumpFileBuilder::Dump(lldb::FileUP &core_file) const {
708   constexpr size_t header_size = sizeof(llvm::minidump::Header);
709   constexpr size_t directory_size = sizeof(llvm::minidump::Directory);
710 
711   // write header
712   llvm::minidump::Header header;
713   header.Signature = static_cast<llvm::support::ulittle32_t>(
714       llvm::minidump::Header::MagicSignature);
715   header.Version = static_cast<llvm::support::ulittle32_t>(
716       llvm::minidump::Header::MagicVersion);
717   header.NumberOfStreams =
718       static_cast<llvm::support::ulittle32_t>(GetDirectoriesNum());
719   header.StreamDirectoryRVA =
720       static_cast<llvm::support::ulittle32_t>(GetCurrentDataEndOffset());
721   header.Checksum = static_cast<llvm::support::ulittle32_t>(
722       0u), // not used in most of the writers
723       header.TimeDateStamp =
724           static_cast<llvm::support::ulittle32_t>(std::time(nullptr));
725   header.Flags =
726       static_cast<llvm::support::ulittle64_t>(0u); // minidump normal flag
727 
728   Status error;
729   size_t bytes_written;
730 
731   bytes_written = header_size;
732   error = core_file->Write(&header, bytes_written);
733   if (error.Fail() || bytes_written != header_size) {
734     if (bytes_written != header_size)
735       error.SetErrorStringWithFormat(
736           "unable to write the header (written %zd/%zd)", bytes_written,
737           header_size);
738     return error;
739   }
740 
741   // write data
742   bytes_written = m_data.GetByteSize();
743   error = core_file->Write(m_data.GetBytes(), bytes_written);
744   if (error.Fail() || bytes_written != m_data.GetByteSize()) {
745     if (bytes_written != m_data.GetByteSize())
746       error.SetErrorStringWithFormat(
747           "unable to write the data (written %zd/%" PRIu64 ")", bytes_written,
748           m_data.GetByteSize());
749     return error;
750   }
751 
752   // write directories
753   for (const Directory &dir : m_directories) {
754     bytes_written = directory_size;
755     error = core_file->Write(&dir, bytes_written);
756     if (error.Fail() || bytes_written != directory_size) {
757       if (bytes_written != directory_size)
758         error.SetErrorStringWithFormat(
759             "unable to write the directory (written %zd/%zd)", bytes_written,
760             directory_size);
761       return error;
762     }
763   }
764 
765   return error;
766 }
767 
768 size_t MinidumpFileBuilder::GetDirectoriesNum() const {
769   return m_directories.size();
770 }
771 
772 size_t MinidumpFileBuilder::GetCurrentDataEndOffset() const {
773   return sizeof(llvm::minidump::Header) + m_data.GetByteSize();
774 }
775