1 //===- PublicsStream.cpp - PDB Public Symbol Stream -----------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // The data structures defined in this file are based on the reference
11 // implementation which is available at
12 // https://github.com/Microsoft/microsoft-pdb/blob/master/PDB/dbi/gsi.h
13 //
14 // When you are reading the reference source code, you'd find the
15 // information below useful.
16 //
17 // - ppdb1->m_fMinimalDbgInfo seems to be always true.
18 // - SMALLBUCKETS macro is defined.
19 //
20 // The reference doesn't compile, so I learned just by reading code.
21 // It's not guaranteed to be correct.
22 //
23 //===----------------------------------------------------------------------===//
24
25 #include "llvm/DebugInfo/PDB/Raw/PublicsStream.h"
26
27 #include "llvm/DebugInfo/CodeView/CodeView.h"
28 #include "llvm/DebugInfo/CodeView/StreamReader.h"
29 #include "llvm/DebugInfo/CodeView/TypeRecord.h"
30 #include "llvm/DebugInfo/PDB/Raw/IndexedStreamData.h"
31 #include "llvm/DebugInfo/PDB/Raw/MappedBlockStream.h"
32 #include "llvm/DebugInfo/PDB/Raw/PDBFile.h"
33 #include "llvm/DebugInfo/PDB/Raw/RawConstants.h"
34 #include "llvm/DebugInfo/PDB/Raw/RawError.h"
35 #include "llvm/DebugInfo/PDB/Raw/SymbolStream.h"
36
37 #include "llvm/ADT/BitVector.h"
38 #include "llvm/Support/Endian.h"
39 #include "llvm/Support/Format.h"
40 #include "llvm/Support/MathExtras.h"
41
42 using namespace llvm;
43 using namespace llvm::support;
44 using namespace llvm::pdb;
45
46
47 static const unsigned IPHR_HASH = 4096;
48
49 // This is PSGSIHDR struct defined in
50 // https://github.com/Microsoft/microsoft-pdb/blob/master/PDB/dbi/gsi.h
51 struct PublicsStream::HeaderInfo {
52 ulittle32_t SymHash;
53 ulittle32_t AddrMap;
54 ulittle32_t NumThunks;
55 ulittle32_t SizeOfThunk;
56 ulittle16_t ISectThunkTable;
57 char Padding[2];
58 ulittle32_t OffThunkTable;
59 ulittle32_t NumSections;
60 };
61
62 // This is GSIHashHdr.
63 struct PublicsStream::GSIHashHeader {
64 enum : unsigned {
65 HdrSignature = ~0U,
66 HdrVersion = 0xeffe0000 + 19990810,
67 };
68 ulittle32_t VerSignature;
69 ulittle32_t VerHdr;
70 ulittle32_t HrSize;
71 ulittle32_t NumBuckets;
72 };
73
PublicsStream(PDBFile & File,std::unique_ptr<MappedBlockStream> Stream)74 PublicsStream::PublicsStream(PDBFile &File,
75 std::unique_ptr<MappedBlockStream> Stream)
76 : Pdb(File), Stream(std::move(Stream)) {}
77
~PublicsStream()78 PublicsStream::~PublicsStream() {}
79
getSymHash() const80 uint32_t PublicsStream::getSymHash() const { return Header->SymHash; }
getAddrMap() const81 uint32_t PublicsStream::getAddrMap() const { return Header->AddrMap; }
82
83 // Publics stream contains fixed-size headers and a serialized hash table.
84 // This implementation is not complete yet. It reads till the end of the
85 // stream so that we verify the stream is at least not corrupted. However,
86 // we skip over the hash table which we believe contains information about
87 // public symbols.
reload()88 Error PublicsStream::reload() {
89 codeview::StreamReader Reader(*Stream);
90
91 // Check stream size.
92 if (Reader.bytesRemaining() < sizeof(HeaderInfo) + sizeof(GSIHashHeader))
93 return make_error<RawError>(raw_error_code::corrupt_file,
94 "Publics Stream does not contain a header.");
95
96 // Read PSGSIHDR and GSIHashHdr structs.
97 if (Reader.readObject(Header))
98 return make_error<RawError>(raw_error_code::corrupt_file,
99 "Publics Stream does not contain a header.");
100
101 if (Reader.readObject(HashHdr))
102 return make_error<RawError>(raw_error_code::corrupt_file,
103 "Publics Stream does not contain a header.");
104
105 // An array of HashRecord follows. Read them.
106 if (HashHdr->HrSize % sizeof(PSHashRecord))
107 return make_error<RawError>(raw_error_code::corrupt_file,
108 "Invalid HR array size.");
109 uint32_t NumHashRecords = HashHdr->HrSize / sizeof(PSHashRecord);
110 if (auto EC = Reader.readArray(HashRecords, NumHashRecords))
111 return joinErrors(std::move(EC),
112 make_error<RawError>(raw_error_code::corrupt_file,
113 "Could not read an HR array"));
114
115 // A bitmap of a fixed length follows.
116 size_t BitmapSizeInBits = alignTo(IPHR_HASH + 1, 32);
117 uint32_t NumBitmapEntries = BitmapSizeInBits / 8;
118 if (auto EC = Reader.readBytes(Bitmap, NumBitmapEntries))
119 return joinErrors(std::move(EC),
120 make_error<RawError>(raw_error_code::corrupt_file,
121 "Could not read a bitmap."));
122 for (uint8_t B : Bitmap)
123 NumBuckets += countPopulation(B);
124
125 // We don't yet understand the following data structures completely,
126 // but we at least know the types and sizes. Here we are trying
127 // to read the stream till end so that we at least can detect
128 // corrupted streams.
129
130 // Hash buckets follow.
131 if (auto EC = Reader.readArray(HashBuckets, NumBuckets))
132 return joinErrors(std::move(EC),
133 make_error<RawError>(raw_error_code::corrupt_file,
134 "Hash buckets corrupted."));
135
136 // Something called "address map" follows.
137 uint32_t NumAddressMapEntries = Header->AddrMap / sizeof(uint32_t);
138 if (auto EC = Reader.readArray(AddressMap, NumAddressMapEntries))
139 return joinErrors(std::move(EC),
140 make_error<RawError>(raw_error_code::corrupt_file,
141 "Could not read an address map."));
142
143 // Something called "thunk map" follows.
144 if (auto EC = Reader.readArray(ThunkMap, Header->NumThunks))
145 return joinErrors(std::move(EC),
146 make_error<RawError>(raw_error_code::corrupt_file,
147 "Could not read a thunk map."));
148
149 // Something called "section map" follows.
150 if (auto EC = Reader.readArray(SectionOffsets, Header->NumSections))
151 return joinErrors(std::move(EC),
152 make_error<RawError>(raw_error_code::corrupt_file,
153 "Could not read a section map."));
154
155 if (Reader.bytesRemaining() > 0)
156 return make_error<RawError>(raw_error_code::corrupt_file,
157 "Corrupted publics stream.");
158 return Error::success();
159 }
160
161 iterator_range<codeview::CVSymbolArray::Iterator>
getSymbols(bool * HadError) const162 PublicsStream::getSymbols(bool *HadError) const {
163 auto SymbolS = Pdb.getPDBSymbolStream();
164 if (SymbolS.takeError()) {
165 codeview::CVSymbolArray::Iterator Iter;
166 return llvm::make_range(Iter, Iter);
167 }
168 SymbolStream &SS = SymbolS.get();
169
170 return SS.getSymbols(HadError);
171 }
172
commit()173 Error PublicsStream::commit() { return Error::success(); }
174