contrib/llvm/tools/lldb/source/Plugins/Process/minidump/MinidumpTypes.cpp

   1 //===-- MinidumpTypes.cpp ---------------------------------------*- C++ -*-===//
   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 "MinidumpTypes.h"
  10
  11 // C includes
  12 // C++ includes
  13
  14 using namespace lldb_private;
  15 using namespace minidump;
  16
  17 // MinidumpMiscInfo
  18 const MinidumpMiscInfo *MinidumpMiscInfo::Parse(llvm::ArrayRef<uint8_t> &data) {
  19   const MinidumpMiscInfo *misc_info;
  20   Status error = consumeObject(data, misc_info);
  21   if (error.Fail())
  22     return nullptr;
  23
  24   return misc_info;
  25 }
  26
  27 llvm::Optional<lldb::pid_t> MinidumpMiscInfo::GetPid() const {
  28   uint32_t pid_flag = static_cast<uint32_t>(MinidumpMiscInfoFlags::ProcessID);
  29   if (flags1 & pid_flag)
  30     return llvm::Optional<lldb::pid_t>(process_id);
  31
  32   return llvm::None;
  33 }
  34
  35 // Linux Proc Status
  36 // it's stored as an ascii string in the file
  37 llvm::Optional<LinuxProcStatus>
  38 LinuxProcStatus::Parse(llvm::ArrayRef<uint8_t> &data) {
  39   LinuxProcStatus result;
  40   result.proc_status =
  41       llvm::StringRef(reinterpret_cast<const char *>(data.data()), data.size());
  42   data = data.drop_front(data.size());
  43
  44   llvm::SmallVector<llvm::StringRef, 0> lines;
  45   result.proc_status.split(lines, '\n', 42);
  46   // /proc/$pid/status has 41 lines, but why not use 42?
  47   for (auto line : lines) {
  48     if (line.consume_front("Pid:")) {
  49       line = line.trim();
  50       if (!line.getAsInteger(10, result.pid))
  51         return result;
  52     }
  53   }
  54
  55   return llvm::None;
  56 }
  57
  58 lldb::pid_t LinuxProcStatus::GetPid() const { return pid; }
  59
  60 // Exception stuff
  61 const MinidumpExceptionStream *
  62 MinidumpExceptionStream::Parse(llvm::ArrayRef<uint8_t> &data) {
  63   const MinidumpExceptionStream *exception_stream = nullptr;
  64   Status error = consumeObject(data, exception_stream);
  65   if (error.Fail())
  66     return nullptr;
  67
  68   return exception_stream;
  69 }
  70
  71 std::pair<llvm::ArrayRef<MinidumpMemoryDescriptor64>, uint64_t>
  72 MinidumpMemoryDescriptor64::ParseMemory64List(llvm::ArrayRef<uint8_t> &data) {
  73   const llvm::support::ulittle64_t *mem_ranges_count;
  74   Status error = consumeObject(data, mem_ranges_count);
  75   if (error.Fail() ||
  76       *mem_ranges_count * sizeof(MinidumpMemoryDescriptor64) > data.size())
  77     return {};
  78
  79   const llvm::support::ulittle64_t *base_rva;
  80   error = consumeObject(data, base_rva);
  81   if (error.Fail())
  82     return {};
  83
  84   return std::make_pair(
  85       llvm::makeArrayRef(
  86           reinterpret_cast<const MinidumpMemoryDescriptor64 *>(data.data()),
  87           *mem_ranges_count),
  88       *base_rva);
  89 }
  90
  91 std::vector<const MinidumpMemoryInfo *>
  92 MinidumpMemoryInfo::ParseMemoryInfoList(llvm::ArrayRef<uint8_t> &data) {
  93   const MinidumpMemoryInfoListHeader *header;
  94   Status error = consumeObject(data, header);
  95   if (error.Fail() ||
  96       header->size_of_header < sizeof(MinidumpMemoryInfoListHeader) ||
  97       header->size_of_entry < sizeof(MinidumpMemoryInfo))
  98     return {};
  99
 100   data = data.drop_front(header->size_of_header -
 101                          sizeof(MinidumpMemoryInfoListHeader));
 102
 103   if (header->size_of_entry * header->num_of_entries > data.size())
 104     return {};
 105
 106   std::vector<const MinidumpMemoryInfo *> result;
 107   result.reserve(header->num_of_entries);
 108
 109   for (uint64_t i = 0; i < header->num_of_entries; ++i) {
 110     result.push_back(reinterpret_cast<const MinidumpMemoryInfo *>(
 111         data.data() + i * header->size_of_entry));
 112   }
 113
 114   return result;
 115 }