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 SymbolWriter.writeBytes(Syms); 159 assert(SymbolWriter.getOffset() % alignOf(CodeViewContainer::Pdb) == 0 && 160 "Invalid debug section alignment!"); 161 // TODO: Write C11 Line data 162 for (const auto &Builder : C13Builders) { 163 assert(Builder && "Empty C13 Fragment Builder!"); 164 if (auto EC = Builder->commit(SymbolWriter)) 165 return EC; 166 } 167 168 // TODO: Figure out what GlobalRefs substream actually is and populate it. 169 if (auto EC = SymbolWriter.writeInteger<uint32_t>(0)) 170 return EC; 171 if (SymbolWriter.bytesRemaining() > 0) 172 return make_error<RawError>(raw_error_code::stream_too_long); 173 } 174 return Error::success(); 175 } 176 177 void DbiModuleDescriptorBuilder::addDebugSubsection( 178 std::shared_ptr<DebugSubsection> Subsection) { 179 assert(Subsection); 180 C13Builders.push_back(llvm::make_unique<DebugSubsectionRecordBuilder>( 181 std::move(Subsection), CodeViewContainer::Pdb)); 182 } 183 184 void DbiModuleDescriptorBuilder::addDebugSubsection( 185 const DebugSubsectionRecord &SubsectionContents) { 186 C13Builders.push_back(llvm::make_unique<DebugSubsectionRecordBuilder>( 187 SubsectionContents, CodeViewContainer::Pdb)); 188 } 189