LLVM  8.0.0svn
DbiModuleDescriptorBuilder.cpp
Go to the documentation of this file.
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 
11 
12 #include "llvm/ADT/ArrayRef.h"
13 #include "llvm/BinaryFormat/COFF.h"
24 
25 using namespace llvm;
26 using namespace llvm::codeview;
27 using namespace llvm::msf;
28 using namespace llvm::pdb;
29 
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 
50 
52  return Layout.ModDiStream;
53 }
54 
56  ObjFileName = Name;
57 }
58 
60  PdbFilePathNI = NI;
61 }
62 
64  const SectionContrib &SC) {
65  Layout.SC = SC;
66 }
67 
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 
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 
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 
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 
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());
143  BinaryStreamWriter SymbolWriter(Ref);
144  // Write the symbols.
145  if (auto EC =
147  return EC;
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 
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 
181  const DebugSubsectionRecord &SubsectionContents) {
182  C13Builders.push_back(llvm::make_unique<DebugSubsectionRecordBuilder>(
183  SubsectionContents, CodeViewContainer::Pdb));
184 }
Error writeObject(const T &Obj)
Writes the object Obj to the underlying stream, as if by using memcpy.
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
support::ulittle16_t NumFiles
Number of files contributing to this module.
Definition: RawTypes.h:239
support::ulittle32_t SrcFileNameNI
Name Index for src file name.
Definition: RawTypes.h:253
Error commit(BinaryStreamWriter &ModiWriter, const msf::MSFLayout &MsfLayout, WritableBinaryStreamRef MsfBuffer)
support::ulittle32_t SymBytes
Size of local symbol debug info in above stream.
Definition: RawTypes.h:230
uint64_t alignTo(uint64_t Value, uint64_t Align, uint64_t Skew=0)
Returns the next integer (mod 2**64) that is greater than or equal to Value and is a multiple of Alig...
Definition: MathExtras.h:685
uint32_t alignOf(CodeViewContainer Container)
Definition: CodeView.h:574
The access may reference the value stored in memory.
support::ulittle32_t PdbFilePathNI
Name Index for path to compiler PDB.
Definition: RawTypes.h:256
support::ulittle16_t Flags
See ModInfoFlags definition.
Definition: RawTypes.h:224
SectionContrib SC
First section contribution of this module.
Definition: RawTypes.h:221
uint32_t length() const
Definition: CVRecord.h:36
void setFirstSectionContrib(const SectionContrib &SC)
support::ulittle32_t C13Bytes
Size of C13 line number info in above stream.
Definition: RawTypes.h:236
const uint16_t kInvalidStreamIndex
Definition: RawConstants.h:20
support::ulittle16_t Imod
Definition: RawTypes.h:53
Error writeStreamRef(BinaryStreamRef Ref)
Efficiently reads all data from Ref, and writes it to this stream.
support::ulittle32_t FileNameOffs
Array of [0..NumFiles) DBI name buffer offsets.
Definition: RawTypes.h:250
Provides write only access to a subclass of WritableBinaryStream.
Error writeInteger(T Value)
Write the integer Value to the underlying stream in the specified endianness.
uint32_t bytesRemaining() const
Error writeCString(StringRef Str)
Write the string Str to the underlying stream followed by a null terminator.
static ErrorSuccess success()
Create a success value.
Definition: Error.h:327
support::ulittle32_t Mod
Currently opened module.
Definition: RawTypes.h:218
BinaryStreamRef is to BinaryStream what ArrayRef is to an Array.
CHAIN = SC CHAIN, Imm128 - System call.
Expected< uint32_t > addStream(uint32_t Size, ArrayRef< uint32_t > Blocks)
Add a stream to the MSF file with the given size, occupying the given list of blocks.
Definition: MSFBuilder.cpp:155
support::ulittle16_t ModDiStream
Stream Number of module debug info.
Definition: RawTypes.h:227
static uint32_t calculateDiSymbolStreamSize(uint32_t SymbolByteSize, uint32_t C13Size)
support::ulittle32_t C11Bytes
Size of C11 line number info in above stream.
Definition: RawTypes.h:233
Error padToAlignment(uint32_t Align)
uint32_t Size
Definition: Profile.cpp:47
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
BinaryItemStream represents a sequence of objects stored in some kind of external container but for w...
Lightweight error class with error context and mandatory checking.
Definition: Error.h:158
void setItems(ArrayRef< T > ItemArray)
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
BumpPtrAllocator & getAllocator()
Definition: MSFBuilder.h:119
void addDebugSubsection(std::shared_ptr< codeview::DebugSubsection > Subsection)