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