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