Line data Source code
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 :
30 : static uint32_t calculateDiSymbolStreamSize(uint32_t SymbolByteSize,
31 : uint32_t C13Size) {
32 : uint32_t Size = sizeof(uint32_t); // Signature
33 438 : Size += alignTo(SymbolByteSize, 4); // Symbol Data
34 : Size += 0; // TODO: Layout.C11Bytes
35 219 : Size += C13Size; // C13 Debug Info Size
36 219 : Size += sizeof(uint32_t); // GlobalRefs substream size (always 0)
37 : Size += 0; // GlobalRefs substream bytes
38 : return Size;
39 : }
40 :
41 219 : DbiModuleDescriptorBuilder::DbiModuleDescriptorBuilder(StringRef ModuleName,
42 : uint32_t ModIndex,
43 219 : msf::MSFBuilder &Msf)
44 219 : : MSF(Msf), ModuleName(ModuleName) {
45 219 : ::memset(&Layout, 0, sizeof(Layout));
46 : Layout.Mod = ModIndex;
47 219 : }
48 :
49 438 : DbiModuleDescriptorBuilder::~DbiModuleDescriptorBuilder() {}
50 :
51 0 : uint16_t DbiModuleDescriptorBuilder::getStreamIndex() const {
52 0 : return Layout.ModDiStream;
53 : }
54 :
55 131 : void DbiModuleDescriptorBuilder::setObjFileName(StringRef Name) {
56 131 : ObjFileName = Name;
57 131 : }
58 :
59 88 : void DbiModuleDescriptorBuilder::setPdbFilePathNI(uint32_t NI) {
60 88 : PdbFilePathNI = NI;
61 88 : }
62 :
63 117 : void DbiModuleDescriptorBuilder::setFirstSectionContrib(
64 : const SectionContrib &SC) {
65 117 : Layout.SC = SC;
66 117 : }
67 :
68 963 : void DbiModuleDescriptorBuilder::addSymbol(CVSymbol Symbol) {
69 963 : 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 963 : SymbolByteSize += Symbol.length();
75 963 : }
76 :
77 68 : void DbiModuleDescriptorBuilder::addSourceFile(StringRef Path) {
78 68 : SourceFiles.push_back(Path);
79 68 : }
80 :
81 438 : uint32_t DbiModuleDescriptorBuilder::calculateC13DebugInfoSize() const {
82 : uint32_t Result = 0;
83 716 : for (const auto &Builder : C13Builders) {
84 : assert(Builder && "Empty C13 Fragment Builder!");
85 278 : Result += Builder->calculateSerializedLength();
86 : }
87 438 : return Result;
88 : }
89 :
90 438 : uint32_t DbiModuleDescriptorBuilder::calculateSerializedLength() const {
91 : uint32_t L = sizeof(Layout);
92 438 : uint32_t M = ModuleName.size() + 1;
93 438 : uint32_t O = ObjFileName.size() + 1;
94 876 : return alignTo(L + M + O, sizeof(uint32_t));
95 : }
96 :
97 219 : void DbiModuleDescriptorBuilder::finalize() {
98 219 : 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 438 : Layout.NumFiles = SourceFiles.size();
106 219 : 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 219 : Layout.SymBytes = SymbolByteSize + sizeof(uint32_t);
112 219 : }
113 :
114 219 : Error DbiModuleDescriptorBuilder::finalizeMsfLayout() {
115 : this->Layout.ModDiStream = kInvalidStreamIndex;
116 219 : uint32_t C13Size = calculateC13DebugInfoSize();
117 : auto ExpectedSN =
118 438 : MSF.addStream(calculateDiSymbolStreamSize(SymbolByteSize, C13Size));
119 219 : if (!ExpectedSN)
120 : return ExpectedSN.takeError();
121 219 : Layout.ModDiStream = *ExpectedSN;
122 : return Error::success();
123 : }
124 :
125 219 : 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 438 : if (auto EC = ModiWriter.writeObject(Layout))
131 : return EC;
132 219 : if (auto EC = ModiWriter.writeCString(ModuleName))
133 : return EC;
134 219 : if (auto EC = ModiWriter.writeCString(ObjFileName))
135 : return EC;
136 438 : if (auto EC = ModiWriter.padToAlignment(sizeof(uint32_t)))
137 : return EC;
138 :
139 219 : if (Layout.ModDiStream != kInvalidStreamIndex) {
140 : auto NS = WritableMappedBlockStream::createIndexedStream(
141 657 : MsfLayout, MsfBuffer, Layout.ModDiStream, MSF.getAllocator());
142 219 : WritableBinaryStreamRef Ref(*NS);
143 219 : BinaryStreamWriter SymbolWriter(Ref);
144 : // Write the symbols.
145 219 : if (auto EC =
146 219 : SymbolWriter.writeInteger<uint32_t>(COFF::DEBUG_SECTION_MAGIC))
147 : return EC;
148 : BinaryItemStream<CVSymbol> Records(llvm::support::endianness::little);
149 : Records.setItems(Symbols);
150 219 : BinaryStreamRef RecordsRef(Records);
151 438 : if (auto EC = SymbolWriter.writeStreamRef(RecordsRef))
152 : return EC;
153 438 : 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 358 : for (const auto &Builder : C13Builders) {
159 : assert(Builder && "Empty C13 Fragment Builder!");
160 278 : if (auto EC = Builder->commit(SymbolWriter))
161 : return EC;
162 : }
163 :
164 : // TODO: Figure out what GlobalRefs substream actually is and populate it.
165 438 : if (auto EC = SymbolWriter.writeInteger<uint32_t>(0))
166 : return EC;
167 219 : if (SymbolWriter.bytesRemaining() > 0)
168 : return make_error<RawError>(raw_error_code::stream_too_long);
169 : }
170 : return Error::success();
171 : }
172 :
173 67 : void DbiModuleDescriptorBuilder::addDebugSubsection(
174 : std::shared_ptr<DebugSubsection> Subsection) {
175 : assert(Subsection);
176 134 : C13Builders.push_back(llvm::make_unique<DebugSubsectionRecordBuilder>(
177 : std::move(Subsection), CodeViewContainer::Pdb));
178 67 : }
179 :
180 72 : void DbiModuleDescriptorBuilder::addDebugSubsection(
181 : const DebugSubsectionRecord &SubsectionContents) {
182 144 : C13Builders.push_back(llvm::make_unique<DebugSubsectionRecordBuilder>(
183 : SubsectionContents, CodeViewContainer::Pdb));
184 72 : }
|
