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