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 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 None; 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 Optional<ArrayRef<uint8_t>> Stream = getRawStream(StreamType::MemoryInfoList); 59 if (!Stream) 60 return createError("No such stream"); 61 auto ExpectedHeader = 62 getDataSliceAs<minidump::MemoryInfoListHeader>(*Stream, 0, 1); 63 if (!ExpectedHeader) 64 return ExpectedHeader.takeError(); 65 const minidump::MemoryInfoListHeader &H = ExpectedHeader.get()[0]; 66 Expected<ArrayRef<uint8_t>> Data = 67 getDataSlice(*Stream, H.SizeOfHeader, H.SizeOfEntry * H.NumberOfEntries); 68 if (!Data) 69 return Data.takeError(); 70 return make_range(MemoryInfoIterator(*Data, H.SizeOfEntry), 71 MemoryInfoIterator({}, H.SizeOfEntry)); 72 } 73 74 template <typename T> 75 Expected<ArrayRef<T>> MinidumpFile::getListStream(StreamType Type) const { 76 Optional<ArrayRef<uint8_t>> Stream = getRawStream(Type); 77 if (!Stream) 78 return createError("No such stream"); 79 auto ExpectedSize = getDataSliceAs<support::ulittle32_t>(*Stream, 0, 1); 80 if (!ExpectedSize) 81 return ExpectedSize.takeError(); 82 83 size_t ListSize = ExpectedSize.get()[0]; 84 85 size_t ListOffset = 4; 86 // Some producers insert additional padding bytes to align the list to an 87 // 8-byte boundary. Check for that by comparing the list size with the overall 88 // stream size. 89 if (ListOffset + sizeof(T) * ListSize < Stream->size()) 90 ListOffset = 8; 91 92 return getDataSliceAs<T>(*Stream, ListOffset, ListSize); 93 } 94 template Expected<ArrayRef<Module>> 95 MinidumpFile::getListStream(StreamType) const; 96 template Expected<ArrayRef<Thread>> 97 MinidumpFile::getListStream(StreamType) const; 98 template Expected<ArrayRef<MemoryDescriptor>> 99 MinidumpFile::getListStream(StreamType) const; 100 101 Expected<ArrayRef<uint8_t>> 102 MinidumpFile::getDataSlice(ArrayRef<uint8_t> Data, size_t Offset, size_t Size) { 103 // Check for overflow. 104 if (Offset + Size < Offset || Offset + Size < Size || 105 Offset + Size > Data.size()) 106 return createEOFError(); 107 return Data.slice(Offset, Size); 108 } 109 110 Expected<std::unique_ptr<MinidumpFile>> 111 MinidumpFile::create(MemoryBufferRef Source) { 112 ArrayRef<uint8_t> Data = arrayRefFromStringRef(Source.getBuffer()); 113 auto ExpectedHeader = getDataSliceAs<minidump::Header>(Data, 0, 1); 114 if (!ExpectedHeader) 115 return ExpectedHeader.takeError(); 116 117 const minidump::Header &Hdr = (*ExpectedHeader)[0]; 118 if (Hdr.Signature != Header::MagicSignature) 119 return createError("Invalid signature"); 120 if ((Hdr.Version & 0xffff) != Header::MagicVersion) 121 return createError("Invalid version"); 122 123 auto ExpectedStreams = getDataSliceAs<Directory>(Data, Hdr.StreamDirectoryRVA, 124 Hdr.NumberOfStreams); 125 if (!ExpectedStreams) 126 return ExpectedStreams.takeError(); 127 128 DenseMap<StreamType, std::size_t> StreamMap; 129 for (const auto &StreamDescriptor : llvm::enumerate(*ExpectedStreams)) { 130 StreamType Type = StreamDescriptor.value().Type; 131 const LocationDescriptor &Loc = StreamDescriptor.value().Location; 132 133 Expected<ArrayRef<uint8_t>> Stream = 134 getDataSlice(Data, Loc.RVA, Loc.DataSize); 135 if (!Stream) 136 return Stream.takeError(); 137 138 if (Type == StreamType::Unused && Loc.DataSize == 0) { 139 // Ignore dummy streams. This is technically ill-formed, but a number of 140 // existing minidumps seem to contain such streams. 141 continue; 142 } 143 144 if (Type == DenseMapInfo<StreamType>::getEmptyKey() || 145 Type == DenseMapInfo<StreamType>::getTombstoneKey()) 146 return createError("Cannot handle one of the minidump streams"); 147 148 // Update the directory map, checking for duplicate stream types. 149 if (!StreamMap.try_emplace(Type, StreamDescriptor.index()).second) 150 return createError("Duplicate stream type"); 151 } 152 153 return std::unique_ptr<MinidumpFile>( 154 new MinidumpFile(Source, Hdr, *ExpectedStreams, std::move(StreamMap))); 155 } 156