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