1 //===- PDBFileBuilder.cpp - PDB File Creation -------------------*- 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 "llvm/DebugInfo/PDB/Native/PDBFileBuilder.h"
10 
11 #include "llvm/ADT/BitVector.h"
12 
13 #include "llvm/DebugInfo/MSF/MSFBuilder.h"
14 #include "llvm/DebugInfo/PDB/Native/DbiStream.h"
15 #include "llvm/DebugInfo/PDB/Native/DbiStreamBuilder.h"
16 #include "llvm/DebugInfo/PDB/Native/GSIStreamBuilder.h"
17 #include "llvm/DebugInfo/PDB/Native/InfoStream.h"
18 #include "llvm/DebugInfo/PDB/Native/InfoStreamBuilder.h"
19 #include "llvm/DebugInfo/PDB/Native/PDBStringTableBuilder.h"
20 #include "llvm/DebugInfo/PDB/Native/RawError.h"
21 #include "llvm/DebugInfo/PDB/Native/TpiStream.h"
22 #include "llvm/DebugInfo/PDB/Native/TpiStreamBuilder.h"
23 #include "llvm/Support/BinaryStream.h"
24 #include "llvm/Support/BinaryStreamWriter.h"
25 #include "llvm/Support/CRC.h"
26 #include "llvm/Support/Path.h"
27 #include "llvm/Support/xxhash.h"
28 
29 using namespace llvm;
30 using namespace llvm::codeview;
31 using namespace llvm::msf;
32 using namespace llvm::pdb;
33 using namespace llvm::support;
34 
35 PDBFileBuilder::PDBFileBuilder(BumpPtrAllocator &Allocator)
36     : Allocator(Allocator), InjectedSourceHashTraits(Strings),
37       InjectedSourceTable(2) {}
38 
39 PDBFileBuilder::~PDBFileBuilder() {}
40 
41 Error PDBFileBuilder::initialize(uint32_t BlockSize) {
42   auto ExpectedMsf = MSFBuilder::create(Allocator, BlockSize);
43   if (!ExpectedMsf)
44     return ExpectedMsf.takeError();
45   Msf = std::make_unique<MSFBuilder>(std::move(*ExpectedMsf));
46   return Error::success();
47 }
48 
49 MSFBuilder &PDBFileBuilder::getMsfBuilder() { return *Msf; }
50 
51 InfoStreamBuilder &PDBFileBuilder::getInfoBuilder() {
52   if (!Info)
53     Info = std::make_unique<InfoStreamBuilder>(*Msf, NamedStreams);
54   return *Info;
55 }
56 
57 DbiStreamBuilder &PDBFileBuilder::getDbiBuilder() {
58   if (!Dbi)
59     Dbi = std::make_unique<DbiStreamBuilder>(*Msf);
60   return *Dbi;
61 }
62 
63 TpiStreamBuilder &PDBFileBuilder::getTpiBuilder() {
64   if (!Tpi)
65     Tpi = std::make_unique<TpiStreamBuilder>(*Msf, StreamTPI);
66   return *Tpi;
67 }
68 
69 TpiStreamBuilder &PDBFileBuilder::getIpiBuilder() {
70   if (!Ipi)
71     Ipi = std::make_unique<TpiStreamBuilder>(*Msf, StreamIPI);
72   return *Ipi;
73 }
74 
75 PDBStringTableBuilder &PDBFileBuilder::getStringTableBuilder() {
76   return Strings;
77 }
78 
79 GSIStreamBuilder &PDBFileBuilder::getGsiBuilder() {
80   if (!Gsi)
81     Gsi = std::make_unique<GSIStreamBuilder>(*Msf);
82   return *Gsi;
83 }
84 
85 Expected<uint32_t> PDBFileBuilder::allocateNamedStream(StringRef Name,
86                                                        uint32_t Size) {
87   auto ExpectedStream = Msf->addStream(Size);
88   if (ExpectedStream)
89     NamedStreams.set(Name, *ExpectedStream);
90   return ExpectedStream;
91 }
92 
93 Error PDBFileBuilder::addNamedStream(StringRef Name, StringRef Data) {
94   Expected<uint32_t> ExpectedIndex = allocateNamedStream(Name, Data.size());
95   if (!ExpectedIndex)
96     return ExpectedIndex.takeError();
97   assert(NamedStreamData.count(*ExpectedIndex) == 0);
98   NamedStreamData[*ExpectedIndex] = Data;
99   return Error::success();
100 }
101 
102 void PDBFileBuilder::addInjectedSource(StringRef Name,
103                                        std::unique_ptr<MemoryBuffer> Buffer) {
104   // Stream names must be exact matches, since they get looked up in a hash
105   // table and the hash value is dependent on the exact contents of the string.
106   // link.exe lowercases a path and converts / to \, so we must do the same.
107   SmallString<64> VName;
108   sys::path::native(Name.lower(), VName);
109 
110   uint32_t NI = getStringTableBuilder().insert(Name);
111   uint32_t VNI = getStringTableBuilder().insert(VName);
112 
113   InjectedSourceDescriptor Desc;
114   Desc.Content = std::move(Buffer);
115   Desc.NameIndex = NI;
116   Desc.VNameIndex = VNI;
117   Desc.StreamName = "/src/files/";
118 
119   Desc.StreamName += VName;
120 
121   InjectedSources.push_back(std::move(Desc));
122 }
123 
124 Error PDBFileBuilder::finalizeMsfLayout() {
125 
126   if (Ipi && Ipi->getRecordCount() > 0) {
127     // In theory newer PDBs always have an ID stream, but by saying that we're
128     // only going to *really* have an ID stream if there is at least one ID
129     // record, we leave open the opportunity to test older PDBs such as those
130     // that don't have an ID stream.
131     auto &Info = getInfoBuilder();
132     Info.addFeature(PdbRaw_FeatureSig::VC140);
133   }
134 
135   uint32_t StringsLen = Strings.calculateSerializedSize();
136 
137   Expected<uint32_t> SN = allocateNamedStream("/LinkInfo", 0);
138   if (!SN)
139     return SN.takeError();
140 
141   if (Gsi) {
142     if (auto EC = Gsi->finalizeMsfLayout())
143       return EC;
144     if (Dbi) {
145       Dbi->setPublicsStreamIndex(Gsi->getPublicsStreamIndex());
146       Dbi->setGlobalsStreamIndex(Gsi->getGlobalsStreamIndex());
147       Dbi->setSymbolRecordStreamIndex(Gsi->getRecordStreamIdx());
148     }
149   }
150   if (Tpi) {
151     if (auto EC = Tpi->finalizeMsfLayout())
152       return EC;
153   }
154   if (Dbi) {
155     if (auto EC = Dbi->finalizeMsfLayout())
156       return EC;
157   }
158   SN = allocateNamedStream("/names", StringsLen);
159   if (!SN)
160     return SN.takeError();
161 
162   if (Ipi) {
163     if (auto EC = Ipi->finalizeMsfLayout())
164       return EC;
165   }
166 
167   // Do this last, since it relies on the named stream map being complete, and
168   // that can be updated by previous steps in the finalization.
169   if (Info) {
170     if (auto EC = Info->finalizeMsfLayout())
171       return EC;
172   }
173 
174   if (!InjectedSources.empty()) {
175     for (const auto &IS : InjectedSources) {
176       JamCRC CRC(0);
177       CRC.update(arrayRefFromStringRef(IS.Content->getBuffer()));
178 
179       SrcHeaderBlockEntry Entry;
180       ::memset(&Entry, 0, sizeof(SrcHeaderBlockEntry));
181       Entry.Size = sizeof(SrcHeaderBlockEntry);
182       Entry.FileSize = IS.Content->getBufferSize();
183       Entry.FileNI = IS.NameIndex;
184       Entry.VFileNI = IS.VNameIndex;
185       Entry.ObjNI = 1;
186       Entry.IsVirtual = 0;
187       Entry.Version =
188           static_cast<uint32_t>(PdbRaw_SrcHeaderBlockVer::SrcVerOne);
189       Entry.CRC = CRC.getCRC();
190       StringRef VName = getStringTableBuilder().getStringForId(IS.VNameIndex);
191       InjectedSourceTable.set_as(VName, std::move(Entry),
192                                  InjectedSourceHashTraits);
193     }
194 
195     uint32_t SrcHeaderBlockSize =
196         sizeof(SrcHeaderBlockHeader) +
197         InjectedSourceTable.calculateSerializedLength();
198     SN = allocateNamedStream("/src/headerblock", SrcHeaderBlockSize);
199     if (!SN)
200       return SN.takeError();
201     for (const auto &IS : InjectedSources) {
202       SN = allocateNamedStream(IS.StreamName, IS.Content->getBufferSize());
203       if (!SN)
204         return SN.takeError();
205     }
206   }
207 
208   // Do this last, since it relies on the named stream map being complete, and
209   // that can be updated by previous steps in the finalization.
210   if (Info) {
211     if (auto EC = Info->finalizeMsfLayout())
212       return EC;
213   }
214 
215   return Error::success();
216 }
217 
218 Expected<uint32_t> PDBFileBuilder::getNamedStreamIndex(StringRef Name) const {
219   uint32_t SN = 0;
220   if (!NamedStreams.get(Name, SN))
221     return llvm::make_error<pdb::RawError>(raw_error_code::no_stream);
222   return SN;
223 }
224 
225 void PDBFileBuilder::commitSrcHeaderBlock(WritableBinaryStream &MsfBuffer,
226                                           const msf::MSFLayout &Layout) {
227   assert(!InjectedSourceTable.empty());
228 
229   uint32_t SN = cantFail(getNamedStreamIndex("/src/headerblock"));
230   auto Stream = WritableMappedBlockStream::createIndexedStream(
231       Layout, MsfBuffer, SN, Allocator);
232   BinaryStreamWriter Writer(*Stream);
233 
234   SrcHeaderBlockHeader Header;
235   ::memset(&Header, 0, sizeof(Header));
236   Header.Version = static_cast<uint32_t>(PdbRaw_SrcHeaderBlockVer::SrcVerOne);
237   Header.Size = Writer.bytesRemaining();
238 
239   cantFail(Writer.writeObject(Header));
240   cantFail(InjectedSourceTable.commit(Writer));
241 
242   assert(Writer.bytesRemaining() == 0);
243 }
244 
245 void PDBFileBuilder::commitInjectedSources(WritableBinaryStream &MsfBuffer,
246                                            const msf::MSFLayout &Layout) {
247   if (InjectedSourceTable.empty())
248     return;
249 
250   commitSrcHeaderBlock(MsfBuffer, Layout);
251 
252   for (const auto &IS : InjectedSources) {
253     uint32_t SN = cantFail(getNamedStreamIndex(IS.StreamName));
254 
255     auto SourceStream = WritableMappedBlockStream::createIndexedStream(
256         Layout, MsfBuffer, SN, Allocator);
257     BinaryStreamWriter SourceWriter(*SourceStream);
258     assert(SourceWriter.bytesRemaining() == IS.Content->getBufferSize());
259     cantFail(SourceWriter.writeBytes(
260         arrayRefFromStringRef(IS.Content->getBuffer())));
261   }
262 }
263 
264 Error PDBFileBuilder::commit(StringRef Filename, codeview::GUID *Guid) {
265   assert(!Filename.empty());
266   if (auto EC = finalizeMsfLayout())
267     return EC;
268 
269   MSFLayout Layout;
270   Expected<FileBufferByteStream> ExpectedMsfBuffer =
271       Msf->commit(Filename, Layout);
272   if (!ExpectedMsfBuffer)
273     return ExpectedMsfBuffer.takeError();
274   FileBufferByteStream Buffer = std::move(*ExpectedMsfBuffer);
275 
276   auto ExpectedSN = getNamedStreamIndex("/names");
277   if (!ExpectedSN)
278     return ExpectedSN.takeError();
279 
280   auto NS = WritableMappedBlockStream::createIndexedStream(
281       Layout, Buffer, *ExpectedSN, Allocator);
282   BinaryStreamWriter NSWriter(*NS);
283   if (auto EC = Strings.commit(NSWriter))
284     return EC;
285 
286   for (const auto &NSE : NamedStreamData) {
287     if (NSE.second.empty())
288       continue;
289 
290     auto NS = WritableMappedBlockStream::createIndexedStream(
291         Layout, Buffer, NSE.first, Allocator);
292     BinaryStreamWriter NSW(*NS);
293     if (auto EC = NSW.writeBytes(arrayRefFromStringRef(NSE.second)))
294       return EC;
295   }
296 
297   if (Info) {
298     if (auto EC = Info->commit(Layout, Buffer))
299       return EC;
300   }
301 
302   if (Dbi) {
303     if (auto EC = Dbi->commit(Layout, Buffer))
304       return EC;
305   }
306 
307   if (Tpi) {
308     if (auto EC = Tpi->commit(Layout, Buffer))
309       return EC;
310   }
311 
312   if (Ipi) {
313     if (auto EC = Ipi->commit(Layout, Buffer))
314       return EC;
315   }
316 
317   if (Gsi) {
318     if (auto EC = Gsi->commit(Layout, Buffer))
319       return EC;
320   }
321 
322   auto InfoStreamBlocks = Layout.StreamMap[StreamPDB];
323   assert(!InfoStreamBlocks.empty());
324   uint64_t InfoStreamFileOffset =
325       blockToOffset(InfoStreamBlocks.front(), Layout.SB->BlockSize);
326   InfoStreamHeader *H = reinterpret_cast<InfoStreamHeader *>(
327       Buffer.getBufferStart() + InfoStreamFileOffset);
328 
329   commitInjectedSources(Buffer, Layout);
330 
331   // Set the build id at the very end, after every other byte of the PDB
332   // has been written.
333   if (Info->hashPDBContentsToGUID()) {
334     // Compute a hash of all sections of the output file.
335     uint64_t Digest =
336         xxHash64({Buffer.getBufferStart(), Buffer.getBufferEnd()});
337 
338     H->Age = 1;
339 
340     memcpy(H->Guid.Guid, &Digest, 8);
341     // xxhash only gives us 8 bytes, so put some fixed data in the other half.
342     memcpy(H->Guid.Guid + 8, "LLD PDB.", 8);
343 
344     // Put the hash in the Signature field too.
345     H->Signature = static_cast<uint32_t>(Digest);
346 
347     // Return GUID to caller.
348     memcpy(Guid, H->Guid.Guid, 16);
349   } else {
350     H->Age = Info->getAge();
351     H->Guid = Info->getGuid();
352     Optional<uint32_t> Sig = Info->getSignature();
353     H->Signature = Sig.hasValue() ? *Sig : time(nullptr);
354   }
355 
356   return Buffer.commit();
357 }
358