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/RawConstants.h"
  20 #include "llvm/DebugInfo/PDB/Native/RawError.h"
  21 #include "llvm/Support/BinaryItemStream.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 namespace llvm {
  30 template <> struct BinaryItemTraits<CVSymbol> {
  31   static size_t length(const CVSymbol &Item) { return Item.RecordData.size(); }
  32
  33   static ArrayRef<uint8_t> bytes(const CVSymbol &Item) {
  34     return Item.RecordData;
  35   }
  36 };
  37 }
  38
  39 static uint32_t calculateDiSymbolStreamSize(uint32_t SymbolByteSize,
  40                                             uint32_t C13Size) {
  41   uint32_t Size = sizeof(uint32_t);   // Signature
  42   Size += alignTo(SymbolByteSize, 4); // Symbol Data
  43   Size += 0;                          // TODO: Layout.C11Bytes
  44   Size += C13Size;                    // C13 Debug Info Size
  45   Size += sizeof(uint32_t);           // GlobalRefs substream size (always 0)
  46   Size += 0;                          // GlobalRefs substream bytes
  47   return Size;
  48 }
  49
  50 DbiModuleDescriptorBuilder::DbiModuleDescriptorBuilder(StringRef ModuleName,
  51                                                        uint32_t ModIndex,
  52                                                        msf::MSFBuilder &Msf)
  53     : MSF(Msf), ModuleName(ModuleName) {
  54   ::memset(&Layout, 0, sizeof(Layout));
  55   Layout.Mod = ModIndex;
  56 }
  57
  58 DbiModuleDescriptorBuilder::~DbiModuleDescriptorBuilder() {}
  59
  60 uint16_t DbiModuleDescriptorBuilder::getStreamIndex() const {
  61   return Layout.ModDiStream;
  62 }
  63
  64 void DbiModuleDescriptorBuilder::setObjFileName(StringRef Name) {
  65   ObjFileName = Name;
  66 }
  67
  68 void DbiModuleDescriptorBuilder::setPdbFilePathNI(uint32_t NI) {
  69   PdbFilePathNI = NI;
  70 }
  71
  72 void DbiModuleDescriptorBuilder::addSymbol(CVSymbol Symbol) {
  73   Symbols.push_back(Symbol);
  74   // Symbols written to a PDB file are required to be 4 byte aligned.  The same
  75   // is not true of object files.
  76   assert(Symbol.length() % alignOf(CodeViewContainer::Pdb) == 0 &&
  77          "Invalid Symbol alignment!");
  78   SymbolByteSize += Symbol.length();
  79 }
  80
  81 void DbiModuleDescriptorBuilder::addSourceFile(StringRef Path) {
  82   SourceFiles.push_back(Path);
  83 }
  84
  85 uint32_t DbiModuleDescriptorBuilder::calculateC13DebugInfoSize() const {
  86   uint32_t Result = 0;
  87   for (const auto &Builder : C13Builders) {
  88     assert(Builder && "Empty C13 Fragment Builder!");
  89     Result += Builder->calculateSerializedLength();
  90   }
  91   return Result;
  92 }
  93
  94 uint32_t DbiModuleDescriptorBuilder::calculateSerializedLength() const {
  95   uint32_t L = sizeof(Layout);
  96   uint32_t M = ModuleName.size() + 1;
  97   uint32_t O = ObjFileName.size() + 1;
  98   return alignTo(L + M + O, sizeof(uint32_t));
  99 }
 100
 101 template <typename T> struct Foo {
 102   explicit Foo(T &&Answer) : Answer(Answer) {}
 103
 104   T Answer;
 105 };
 106
 107 template <typename T> Foo<T> makeFoo(T &&t) { return Foo<T>(std::move(t)); }
 108
 109 void DbiModuleDescriptorBuilder::finalize() {
 110   Layout.SC.ModuleIndex = Layout.Mod;
 111   Layout.FileNameOffs = 0; // TODO: Fix this
 112   Layout.Flags = 0;        // TODO: Fix this
 113   Layout.C11Bytes = 0;
 114   Layout.C13Bytes = calculateC13DebugInfoSize();
 115   (void)Layout.Mod;         // Set in constructor
 116   (void)Layout.ModDiStream; // Set in finalizeMsfLayout
 117   Layout.NumFiles = SourceFiles.size();
 118   Layout.PdbFilePathNI = PdbFilePathNI;
 119   Layout.SrcFileNameNI = 0;
 120
 121   // This value includes both the signature field as well as the record bytes
 122   // from the symbol stream.
 123   Layout.SymBytes = SymbolByteSize + sizeof(uint32_t);
 124 }
 125
 126 Error DbiModuleDescriptorBuilder::finalizeMsfLayout() {
 127   this->Layout.ModDiStream = kInvalidStreamIndex;
 128   uint32_t C13Size = calculateC13DebugInfoSize();
 129   auto ExpectedSN =
 130       MSF.addStream(calculateDiSymbolStreamSize(SymbolByteSize, C13Size));
 131   if (!ExpectedSN)
 132     return ExpectedSN.takeError();
 133   Layout.ModDiStream = *ExpectedSN;
 134   return Error::success();
 135 }
 136
 137 Error DbiModuleDescriptorBuilder::commit(BinaryStreamWriter &ModiWriter,
 138                                          const msf::MSFLayout &MsfLayout,
 139                                          WritableBinaryStreamRef MsfBuffer) {
 140   // We write the Modi record to the `ModiWriter`, but we additionally write its
 141   // symbol stream to a brand new stream.
 142   if (auto EC = ModiWriter.writeObject(Layout))
 143     return EC;
 144   if (auto EC = ModiWriter.writeCString(ModuleName))
 145     return EC;
 146   if (auto EC = ModiWriter.writeCString(ObjFileName))
 147     return EC;
 148   if (auto EC = ModiWriter.padToAlignment(sizeof(uint32_t)))
 149     return EC;
 150
 151   if (Layout.ModDiStream != kInvalidStreamIndex) {
 152     auto NS = WritableMappedBlockStream::createIndexedStream(
 153         MsfLayout, MsfBuffer, Layout.ModDiStream, MSF.getAllocator());
 154     WritableBinaryStreamRef Ref(*NS);
 155     BinaryStreamWriter SymbolWriter(Ref);
 156     // Write the symbols.
 157     if (auto EC =
 158             SymbolWriter.writeInteger<uint32_t>(COFF::DEBUG_SECTION_MAGIC))
 159       return EC;
 160     BinaryItemStream<CVSymbol> Records(llvm::support::endianness::little);
 161     Records.setItems(Symbols);
 162     BinaryStreamRef RecordsRef(Records);
 163     if (auto EC = SymbolWriter.writeStreamRef(RecordsRef))
 164       return EC;
 165     if (auto EC = SymbolWriter.padToAlignment(4))
 166       return EC;
 167     // TODO: Write C11 Line data
 168     assert(SymbolWriter.getOffset() % alignOf(CodeViewContainer::Pdb) == 0 &&
 169            "Invalid debug section alignment!");
 170     for (const auto &Builder : C13Builders) {
 171       assert(Builder && "Empty C13 Fragment Builder!");
 172       if (auto EC = Builder->commit(SymbolWriter))
 173         return EC;
 174     }
 175
 176     // TODO: Figure out what GlobalRefs substream actually is and populate it.
 177     if (auto EC = SymbolWriter.writeInteger<uint32_t>(0))
 178       return EC;
 179     if (SymbolWriter.bytesRemaining() > 0)
 180       return make_error<RawError>(raw_error_code::stream_too_long);
 181   }
 182   return Error::success();
 183 }
 184
 185 void DbiModuleDescriptorBuilder::addDebugSubsection(
 186     std::shared_ptr<DebugSubsection> Subsection) {
 187   assert(Subsection);
 188   C13Builders.push_back(llvm::make_unique<DebugSubsectionRecordBuilder>(
 189       std::move(Subsection), CodeViewContainer::Pdb));
 190 }
 191
 192 void DbiModuleDescriptorBuilder::addDebugSubsection(
 193     const DebugSubsectionRecord &SubsectionContents) {
 194   C13Builders.push_back(llvm::make_unique<DebugSubsectionRecordBuilder>(
 195       SubsectionContents, CodeViewContainer::Pdb));
 196 }