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