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

   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   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
  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
  49 DbiModuleDescriptorBuilder::~DbiModuleDescriptorBuilder() {}
  50
  51 uint16_t DbiModuleDescriptorBuilder::getStreamIndex() const {
  52   return Layout.ModDiStream;
  53 }
  54
  55 void DbiModuleDescriptorBuilder::setObjFileName(StringRef Name) {
  56   ObjFileName = Name;
  57 }
  58
  59 void DbiModuleDescriptorBuilder::setPdbFilePathNI(uint32_t NI) {
  60   PdbFilePathNI = NI;
  61 }
  62
  63 void DbiModuleDescriptorBuilder::setFirstSectionContrib(
  64     const SectionContrib &SC) {
  65   Layout.SC = SC;
  66 }
  67
  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
  77 void DbiModuleDescriptorBuilder::addSourceFile(StringRef Path) {
  78   SourceFiles.push_back(Path);
  79 }
  80
  81 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
  90 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
  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
 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
 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
 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
 180 void DbiModuleDescriptorBuilder::addDebugSubsection(
 181     const DebugSubsectionRecord &SubsectionContents) {
 182   C13Builders.push_back(llvm::make_unique<DebugSubsectionRecordBuilder>(
 183       SubsectionContents, CodeViewContainer::Pdb));
 184 }