LCOV - code coverage report
Current view: top level - lib/DebugInfo/PDB/Native - DbiModuleDescriptorBuilder.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 68 71 95.8 %
Date: 2018-07-13 00:08:38 Functions: 14 15 93.3 %
Legend: Lines: hit not hit

          Line data    Source code
       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         350 :   Size += alignTo(SymbolByteSize, 4); // Symbol Data
      34             :   Size += 0;                          // TODO: Layout.C11Bytes
      35         175 :   Size += C13Size;                    // C13 Debug Info Size
      36         175 :   Size += sizeof(uint32_t);           // GlobalRefs substream size (always 0)
      37             :   Size += 0;                          // GlobalRefs substream bytes
      38             :   return Size;
      39             : }
      40             : 
      41         175 : DbiModuleDescriptorBuilder::DbiModuleDescriptorBuilder(StringRef ModuleName,
      42             :                                                        uint32_t ModIndex,
      43         175 :                                                        msf::MSFBuilder &Msf)
      44         175 :     : MSF(Msf), ModuleName(ModuleName) {
      45         175 :   ::memset(&Layout, 0, sizeof(Layout));
      46             :   Layout.Mod = ModIndex;
      47         175 : }
      48             : 
      49         525 : DbiModuleDescriptorBuilder::~DbiModuleDescriptorBuilder() {}
      50             : 
      51           0 : uint16_t DbiModuleDescriptorBuilder::getStreamIndex() const {
      52           0 :   return Layout.ModDiStream;
      53             : }
      54             : 
      55         106 : void DbiModuleDescriptorBuilder::setObjFileName(StringRef Name) {
      56         212 :   ObjFileName = Name;
      57         106 : }
      58             : 
      59          69 : void DbiModuleDescriptorBuilder::setPdbFilePathNI(uint32_t NI) {
      60          69 :   PdbFilePathNI = NI;
      61          69 : }
      62             : 
      63          93 : void DbiModuleDescriptorBuilder::setFirstSectionContrib(
      64             :     const SectionContrib &SC) {
      65          93 :   Layout.SC = SC;
      66          93 : }
      67             : 
      68         807 : void DbiModuleDescriptorBuilder::addSymbol(CVSymbol Symbol) {
      69         807 :   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         807 :   SymbolByteSize += Symbol.length();
      75         807 : }
      76             : 
      77          56 : void DbiModuleDescriptorBuilder::addSourceFile(StringRef Path) {
      78         112 :   SourceFiles.push_back(Path);
      79          56 : }
      80             : 
      81         350 : uint32_t DbiModuleDescriptorBuilder::calculateC13DebugInfoSize() const {
      82             :   uint32_t Result = 0;
      83         350 :   for (const auto &Builder : C13Builders) {
      84             :     assert(Builder && "Empty C13 Fragment Builder!");
      85         232 :     Result += Builder->calculateSerializedLength();
      86             :   }
      87         350 :   return Result;
      88             : }
      89             : 
      90         350 : uint32_t DbiModuleDescriptorBuilder::calculateSerializedLength() const {
      91             :   uint32_t L = sizeof(Layout);
      92         350 :   uint32_t M = ModuleName.size() + 1;
      93         350 :   uint32_t O = ObjFileName.size() + 1;
      94         700 :   return alignTo(L + M + O, sizeof(uint32_t));
      95             : }
      96             : 
      97         175 : void DbiModuleDescriptorBuilder::finalize() {
      98         175 :   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         350 :   Layout.NumFiles = SourceFiles.size();
     106         175 :   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         175 :   Layout.SymBytes = SymbolByteSize + sizeof(uint32_t);
     112         175 : }
     113             : 
     114         175 : Error DbiModuleDescriptorBuilder::finalizeMsfLayout() {
     115             :   this->Layout.ModDiStream = kInvalidStreamIndex;
     116         175 :   uint32_t C13Size = calculateC13DebugInfoSize();
     117             :   auto ExpectedSN =
     118         350 :       MSF.addStream(calculateDiSymbolStreamSize(SymbolByteSize, C13Size));
     119         175 :   if (!ExpectedSN)
     120             :     return ExpectedSN.takeError();
     121         175 :   Layout.ModDiStream = *ExpectedSN;
     122             :   return Error::success();
     123             : }
     124             : 
     125         175 : 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         350 :   if (auto EC = ModiWriter.writeObject(Layout))
     131             :     return EC;
     132         350 :   if (auto EC = ModiWriter.writeCString(ModuleName))
     133             :     return EC;
     134         350 :   if (auto EC = ModiWriter.writeCString(ObjFileName))
     135             :     return EC;
     136         350 :   if (auto EC = ModiWriter.padToAlignment(sizeof(uint32_t)))
     137             :     return EC;
     138             : 
     139         175 :   if (Layout.ModDiStream != kInvalidStreamIndex) {
     140             :     auto NS = WritableMappedBlockStream::createIndexedStream(
     141         525 :         MsfLayout, MsfBuffer, Layout.ModDiStream, MSF.getAllocator());
     142         175 :     WritableBinaryStreamRef Ref(*NS);
     143         350 :     BinaryStreamWriter SymbolWriter(Ref);
     144             :     // Write the symbols.
     145         175 :     if (auto EC =
     146         175 :             SymbolWriter.writeInteger<uint32_t>(COFF::DEBUG_SECTION_MAGIC))
     147             :       return EC;
     148             :     BinaryItemStream<CVSymbol> Records(llvm::support::endianness::little);
     149             :     Records.setItems(Symbols);
     150         175 :     BinaryStreamRef RecordsRef(Records);
     151         525 :     if (auto EC = SymbolWriter.writeStreamRef(RecordsRef))
     152             :       return EC;
     153         350 :     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         291 :     for (const auto &Builder : C13Builders) {
     159             :       assert(Builder && "Empty C13 Fragment Builder!");
     160         232 :       if (auto EC = Builder->commit(SymbolWriter))
     161             :         return EC;
     162             :     }
     163             : 
     164             :     // TODO: Figure out what GlobalRefs substream actually is and populate it.
     165         350 :     if (auto EC = SymbolWriter.writeInteger<uint32_t>(0))
     166             :       return EC;
     167         175 :     if (SymbolWriter.bytesRemaining() > 0)
     168           0 :       return make_error<RawError>(raw_error_code::stream_too_long);
     169             :   }
     170             :   return Error::success();
     171             : }
     172             : 
     173          57 : void DbiModuleDescriptorBuilder::addDebugSubsection(
     174             :     std::shared_ptr<DebugSubsection> Subsection) {
     175             :   assert(Subsection);
     176         114 :   C13Builders.push_back(llvm::make_unique<DebugSubsectionRecordBuilder>(
     177             :       std::move(Subsection), CodeViewContainer::Pdb));
     178          57 : }
     179             : 
     180          59 : void DbiModuleDescriptorBuilder::addDebugSubsection(
     181             :     const DebugSubsectionRecord &SubsectionContents) {
     182         118 :   C13Builders.push_back(llvm::make_unique<DebugSubsectionRecordBuilder>(
     183             :       SubsectionContents, CodeViewContainer::Pdb));
     184          59 : }

Generated by: LCOV version 1.13