llvm/lib/Object/Minidump.cpp

   1 //===- Minidump.cpp - Minidump object file implementation -----------------===//
   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 "llvm/Object/Minidump.h"
  10 #include "llvm/Object/Error.h"
  11 #include "llvm/Support/ConvertUTF.h"
  12
  13 using namespace llvm;
  14 using namespace llvm::object;
  15 using namespace llvm::minidump;
  16
  17 std::optional<ArrayRef<uint8_t>>
  18 MinidumpFile::getRawStream(minidump::StreamType Type) const {
  19   auto It = StreamMap.find(Type);
  20   if (It != StreamMap.end())
  21     return getRawStream(Streams[It->second]);
  22   return std::nullopt;
  23 }
  24
  25 Expected<std::string> MinidumpFile::getString(size_t Offset) const {
  26   // Minidump strings consist of a 32-bit length field, which gives the size of
  27   // the string in *bytes*. This is followed by the actual string encoded in
  28   // UTF16.
  29   auto ExpectedSize =
  30       getDataSliceAs<support::ulittle32_t>(getData(), Offset, 1);
  31   if (!ExpectedSize)
  32     return ExpectedSize.takeError();
  33   size_t Size = (*ExpectedSize)[0];
  34   if (Size % 2 != 0)
  35     return createError("String size not even");
  36   Size /= 2;
  37   if (Size == 0)
  38     return "";
  39
  40   Offset += sizeof(support::ulittle32_t);
  41   auto ExpectedData =
  42       getDataSliceAs<support::ulittle16_t>(getData(), Offset, Size);
  43   if (!ExpectedData)
  44     return ExpectedData.takeError();
  45
  46   SmallVector<UTF16, 32> WStr(Size);
  47   copy(*ExpectedData, WStr.begin());
  48
  49   std::string Result;
  50   if (!convertUTF16ToUTF8String(WStr, Result))
  51     return createError("String decoding failed");
  52
  53   return Result;
  54 }
  55
  56 Expected<iterator_range<MinidumpFile::MemoryInfoIterator>>
  57 MinidumpFile::getMemoryInfoList() const {
  58   std::optional<ArrayRef<uint8_t>> Stream =
  59       getRawStream(StreamType::MemoryInfoList);
  60   if (!Stream)
  61     return createError("No such stream");
  62   auto ExpectedHeader =
  63       getDataSliceAs<minidump::MemoryInfoListHeader>(*Stream, 0, 1);
  64   if (!ExpectedHeader)
  65     return ExpectedHeader.takeError();
  66   const minidump::MemoryInfoListHeader &H = ExpectedHeader.get()[0];
  67   Expected<ArrayRef<uint8_t>> Data =
  68       getDataSlice(*Stream, H.SizeOfHeader, H.SizeOfEntry * H.NumberOfEntries);
  69   if (!Data)
  70     return Data.takeError();
  71   return make_range(MemoryInfoIterator(*Data, H.SizeOfEntry),
  72                     MemoryInfoIterator({}, H.SizeOfEntry));
  73 }
  74
  75 template <typename T>
  76 Expected<ArrayRef<T>> MinidumpFile::getListStream(StreamType Type) const {
  77   std::optional<ArrayRef<uint8_t>> Stream = getRawStream(Type);
  78   if (!Stream)
  79     return createError("No such stream");
  80   auto ExpectedSize = getDataSliceAs<support::ulittle32_t>(*Stream, 0, 1);
  81   if (!ExpectedSize)
  82     return ExpectedSize.takeError();
  83
  84   size_t ListSize = ExpectedSize.get()[0];
  85
  86   size_t ListOffset = 4;
  87   // Some producers insert additional padding bytes to align the list to an
  88   // 8-byte boundary. Check for that by comparing the list size with the overall
  89   // stream size.
  90   if (ListOffset + sizeof(T) * ListSize < Stream->size())
  91     ListOffset = 8;
  92
  93   return getDataSliceAs<T>(*Stream, ListOffset, ListSize);
  94 }
  95 template Expected<ArrayRef<Module>>
  96     MinidumpFile::getListStream(StreamType) const;
  97 template Expected<ArrayRef<Thread>>
  98     MinidumpFile::getListStream(StreamType) const;
  99 template Expected<ArrayRef<MemoryDescriptor>>
 100     MinidumpFile::getListStream(StreamType) const;
 101
 102 Expected<ArrayRef<uint8_t>>
 103 MinidumpFile::getDataSlice(ArrayRef<uint8_t> Data, size_t Offset, size_t Size) {
 104   // Check for overflow.
 105   if (Offset + Size < Offset || Offset + Size < Size ||
 106       Offset + Size > Data.size())
 107     return createEOFError();
 108   return Data.slice(Offset, Size);
 109 }
 110
 111 Expected<std::unique_ptr<MinidumpFile>>
 112 MinidumpFile::create(MemoryBufferRef Source) {
 113   ArrayRef<uint8_t> Data = arrayRefFromStringRef(Source.getBuffer());
 114   auto ExpectedHeader = getDataSliceAs<minidump::Header>(Data, 0, 1);
 115   if (!ExpectedHeader)
 116     return ExpectedHeader.takeError();
 117
 118   const minidump::Header &Hdr = (*ExpectedHeader)[0];
 119   if (Hdr.Signature != Header::MagicSignature)
 120     return createError("Invalid signature");
 121   if ((Hdr.Version & 0xffff) != Header::MagicVersion)
 122     return createError("Invalid version");
 123
 124   auto ExpectedStreams = getDataSliceAs<Directory>(Data, Hdr.StreamDirectoryRVA,
 125                                                    Hdr.NumberOfStreams);
 126   if (!ExpectedStreams)
 127     return ExpectedStreams.takeError();
 128
 129   DenseMap<StreamType, std::size_t> StreamMap;
 130   for (const auto &StreamDescriptor : llvm::enumerate(*ExpectedStreams)) {
 131     StreamType Type = StreamDescriptor.value().Type;
 132     const LocationDescriptor &Loc = StreamDescriptor.value().Location;
 133
 134     Expected<ArrayRef<uint8_t>> Stream =
 135         getDataSlice(Data, Loc.RVA, Loc.DataSize);
 136     if (!Stream)
 137       return Stream.takeError();
 138
 139     if (Type == StreamType::Unused && Loc.DataSize == 0) {
 140       // Ignore dummy streams. This is technically ill-formed, but a number of
 141       // existing minidumps seem to contain such streams.
 142       continue;
 143     }
 144
 145     if (Type == DenseMapInfo<StreamType>::getEmptyKey() ||
 146         Type == DenseMapInfo<StreamType>::getTombstoneKey())
 147       return createError("Cannot handle one of the minidump streams");
 148
 149     // Update the directory map, checking for duplicate stream types.
 150     if (!StreamMap.try_emplace(Type, StreamDescriptor.index()).second)
 151       return createError("Duplicate stream type");
 152   }
 153
 154   return std::unique_ptr<MinidumpFile>(
 155       new MinidumpFile(Source, Hdr, *ExpectedStreams, std::move(StreamMap)));
 156 }