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::addSymbol(CVSymbol Symbol) {
  64   Symbols.push_back(Symbol);
  65   // Symbols written to a PDB file are required to be 4 byte aligned.  The same
  66   // is not true of object files.
  67   assert(Symbol.length() % alignOf(CodeViewContainer::Pdb) == 0 &&
  68          "Invalid Symbol alignment!");
  69   SymbolByteSize += Symbol.length();
  70 }
  71
  72 void DbiModuleDescriptorBuilder::addSourceFile(StringRef Path) {
  73   SourceFiles.push_back(Path);
  74 }
  75
  76 uint32_t DbiModuleDescriptorBuilder::calculateC13DebugInfoSize() const {
  77   uint32_t Result = 0;
  78   for (const auto &Builder : C13Builders) {
  79     assert(Builder && "Empty C13 Fragment Builder!");
  80     Result += Builder->calculateSerializedLength();
  81   }
  82   return Result;
  83 }
  84
  85 uint32_t DbiModuleDescriptorBuilder::calculateSerializedLength() const {
  86   uint32_t L = sizeof(Layout);
  87   uint32_t M = ModuleName.size() + 1;
  88   uint32_t O = ObjFileName.size() + 1;
  89   return alignTo(L + M + O, sizeof(uint32_t));
  90 }
  91
  92 void DbiModuleDescriptorBuilder::finalize() {
  93   Layout.SC.ModuleIndex = Layout.Mod;
  94   Layout.FileNameOffs = 0; // TODO: Fix this
  95   Layout.Flags = 0;        // TODO: Fix this
  96   Layout.C11Bytes = 0;
  97   Layout.C13Bytes = calculateC13DebugInfoSize();
  98   (void)Layout.Mod;         // Set in constructor
  99   (void)Layout.ModDiStream; // Set in finalizeMsfLayout
 100   Layout.NumFiles = SourceFiles.size();
 101   Layout.PdbFilePathNI = PdbFilePathNI;
 102   Layout.SrcFileNameNI = 0;
 103
 104   // This value includes both the signature field as well as the record bytes
 105   // from the symbol stream.
 106   Layout.SymBytes = SymbolByteSize + sizeof(uint32_t);
 107 }
 108
 109 Error DbiModuleDescriptorBuilder::finalizeMsfLayout() {
 110   this->Layout.ModDiStream = kInvalidStreamIndex;
 111   uint32_t C13Size = calculateC13DebugInfoSize();
 112   auto ExpectedSN =
 113       MSF.addStream(calculateDiSymbolStreamSize(SymbolByteSize, C13Size));
 114   if (!ExpectedSN)
 115     return ExpectedSN.takeError();
 116   Layout.ModDiStream = *ExpectedSN;
 117   return Error::success();
 118 }
 119
 120 Error DbiModuleDescriptorBuilder::commit(BinaryStreamWriter &ModiWriter,
 121                                          const msf::MSFLayout &MsfLayout,
 122                                          WritableBinaryStreamRef MsfBuffer) {
 123   // We write the Modi record to the `ModiWriter`, but we additionally write its
 124   // symbol stream to a brand new stream.
 125   if (auto EC = ModiWriter.writeObject(Layout))
 126     return EC;
 127   if (auto EC = ModiWriter.writeCString(ModuleName))
 128     return EC;
 129   if (auto EC = ModiWriter.writeCString(ObjFileName))
 130     return EC;
 131   if (auto EC = ModiWriter.padToAlignment(sizeof(uint32_t)))
 132     return EC;
 133
 134   if (Layout.ModDiStream != kInvalidStreamIndex) {
 135     auto NS = WritableMappedBlockStream::createIndexedStream(
 136         MsfLayout, MsfBuffer, Layout.ModDiStream, MSF.getAllocator());
 137     WritableBinaryStreamRef Ref(*NS);
 138     BinaryStreamWriter SymbolWriter(Ref);
 139     // Write the symbols.
 140     if (auto EC =
 141             SymbolWriter.writeInteger<uint32_t>(COFF::DEBUG_SECTION_MAGIC))
 142       return EC;
 143     BinaryItemStream<CVSymbol> Records(llvm::support::endianness::little);
 144     Records.setItems(Symbols);
 145     BinaryStreamRef RecordsRef(Records);
 146     if (auto EC = SymbolWriter.writeStreamRef(RecordsRef))
 147       return EC;
 148     if (auto EC = SymbolWriter.padToAlignment(4))
 149       return EC;
 150     // TODO: Write C11 Line data
 151     assert(SymbolWriter.getOffset() % alignOf(CodeViewContainer::Pdb) == 0 &&
 152            "Invalid debug section alignment!");
 153     for (const auto &Builder : C13Builders) {
 154       assert(Builder && "Empty C13 Fragment Builder!");
 155       if (auto EC = Builder->commit(SymbolWriter))
 156         return EC;
 157     }
 158
 159     // TODO: Figure out what GlobalRefs substream actually is and populate it.
 160     if (auto EC = SymbolWriter.writeInteger<uint32_t>(0))
 161       return EC;
 162     if (SymbolWriter.bytesRemaining() > 0)
 163       return make_error<RawError>(raw_error_code::stream_too_long);
 164   }
 165   return Error::success();
 166 }
 167
 168 void DbiModuleDescriptorBuilder::addDebugSubsection(
 169     std::shared_ptr<DebugSubsection> Subsection) {
 170   assert(Subsection);
 171   C13Builders.push_back(llvm::make_unique<DebugSubsectionRecordBuilder>(
 172       std::move(Subsection), CodeViewContainer::Pdb));
 173 }
 174
 175 void DbiModuleDescriptorBuilder::addDebugSubsection(
 176     const DebugSubsectionRecord &SubsectionContents) {
 177   C13Builders.push_back(llvm::make_unique<DebugSubsectionRecordBuilder>(
 178       SubsectionContents, CodeViewContainer::Pdb));
 179 }