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