1 //===- DbiModuleDescriptorBuilder.cpp - PDB Mod Info 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/DbiModuleDescriptorBuilder.h"
10
11 #include "llvm/ADT/ArrayRef.h"
12 #include "llvm/BinaryFormat/COFF.h"
13 #include "llvm/DebugInfo/CodeView/DebugSubsectionRecord.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/DbiModuleDescriptor.h"
18 #include "llvm/DebugInfo/PDB/Native/GSIStreamBuilder.h"
19 #include "llvm/DebugInfo/PDB/Native/RawConstants.h"
20 #include "llvm/DebugInfo/PDB/Native/RawError.h"
21 #include "llvm/Support/BinaryStreamWriter.h"
22
23 using namespace llvm;
24 using namespace llvm::codeview;
25 using namespace llvm::msf;
26 using namespace llvm::pdb;
27
calculateDiSymbolStreamSize(uint32_t SymbolByteSize,uint32_t C13Size)28 static uint32_t calculateDiSymbolStreamSize(uint32_t SymbolByteSize,
29 uint32_t C13Size) {
30 uint32_t Size = sizeof(uint32_t); // Signature
31 Size += alignTo(SymbolByteSize, 4); // Symbol Data
32 Size += 0; // TODO: Layout.C11Bytes
33 Size += C13Size; // C13 Debug Info Size
34 Size += sizeof(uint32_t); // GlobalRefs substream size (always 0)
35 Size += 0; // GlobalRefs substream bytes
36 return Size;
37 }
38
DbiModuleDescriptorBuilder(StringRef ModuleName,uint32_t ModIndex,msf::MSFBuilder & Msf)39 DbiModuleDescriptorBuilder::DbiModuleDescriptorBuilder(StringRef ModuleName,
40 uint32_t ModIndex,
41 msf::MSFBuilder &Msf)
42 : MSF(Msf), ModuleName(ModuleName) {
43 ::memset(&Layout, 0, sizeof(Layout));
44 Layout.Mod = ModIndex;
45 }
46
~DbiModuleDescriptorBuilder()47 DbiModuleDescriptorBuilder::~DbiModuleDescriptorBuilder() {}
48
getStreamIndex() const49 uint16_t DbiModuleDescriptorBuilder::getStreamIndex() const {
50 return Layout.ModDiStream;
51 }
52
setObjFileName(StringRef Name)53 void DbiModuleDescriptorBuilder::setObjFileName(StringRef Name) {
54 ObjFileName = Name;
55 }
56
setPdbFilePathNI(uint32_t NI)57 void DbiModuleDescriptorBuilder::setPdbFilePathNI(uint32_t NI) {
58 PdbFilePathNI = NI;
59 }
60
setFirstSectionContrib(const SectionContrib & SC)61 void DbiModuleDescriptorBuilder::setFirstSectionContrib(
62 const SectionContrib &SC) {
63 Layout.SC = SC;
64 }
65
addSymbol(CVSymbol Symbol)66 void DbiModuleDescriptorBuilder::addSymbol(CVSymbol Symbol) {
67 // Defer to the bulk API. It does the same thing.
68 addSymbolsInBulk(Symbol.data());
69 }
70
addSymbolsInBulk(ArrayRef<uint8_t> BulkSymbols)71 void DbiModuleDescriptorBuilder::addSymbolsInBulk(
72 ArrayRef<uint8_t> BulkSymbols) {
73 // Do nothing for empty runs of symbols.
74 if (BulkSymbols.empty())
75 return;
76
77 Symbols.push_back(BulkSymbols);
78 // Symbols written to a PDB file are required to be 4 byte aligned. The same
79 // is not true of object files.
80 assert(BulkSymbols.size() % alignOf(CodeViewContainer::Pdb) == 0 &&
81 "Invalid Symbol alignment!");
82 SymbolByteSize += BulkSymbols.size();
83 }
84
addSourceFile(StringRef Path)85 void DbiModuleDescriptorBuilder::addSourceFile(StringRef Path) {
86 SourceFiles.push_back(Path);
87 }
88
calculateC13DebugInfoSize() const89 uint32_t DbiModuleDescriptorBuilder::calculateC13DebugInfoSize() const {
90 uint32_t Result = 0;
91 for (const auto &Builder : C13Builders) {
92 assert(Builder && "Empty C13 Fragment Builder!");
93 Result += Builder->calculateSerializedLength();
94 }
95 return Result;
96 }
97
calculateSerializedLength() const98 uint32_t DbiModuleDescriptorBuilder::calculateSerializedLength() const {
99 uint32_t L = sizeof(Layout);
100 uint32_t M = ModuleName.size() + 1;
101 uint32_t O = ObjFileName.size() + 1;
102 return alignTo(L + M + O, sizeof(uint32_t));
103 }
104
finalize()105 void DbiModuleDescriptorBuilder::finalize() {
106 Layout.FileNameOffs = 0; // TODO: Fix this
107 Layout.Flags = 0; // TODO: Fix this
108 Layout.C11Bytes = 0;
109 Layout.C13Bytes = calculateC13DebugInfoSize();
110 (void)Layout.Mod; // Set in constructor
111 (void)Layout.ModDiStream; // Set in finalizeMsfLayout
112 Layout.NumFiles = SourceFiles.size();
113 Layout.PdbFilePathNI = PdbFilePathNI;
114 Layout.SrcFileNameNI = 0;
115
116 // This value includes both the signature field as well as the record bytes
117 // from the symbol stream.
118 Layout.SymBytes =
119 Layout.ModDiStream == kInvalidStreamIndex ? 0 : getNextSymbolOffset();
120 }
121
finalizeMsfLayout()122 Error DbiModuleDescriptorBuilder::finalizeMsfLayout() {
123 this->Layout.ModDiStream = kInvalidStreamIndex;
124 uint32_t C13Size = calculateC13DebugInfoSize();
125 if (!C13Size && !SymbolByteSize)
126 return Error::success();
127 auto ExpectedSN =
128 MSF.addStream(calculateDiSymbolStreamSize(SymbolByteSize, C13Size));
129 if (!ExpectedSN)
130 return ExpectedSN.takeError();
131 Layout.ModDiStream = *ExpectedSN;
132 return Error::success();
133 }
134
commit(BinaryStreamWriter & ModiWriter,const msf::MSFLayout & MsfLayout,WritableBinaryStreamRef MsfBuffer)135 Error DbiModuleDescriptorBuilder::commit(BinaryStreamWriter &ModiWriter,
136 const msf::MSFLayout &MsfLayout,
137 WritableBinaryStreamRef MsfBuffer) {
138 // We write the Modi record to the `ModiWriter`, but we additionally write its
139 // symbol stream to a brand new stream.
140 if (auto EC = ModiWriter.writeObject(Layout))
141 return EC;
142 if (auto EC = ModiWriter.writeCString(ModuleName))
143 return EC;
144 if (auto EC = ModiWriter.writeCString(ObjFileName))
145 return EC;
146 if (auto EC = ModiWriter.padToAlignment(sizeof(uint32_t)))
147 return EC;
148
149 if (Layout.ModDiStream != kInvalidStreamIndex) {
150 auto NS = WritableMappedBlockStream::createIndexedStream(
151 MsfLayout, MsfBuffer, Layout.ModDiStream, MSF.getAllocator());
152 WritableBinaryStreamRef Ref(*NS);
153 BinaryStreamWriter SymbolWriter(Ref);
154 // Write the symbols.
155 if (auto EC =
156 SymbolWriter.writeInteger<uint32_t>(COFF::DEBUG_SECTION_MAGIC))
157 return EC;
158 for (ArrayRef<uint8_t> Syms : Symbols) {
159 if (auto EC = SymbolWriter.writeBytes(Syms))
160 return EC;
161 }
162 assert(SymbolWriter.getOffset() % alignOf(CodeViewContainer::Pdb) == 0 &&
163 "Invalid debug section alignment!");
164 // TODO: Write C11 Line data
165 for (const auto &Builder : C13Builders) {
166 assert(Builder && "Empty C13 Fragment Builder!");
167 if (auto EC = Builder->commit(SymbolWriter))
168 return EC;
169 }
170
171 // TODO: Figure out what GlobalRefs substream actually is and populate it.
172 if (auto EC = SymbolWriter.writeInteger<uint32_t>(0))
173 return EC;
174 if (SymbolWriter.bytesRemaining() > 0)
175 return make_error<RawError>(raw_error_code::stream_too_long);
176 }
177 return Error::success();
178 }
179
addDebugSubsection(std::shared_ptr<DebugSubsection> Subsection)180 void DbiModuleDescriptorBuilder::addDebugSubsection(
181 std::shared_ptr<DebugSubsection> Subsection) {
182 assert(Subsection);
183 C13Builders.push_back(std::make_unique<DebugSubsectionRecordBuilder>(
184 std::move(Subsection), CodeViewContainer::Pdb));
185 }
186
addDebugSubsection(const DebugSubsectionRecord & SubsectionContents)187 void DbiModuleDescriptorBuilder::addDebugSubsection(
188 const DebugSubsectionRecord &SubsectionContents) {
189 C13Builders.push_back(std::make_unique<DebugSubsectionRecordBuilder>(
190 SubsectionContents, CodeViewContainer::Pdb));
191 }
192