contrib/llvm/lib/DebugInfo/PDB/Native/DbiModuleDescriptorBuilder.cpp

   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
  23 using namespace llvm;
  24 using namespace llvm::codeview;
  25 using namespace llvm::msf;
  26 using namespace llvm::pdb;
  27
  28 static 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
  39 DbiModuleDescriptorBuilder::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
  47 DbiModuleDescriptorBuilder::~DbiModuleDescriptorBuilder() {}
  48
  49 uint16_t DbiModuleDescriptorBuilder::getStreamIndex() const {
  50   return Layout.ModDiStream;
  51 }
  52
  53 void DbiModuleDescriptorBuilder::setObjFileName(StringRef Name) {
  54   ObjFileName = Name;
  55 }
  56
  57 void DbiModuleDescriptorBuilder::setPdbFilePathNI(uint32_t NI) {
  58   PdbFilePathNI = NI;
  59 }
  60
  61 void DbiModuleDescriptorBuilder::setFirstSectionContrib(
  62     const SectionContrib &SC) {
  63   Layout.SC = SC;
  64 }
  65
  66 void DbiModuleDescriptorBuilder::addSymbol(CVSymbol Symbol) {
  67   // Defer to the bulk API. It does the same thing.
  68   addSymbolsInBulk(Symbol.data());
  69 }
  70
  71 void 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
  85 void DbiModuleDescriptorBuilder::addSourceFile(StringRef Path) {
  86   SourceFiles.push_back(Path);
  87 }
  88
  89 uint32_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
  98 uint32_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
 105 void 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
 122 Error 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
 135 Error 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
 180 void DbiModuleDescriptorBuilder::addDebugSubsection(
 181     std::shared_ptr<DebugSubsection> Subsection) {
 182   assert(Subsection);
 183   C13Builders.push_back(llvm::make_unique<DebugSubsectionRecordBuilder>(
 184       std::move(Subsection), CodeViewContainer::Pdb));
 185 }
 186
 187 void DbiModuleDescriptorBuilder::addDebugSubsection(
 188     const DebugSubsectionRecord &SubsectionContents) {
 189   C13Builders.push_back(llvm::make_unique<DebugSubsectionRecordBuilder>(
 190       SubsectionContents, CodeViewContainer::Pdb));
 191 }