1 //===- GlobalsStream.cpp - PDB Index of Symbols by Name ---------*- 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 // The on-disk structores used in this file are based on the reference 10 // implementation which is available at 11 // https://github.com/Microsoft/microsoft-pdb/blob/master/PDB/dbi/gsi.h 12 // 13 // When you are reading the reference source code, you'd find the 14 // information below useful. 15 // 16 // - ppdb1->m_fMinimalDbgInfo seems to be always true. 17 // - SMALLBUCKETS macro is defined. 18 // 19 //===----------------------------------------------------------------------===// 20 21 #include "llvm/DebugInfo/PDB/Native/GlobalsStream.h" 22 23 #include "llvm/DebugInfo/CodeView/RecordName.h" 24 #include "llvm/DebugInfo/MSF/MappedBlockStream.h" 25 #include "llvm/DebugInfo/PDB/Native/Hash.h" 26 #include "llvm/DebugInfo/PDB/Native/RawError.h" 27 #include "llvm/DebugInfo/PDB/Native/SymbolStream.h" 28 #include "llvm/Support/BinaryStreamReader.h" 29 #include "llvm/Support/Error.h" 30 #include <algorithm> 31 32 using namespace llvm; 33 using namespace llvm::msf; 34 using namespace llvm::pdb; 35 36 GlobalsStream::GlobalsStream(std::unique_ptr<MappedBlockStream> Stream) 37 : Stream(std::move(Stream)) {} 38 39 GlobalsStream::~GlobalsStream() = default; 40 41 Error GlobalsStream::reload() { 42 BinaryStreamReader Reader(*Stream); 43 if (auto E = GlobalsTable.read(Reader)) 44 return E; 45 return Error::success(); 46 } 47 48 std::vector<std::pair<uint32_t, codeview::CVSymbol>> 49 GlobalsStream::findRecordsByName(StringRef Name, 50 const SymbolStream &Symbols) const { 51 std::vector<std::pair<uint32_t, codeview::CVSymbol>> Result; 52 53 // Hash the name to figure out which bucket this goes into. 54 size_t ExpandedBucketIndex = hashStringV1(Name) % IPHR_HASH; 55 int32_t CompressedBucketIndex = GlobalsTable.BucketMap[ExpandedBucketIndex]; 56 if (CompressedBucketIndex == -1) 57 return Result; 58 59 uint32_t LastBucketIndex = GlobalsTable.HashBuckets.size() - 1; 60 uint32_t StartRecordIndex = 61 GlobalsTable.HashBuckets[CompressedBucketIndex] / 12; 62 uint32_t EndRecordIndex = 0; 63 if (LLVM_LIKELY(uint32_t(CompressedBucketIndex) < LastBucketIndex)) { 64 EndRecordIndex = GlobalsTable.HashBuckets[CompressedBucketIndex + 1]; 65 } else { 66 // If this is the last bucket, it consists of all hash records until the end 67 // of the HashRecords array. 68 EndRecordIndex = GlobalsTable.HashRecords.size() * 12; 69 } 70 71 EndRecordIndex /= 12; 72 73 assert(EndRecordIndex <= GlobalsTable.HashRecords.size()); 74 while (StartRecordIndex < EndRecordIndex) { 75 PSHashRecord PSH = GlobalsTable.HashRecords[StartRecordIndex]; 76 uint32_t Off = PSH.Off - 1; 77 codeview::CVSymbol Record = Symbols.readRecord(Off); 78 if (codeview::getSymbolName(Record) == Name) 79 Result.push_back(std::make_pair(Off, std::move(Record))); 80 ++StartRecordIndex; 81 } 82 return Result; 83 } 84 85 static Error checkHashHdrVersion(const GSIHashHeader *HashHdr) { 86 if (HashHdr->VerHdr != GSIHashHeader::HdrVersion) 87 return make_error<RawError>( 88 raw_error_code::feature_unsupported, 89 "Encountered unsupported globals stream version."); 90 91 return Error::success(); 92 } 93 94 static Error readGSIHashHeader(const GSIHashHeader *&HashHdr, 95 BinaryStreamReader &Reader) { 96 if (Reader.readObject(HashHdr)) 97 return make_error<RawError>(raw_error_code::corrupt_file, 98 "Stream does not contain a GSIHashHeader."); 99 100 if (HashHdr->VerSignature != GSIHashHeader::HdrSignature) 101 return make_error<RawError>( 102 raw_error_code::feature_unsupported, 103 "GSIHashHeader signature (0xffffffff) not found."); 104 105 return Error::success(); 106 } 107 108 static Error readGSIHashRecords(FixedStreamArray<PSHashRecord> &HashRecords, 109 const GSIHashHeader *HashHdr, 110 BinaryStreamReader &Reader) { 111 if (auto EC = checkHashHdrVersion(HashHdr)) 112 return EC; 113 114 // HashHdr->HrSize specifies the number of bytes of PSHashRecords we have. 115 // Verify that we can read them all. 116 if (HashHdr->HrSize % sizeof(PSHashRecord)) 117 return make_error<RawError>(raw_error_code::corrupt_file, 118 "Invalid HR array size."); 119 uint32_t NumHashRecords = HashHdr->HrSize / sizeof(PSHashRecord); 120 if (auto EC = Reader.readArray(HashRecords, NumHashRecords)) 121 return joinErrors(std::move(EC), 122 make_error<RawError>(raw_error_code::corrupt_file, 123 "Error reading hash records.")); 124 125 return Error::success(); 126 } 127 128 static Error 129 readGSIHashBuckets(FixedStreamArray<support::ulittle32_t> &HashBuckets, 130 FixedStreamArray<support::ulittle32_t> &HashBitmap, 131 const GSIHashHeader *HashHdr, 132 MutableArrayRef<int32_t> BucketMap, 133 BinaryStreamReader &Reader) { 134 if (auto EC = checkHashHdrVersion(HashHdr)) 135 return EC; 136 137 // Before the actual hash buckets, there is a bitmap of length determined by 138 // IPHR_HASH. 139 size_t BitmapSizeInBits = alignTo(IPHR_HASH + 1, 32); 140 uint32_t NumBitmapEntries = BitmapSizeInBits / 32; 141 if (auto EC = Reader.readArray(HashBitmap, NumBitmapEntries)) 142 return joinErrors(std::move(EC), 143 make_error<RawError>(raw_error_code::corrupt_file, 144 "Could not read a bitmap.")); 145 uint32_t CompressedBucketIdx = 0; 146 for (uint32_t I = 0; I <= IPHR_HASH; ++I) { 147 uint8_t WordIdx = I / 32; 148 uint8_t BitIdx = I % 32; 149 bool IsSet = HashBitmap[WordIdx] & (1U << BitIdx); 150 if (IsSet) { 151 BucketMap[I] = CompressedBucketIdx++; 152 } else { 153 BucketMap[I] = -1; 154 } 155 } 156 157 uint32_t NumBuckets = 0; 158 for (uint32_t B : HashBitmap) 159 NumBuckets += llvm::popcount(B); 160 161 // Hash buckets follow. 162 if (auto EC = Reader.readArray(HashBuckets, NumBuckets)) 163 return joinErrors(std::move(EC), 164 make_error<RawError>(raw_error_code::corrupt_file, 165 "Hash buckets corrupted.")); 166 167 return Error::success(); 168 } 169 170 Error GSIHashTable::read(BinaryStreamReader &Reader) { 171 if (auto EC = readGSIHashHeader(HashHdr, Reader)) 172 return EC; 173 if (auto EC = readGSIHashRecords(HashRecords, HashHdr, Reader)) 174 return EC; 175 if (HashHdr->HrSize > 0) 176 if (auto EC = readGSIHashBuckets(HashBuckets, HashBitmap, HashHdr, 177 BucketMap, Reader)) 178 return EC; 179 return Error::success(); 180 } 181