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