PDB.cpp revision 327952 
1//===- PDB.cpp ------------------------------------------------------------===//
2//
3//                             The LLVM Linker
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 "PDB.h"
11#include "Chunks.h"
12#include "Config.h"
13#include "Driver.h"
14#include "SymbolTable.h"
15#include "Symbols.h"
16#include "Writer.h"
17#include "lld/Common/ErrorHandler.h"
18#include "llvm/DebugInfo/CodeView/CVDebugRecord.h"
19#include "llvm/DebugInfo/CodeView/DebugSubsectionRecord.h"
20#include "llvm/DebugInfo/CodeView/GlobalTypeTableBuilder.h"
21#include "llvm/DebugInfo/CodeView/LazyRandomTypeCollection.h"
22#include "llvm/DebugInfo/CodeView/MergingTypeTableBuilder.h"
23#include "llvm/DebugInfo/CodeView/RecordName.h"
24#include "llvm/DebugInfo/CodeView/SymbolDeserializer.h"
25#include "llvm/DebugInfo/CodeView/SymbolSerializer.h"
26#include "llvm/DebugInfo/CodeView/TypeDeserializer.h"
27#include "llvm/DebugInfo/CodeView/TypeDumpVisitor.h"
28#include "llvm/DebugInfo/CodeView/TypeIndexDiscovery.h"
29#include "llvm/DebugInfo/CodeView/TypeStreamMerger.h"
30#include "llvm/DebugInfo/MSF/MSFBuilder.h"
31#include "llvm/DebugInfo/MSF/MSFCommon.h"
32#include "llvm/DebugInfo/PDB/GenericError.h"
33#include "llvm/DebugInfo/PDB/Native/DbiModuleDescriptorBuilder.h"
34#include "llvm/DebugInfo/PDB/Native/DbiStream.h"
35#include "llvm/DebugInfo/PDB/Native/DbiStreamBuilder.h"
36#include "llvm/DebugInfo/PDB/Native/GSIStreamBuilder.h"
37#include "llvm/DebugInfo/PDB/Native/InfoStream.h"
38#include "llvm/DebugInfo/PDB/Native/InfoStreamBuilder.h"
39#include "llvm/DebugInfo/PDB/Native/NativeSession.h"
40#include "llvm/DebugInfo/PDB/Native/PDBFile.h"
41#include "llvm/DebugInfo/PDB/Native/PDBFileBuilder.h"
42#include "llvm/DebugInfo/PDB/Native/PDBStringTableBuilder.h"
43#include "llvm/DebugInfo/PDB/Native/TpiHashing.h"
44#include "llvm/DebugInfo/PDB/Native/TpiStream.h"
45#include "llvm/DebugInfo/PDB/Native/TpiStreamBuilder.h"
46#include "llvm/DebugInfo/PDB/PDB.h"
47#include "llvm/Object/COFF.h"
48#include "llvm/Support/BinaryByteStream.h"
49#include "llvm/Support/Endian.h"
50#include "llvm/Support/JamCRC.h"
51#include "llvm/Support/Path.h"
52#include "llvm/Support/ScopedPrinter.h"
53#include <memory>
54
55using namespace lld;
56using namespace lld::coff;
57using namespace llvm;
58using namespace llvm::codeview;
59
60using llvm::object::coff_section;
61
62static ExitOnError ExitOnErr;
63
64namespace {
65/// Map from type index and item index in a type server PDB to the
66/// corresponding index in the destination PDB.
67struct CVIndexMap {
68  SmallVector<TypeIndex, 0> TPIMap;
69  SmallVector<TypeIndex, 0> IPIMap;
70  bool IsTypeServerMap = false;
71};
72
73class PDBLinker {
74public:
75  PDBLinker(SymbolTable *Symtab)
76      : Alloc(), Symtab(Symtab), Builder(Alloc), TypeTable(Alloc),
77        IDTable(Alloc), GlobalTypeTable(Alloc), GlobalIDTable(Alloc) {}
78
79  /// Emit the basic PDB structure: initial streams, headers, etc.
80  void initialize(const llvm::codeview::DebugInfo &BuildId);
81
82  /// Link CodeView from each object file in the symbol table into the PDB.
83  void addObjectsToPDB();
84
85  /// Link CodeView from a single object file into the PDB.
86  void addObjFile(ObjFile *File);
87
88  /// Produce a mapping from the type and item indices used in the object
89  /// file to those in the destination PDB.
90  ///
91  /// If the object file uses a type server PDB (compiled with /Zi), merge TPI
92  /// and IPI from the type server PDB and return a map for it. Each unique type
93  /// server PDB is merged at most once, so this may return an existing index
94  /// mapping.
95  ///
96  /// If the object does not use a type server PDB (compiled with /Z7), we merge
97  /// all the type and item records from the .debug$S stream and fill in the
98  /// caller-provided ObjectIndexMap.
99  const CVIndexMap &mergeDebugT(ObjFile *File, CVIndexMap &ObjectIndexMap);
100
101  const CVIndexMap &maybeMergeTypeServerPDB(ObjFile *File,
102                                            TypeServer2Record &TS);
103
104  /// Add the section map and section contributions to the PDB.
105  void addSections(ArrayRef<OutputSection *> OutputSections,
106                   ArrayRef<uint8_t> SectionTable);
107
108  void addSectionContrib(pdb::DbiModuleDescriptorBuilder &LinkerModule,
109                         OutputSection *OS, Chunk *C);
110
111  /// Write the PDB to disk.
112  void commit();
113
114private:
115  BumpPtrAllocator Alloc;
116
117  SymbolTable *Symtab;
118
119  pdb::PDBFileBuilder Builder;
120
121  /// Type records that will go into the PDB TPI stream.
122  MergingTypeTableBuilder TypeTable;
123
124  /// Item records that will go into the PDB IPI stream.
125  MergingTypeTableBuilder IDTable;
126
127  /// Type records that will go into the PDB TPI stream (for /DEBUG:GHASH)
128  GlobalTypeTableBuilder GlobalTypeTable;
129
130  /// Item records that will go into the PDB IPI stream (for /DEBUG:GHASH)
131  GlobalTypeTableBuilder GlobalIDTable;
132
133  /// PDBs use a single global string table for filenames in the file checksum
134  /// table.
135  DebugStringTableSubsection PDBStrTab;
136
137  llvm::SmallString<128> NativePath;
138
139  std::vector<pdb::SecMapEntry> SectionMap;
140
141  /// Type index mappings of type server PDBs that we've loaded so far.
142  std::map<GUID, CVIndexMap> TypeServerIndexMappings;
143};
144}
145
146static SectionChunk *findByName(ArrayRef<SectionChunk *> Sections,
147                                StringRef Name) {
148  for (SectionChunk *C : Sections)
149    if (C->getSectionName() == Name)
150      return C;
151  return nullptr;
152}
153
154static ArrayRef<uint8_t> consumeDebugMagic(ArrayRef<uint8_t> Data,
155                                           StringRef SecName) {
156  // First 4 bytes are section magic.
157  if (Data.size() < 4)
158    fatal(SecName + " too short");
159  if (support::endian::read32le(Data.data()) != COFF::DEBUG_SECTION_MAGIC)
160    fatal(SecName + " has an invalid magic");
161  return Data.slice(4);
162}
163
164static ArrayRef<uint8_t> getDebugSection(ObjFile *File, StringRef SecName) {
165  if (SectionChunk *Sec = findByName(File->getDebugChunks(), SecName))
166    return consumeDebugMagic(Sec->getContents(), SecName);
167  return {};
168}
169
170// A COFF .debug$H section is currently a clang extension.  This function checks
171// if a .debug$H section is in a format that we expect / understand, so that we
172// can ignore any sections which are coincidentally also named .debug$H but do
173// not contain a format we recognize.
174static bool canUseDebugH(ArrayRef<uint8_t> DebugH) {
175  if (DebugH.size() < sizeof(object::debug_h_header))
176    return false;
177  auto *Header =
178      reinterpret_cast<const object::debug_h_header *>(DebugH.data());
179  DebugH = DebugH.drop_front(sizeof(object::debug_h_header));
180  return Header->Magic == COFF::DEBUG_HASHES_SECTION_MAGIC &&
181         Header->Version == 0 &&
182         Header->HashAlgorithm == uint16_t(GlobalTypeHashAlg::SHA1) &&
183         (DebugH.size() % 20 == 0);
184}
185
186static Optional<ArrayRef<uint8_t>> getDebugH(ObjFile *File) {
187  SectionChunk *Sec = findByName(File->getDebugChunks(), ".debug$H");
188  if (!Sec)
189    return llvm::None;
190  ArrayRef<uint8_t> Contents = Sec->getContents();
191  if (!canUseDebugH(Contents))
192    return None;
193  return Contents;
194}
195
196static ArrayRef<GloballyHashedType>
197getHashesFromDebugH(ArrayRef<uint8_t> DebugH) {
198  assert(canUseDebugH(DebugH));
199
200  DebugH = DebugH.drop_front(sizeof(object::debug_h_header));
201  uint32_t Count = DebugH.size() / sizeof(GloballyHashedType);
202  return {reinterpret_cast<const GloballyHashedType *>(DebugH.data()), Count};
203}
204
205static void addTypeInfo(pdb::TpiStreamBuilder &TpiBuilder,
206                        TypeCollection &TypeTable) {
207  // Start the TPI or IPI stream header.
208  TpiBuilder.setVersionHeader(pdb::PdbTpiV80);
209
210  // Flatten the in memory type table and hash each type.
211  TypeTable.ForEachRecord([&](TypeIndex TI, const CVType &Type) {
212    auto Hash = pdb::hashTypeRecord(Type);
213    if (auto E = Hash.takeError())
214      fatal("type hashing error");
215    TpiBuilder.addTypeRecord(Type.RecordData, *Hash);
216  });
217}
218
219static Optional<TypeServer2Record>
220maybeReadTypeServerRecord(CVTypeArray &Types) {
221  auto I = Types.begin();
222  if (I == Types.end())
223    return None;
224  const CVType &Type = *I;
225  if (Type.kind() != LF_TYPESERVER2)
226    return None;
227  TypeServer2Record TS;
228  if (auto EC = TypeDeserializer::deserializeAs(const_cast<CVType &>(Type), TS))
229    fatal("error reading type server record: " + toString(std::move(EC)));
230  return std::move(TS);
231}
232
233const CVIndexMap &PDBLinker::mergeDebugT(ObjFile *File,
234                                         CVIndexMap &ObjectIndexMap) {
235  ArrayRef<uint8_t> Data = getDebugSection(File, ".debug$T");
236  if (Data.empty())
237    return ObjectIndexMap;
238
239  BinaryByteStream Stream(Data, support::little);
240  CVTypeArray Types;
241  BinaryStreamReader Reader(Stream);
242  if (auto EC = Reader.readArray(Types, Reader.getLength()))
243    fatal("Reader::readArray failed: " + toString(std::move(EC)));
244
245  // Look through type servers. If we've already seen this type server, don't
246  // merge any type information.
247  if (Optional<TypeServer2Record> TS = maybeReadTypeServerRecord(Types))
248    return maybeMergeTypeServerPDB(File, *TS);
249
250  // This is a /Z7 object. Fill in the temporary, caller-provided
251  // ObjectIndexMap.
252  if (Config->DebugGHashes) {
253    ArrayRef<GloballyHashedType> Hashes;
254    std::vector<GloballyHashedType> OwnedHashes;
255    if (Optional<ArrayRef<uint8_t>> DebugH = getDebugH(File))
256      Hashes = getHashesFromDebugH(*DebugH);
257    else {
258      OwnedHashes = GloballyHashedType::hashTypes(Types);
259      Hashes = OwnedHashes;
260    }
261
262    if (auto Err = mergeTypeAndIdRecords(GlobalIDTable, GlobalTypeTable,
263                                         ObjectIndexMap.TPIMap, Types, Hashes))
264      fatal("codeview::mergeTypeAndIdRecords failed: " +
265            toString(std::move(Err)));
266  } else {
267    if (auto Err = mergeTypeAndIdRecords(IDTable, TypeTable,
268                                         ObjectIndexMap.TPIMap, Types))
269      fatal("codeview::mergeTypeAndIdRecords failed: " +
270            toString(std::move(Err)));
271  }
272  return ObjectIndexMap;
273}
274
275static Expected<std::unique_ptr<pdb::NativeSession>>
276tryToLoadPDB(const GUID &GuidFromObj, StringRef TSPath) {
277  ErrorOr<std::unique_ptr<MemoryBuffer>> MBOrErr = MemoryBuffer::getFile(
278      TSPath, /*FileSize=*/-1, /*RequiresNullTerminator=*/false);
279  if (!MBOrErr)
280    return errorCodeToError(MBOrErr.getError());
281
282  std::unique_ptr<pdb::IPDBSession> ThisSession;
283  if (auto EC = pdb::NativeSession::createFromPdb(
284          MemoryBuffer::getMemBuffer(Driver->takeBuffer(std::move(*MBOrErr)),
285                                     /*RequiresNullTerminator=*/false),
286          ThisSession))
287    return std::move(EC);
288
289  std::unique_ptr<pdb::NativeSession> NS(
290      static_cast<pdb::NativeSession *>(ThisSession.release()));
291  pdb::PDBFile &File = NS->getPDBFile();
292  auto ExpectedInfo = File.getPDBInfoStream();
293  // All PDB Files should have an Info stream.
294  if (!ExpectedInfo)
295    return ExpectedInfo.takeError();
296
297  // Just because a file with a matching name was found and it was an actual
298  // PDB file doesn't mean it matches.  For it to match the InfoStream's GUID
299  // must match the GUID specified in the TypeServer2 record.
300  if (ExpectedInfo->getGuid() != GuidFromObj)
301    return make_error<pdb::GenericError>(
302        pdb::generic_error_code::type_server_not_found, TSPath);
303
304  return std::move(NS);
305}
306
307const CVIndexMap &PDBLinker::maybeMergeTypeServerPDB(ObjFile *File,
308                                                     TypeServer2Record &TS) {
309  // First, check if we already loaded a PDB with this GUID. Return the type
310  // index mapping if we have it.
311  auto Insertion = TypeServerIndexMappings.insert({TS.getGuid(), CVIndexMap()});
312  CVIndexMap &IndexMap = Insertion.first->second;
313  if (!Insertion.second)
314    return IndexMap;
315
316  // Mark this map as a type server map.
317  IndexMap.IsTypeServerMap = true;
318
319  // Check for a PDB at:
320  // 1. The given file path
321  // 2. Next to the object file or archive file
322  auto ExpectedSession = tryToLoadPDB(TS.getGuid(), TS.getName());
323  if (!ExpectedSession) {
324    consumeError(ExpectedSession.takeError());
325    StringRef LocalPath =
326        !File->ParentName.empty() ? File->ParentName : File->getName();
327    SmallString<128> Path = sys::path::parent_path(LocalPath);
328    sys::path::append(
329        Path, sys::path::filename(TS.getName(), sys::path::Style::windows));
330    ExpectedSession = tryToLoadPDB(TS.getGuid(), Path);
331  }
332  if (auto E = ExpectedSession.takeError())
333    fatal("Type server PDB was not found: " + toString(std::move(E)));
334
335  auto ExpectedTpi = (*ExpectedSession)->getPDBFile().getPDBTpiStream();
336  if (auto E = ExpectedTpi.takeError())
337    fatal("Type server does not have TPI stream: " + toString(std::move(E)));
338  auto ExpectedIpi = (*ExpectedSession)->getPDBFile().getPDBIpiStream();
339  if (auto E = ExpectedIpi.takeError())
340    fatal("Type server does not have TPI stream: " + toString(std::move(E)));
341
342  if (Config->DebugGHashes) {
343    // PDBs do not actually store global hashes, so when merging a type server
344    // PDB we have to synthesize global hashes.  To do this, we first synthesize
345    // global hashes for the TPI stream, since it is independent, then we
346    // synthesize hashes for the IPI stream, using the hashes for the TPI stream
347    // as inputs.
348    auto TpiHashes = GloballyHashedType::hashTypes(ExpectedTpi->typeArray());
349    auto IpiHashes =
350        GloballyHashedType::hashIds(ExpectedIpi->typeArray(), TpiHashes);
351
352    // Merge TPI first, because the IPI stream will reference type indices.
353    if (auto Err = mergeTypeRecords(GlobalTypeTable, IndexMap.TPIMap,
354                                    ExpectedTpi->typeArray(), TpiHashes))
355      fatal("codeview::mergeTypeRecords failed: " + toString(std::move(Err)));
356
357    // Merge IPI.
358    if (auto Err =
359            mergeIdRecords(GlobalIDTable, IndexMap.TPIMap, IndexMap.IPIMap,
360                           ExpectedIpi->typeArray(), IpiHashes))
361      fatal("codeview::mergeIdRecords failed: " + toString(std::move(Err)));
362  } else {
363    // Merge TPI first, because the IPI stream will reference type indices.
364    if (auto Err = mergeTypeRecords(TypeTable, IndexMap.TPIMap,
365                                    ExpectedTpi->typeArray()))
366      fatal("codeview::mergeTypeRecords failed: " + toString(std::move(Err)));
367
368    // Merge IPI.
369    if (auto Err = mergeIdRecords(IDTable, IndexMap.TPIMap, IndexMap.IPIMap,
370                                  ExpectedIpi->typeArray()))
371      fatal("codeview::mergeIdRecords failed: " + toString(std::move(Err)));
372  }
373
374  return IndexMap;
375}
376
377static bool remapTypeIndex(TypeIndex &TI, ArrayRef<TypeIndex> TypeIndexMap) {
378  if (TI.isSimple())
379    return true;
380  if (TI.toArrayIndex() >= TypeIndexMap.size())
381    return false;
382  TI = TypeIndexMap[TI.toArrayIndex()];
383  return true;
384}
385
386static void remapTypesInSymbolRecord(ObjFile *File, SymbolKind SymKind,
387                                     MutableArrayRef<uint8_t> Contents,
388                                     const CVIndexMap &IndexMap,
389                                     ArrayRef<TiReference> TypeRefs) {
390  for (const TiReference &Ref : TypeRefs) {
391    unsigned ByteSize = Ref.Count * sizeof(TypeIndex);
392    if (Contents.size() < Ref.Offset + ByteSize)
393      fatal("symbol record too short");
394
395    // This can be an item index or a type index. Choose the appropriate map.
396    ArrayRef<TypeIndex> TypeOrItemMap = IndexMap.TPIMap;
397    bool IsItemIndex = Ref.Kind == TiRefKind::IndexRef;
398    if (IsItemIndex && IndexMap.IsTypeServerMap)
399      TypeOrItemMap = IndexMap.IPIMap;
400
401    MutableArrayRef<TypeIndex> TIs(
402        reinterpret_cast<TypeIndex *>(Contents.data() + Ref.Offset), Ref.Count);
403    for (TypeIndex &TI : TIs) {
404      if (!remapTypeIndex(TI, TypeOrItemMap)) {
405        log("ignoring symbol record of kind 0x" + utohexstr(SymKind) + " in " +
406            File->getName() + " with bad " + (IsItemIndex ? "item" : "type") +
407            " index 0x" + utohexstr(TI.getIndex()));
408        TI = TypeIndex(SimpleTypeKind::NotTranslated);
409        continue;
410      }
411    }
412  }
413}
414
415static SymbolKind symbolKind(ArrayRef<uint8_t> RecordData) {
416  const RecordPrefix *Prefix =
417      reinterpret_cast<const RecordPrefix *>(RecordData.data());
418  return static_cast<SymbolKind>(uint16_t(Prefix->RecordKind));
419}
420
421/// MSVC translates S_PROC_ID_END to S_END, and S_[LG]PROC32_ID to S_[LG]PROC32
422static void translateIdSymbols(MutableArrayRef<uint8_t> &RecordData,
423                               TypeCollection &IDTable) {
424  RecordPrefix *Prefix = reinterpret_cast<RecordPrefix *>(RecordData.data());
425
426  SymbolKind Kind = symbolKind(RecordData);
427
428  if (Kind == SymbolKind::S_PROC_ID_END) {
429    Prefix->RecordKind = SymbolKind::S_END;
430    return;
431  }
432
433  // In an object file, GPROC32_ID has an embedded reference which refers to the
434  // single object file type index namespace.  This has already been translated
435  // to the PDB file's ID stream index space, but we need to convert this to a
436  // symbol that refers to the type stream index space.  So we remap again from
437  // ID index space to type index space.
438  if (Kind == SymbolKind::S_GPROC32_ID || Kind == SymbolKind::S_LPROC32_ID) {
439    SmallVector<TiReference, 1> Refs;
440    auto Content = RecordData.drop_front(sizeof(RecordPrefix));
441    CVSymbol Sym(Kind, RecordData);
442    discoverTypeIndicesInSymbol(Sym, Refs);
443    assert(Refs.size() == 1);
444    assert(Refs.front().Count == 1);
445
446    TypeIndex *TI =
447        reinterpret_cast<TypeIndex *>(Content.data() + Refs[0].Offset);
448    // `TI` is the index of a FuncIdRecord or MemberFuncIdRecord which lives in
449    // the IPI stream, whose `FunctionType` member refers to the TPI stream.
450    // Note that LF_FUNC_ID and LF_MEMFUNC_ID have the same record layout, and
451    // in both cases we just need the second type index.
452    if (!TI->isSimple() && !TI->isNoneType()) {
453      CVType FuncIdData = IDTable.getType(*TI);
454      SmallVector<TypeIndex, 2> Indices;
455      discoverTypeIndices(FuncIdData, Indices);
456      assert(Indices.size() == 2);
457      *TI = Indices[1];
458    }
459
460    Kind = (Kind == SymbolKind::S_GPROC32_ID) ? SymbolKind::S_GPROC32
461                                              : SymbolKind::S_LPROC32;
462    Prefix->RecordKind = uint16_t(Kind);
463  }
464}
465
466/// Copy the symbol record. In a PDB, symbol records must be 4 byte aligned.
467/// The object file may not be aligned.
468static MutableArrayRef<uint8_t> copySymbolForPdb(const CVSymbol &Sym,
469                                                 BumpPtrAllocator &Alloc) {
470  size_t Size = alignTo(Sym.length(), alignOf(CodeViewContainer::Pdb));
471  assert(Size >= 4 && "record too short");
472  assert(Size <= MaxRecordLength && "record too long");
473  void *Mem = Alloc.Allocate(Size, 4);
474
475  // Copy the symbol record and zero out any padding bytes.
476  MutableArrayRef<uint8_t> NewData(reinterpret_cast<uint8_t *>(Mem), Size);
477  memcpy(NewData.data(), Sym.data().data(), Sym.length());
478  memset(NewData.data() + Sym.length(), 0, Size - Sym.length());
479
480  // Update the record prefix length. It should point to the beginning of the
481  // next record.
482  auto *Prefix = reinterpret_cast<RecordPrefix *>(Mem);
483  Prefix->RecordLen = Size - 2;
484  return NewData;
485}
486
487/// Return true if this symbol opens a scope. This implies that the symbol has
488/// "parent" and "end" fields, which contain the offset of the S_END or
489/// S_INLINESITE_END record.
490static bool symbolOpensScope(SymbolKind Kind) {
491  switch (Kind) {
492  case SymbolKind::S_GPROC32:
493  case SymbolKind::S_LPROC32:
494  case SymbolKind::S_LPROC32_ID:
495  case SymbolKind::S_GPROC32_ID:
496  case SymbolKind::S_BLOCK32:
497  case SymbolKind::S_SEPCODE:
498  case SymbolKind::S_THUNK32:
499  case SymbolKind::S_INLINESITE:
500  case SymbolKind::S_INLINESITE2:
501    return true;
502  default:
503    break;
504  }
505  return false;
506}
507
508static bool symbolEndsScope(SymbolKind Kind) {
509  switch (Kind) {
510  case SymbolKind::S_END:
511  case SymbolKind::S_PROC_ID_END:
512  case SymbolKind::S_INLINESITE_END:
513    return true;
514  default:
515    break;
516  }
517  return false;
518}
519
520struct ScopeRecord {
521  ulittle32_t PtrParent;
522  ulittle32_t PtrEnd;
523};
524
525struct SymbolScope {
526  ScopeRecord *OpeningRecord;
527  uint32_t ScopeOffset;
528};
529
530static void scopeStackOpen(SmallVectorImpl<SymbolScope> &Stack,
531                           uint32_t CurOffset, CVSymbol &Sym) {
532  assert(symbolOpensScope(Sym.kind()));
533  SymbolScope S;
534  S.ScopeOffset = CurOffset;
535  S.OpeningRecord = const_cast<ScopeRecord *>(
536      reinterpret_cast<const ScopeRecord *>(Sym.content().data()));
537  S.OpeningRecord->PtrParent = Stack.empty() ? 0 : Stack.back().ScopeOffset;
538  Stack.push_back(S);
539}
540
541static void scopeStackClose(SmallVectorImpl<SymbolScope> &Stack,
542                            uint32_t CurOffset, ObjFile *File) {
543  if (Stack.empty()) {
544    warn("symbol scopes are not balanced in " + File->getName());
545    return;
546  }
547  SymbolScope S = Stack.pop_back_val();
548  S.OpeningRecord->PtrEnd = CurOffset;
549}
550
551static bool symbolGoesInModuleStream(const CVSymbol &Sym) {
552  switch (Sym.kind()) {
553  case SymbolKind::S_GDATA32:
554  case SymbolKind::S_CONSTANT:
555  case SymbolKind::S_UDT:
556  // We really should not be seeing S_PROCREF and S_LPROCREF in the first place
557  // since they are synthesized by the linker in response to S_GPROC32 and
558  // S_LPROC32, but if we do see them, don't put them in the module stream I
559  // guess.
560  case SymbolKind::S_PROCREF:
561  case SymbolKind::S_LPROCREF:
562    return false;
563  // S_GDATA32 does not go in the module stream, but S_LDATA32 does.
564  case SymbolKind::S_LDATA32:
565  default:
566    return true;
567  }
568}
569
570static bool symbolGoesInGlobalsStream(const CVSymbol &Sym) {
571  switch (Sym.kind()) {
572  case SymbolKind::S_CONSTANT:
573  case SymbolKind::S_GDATA32:
574  // S_LDATA32 goes in both the module stream and the globals stream.
575  case SymbolKind::S_LDATA32:
576  case SymbolKind::S_GPROC32:
577  case SymbolKind::S_LPROC32:
578  // We really should not be seeing S_PROCREF and S_LPROCREF in the first place
579  // since they are synthesized by the linker in response to S_GPROC32 and
580  // S_LPROC32, but if we do see them, copy them straight through.
581  case SymbolKind::S_PROCREF:
582  case SymbolKind::S_LPROCREF:
583    return true;
584  // FIXME: For now, we drop all S_UDT symbols (i.e. they don't go in the
585  // globals stream or the modules stream).  These have special handling which
586  // needs more investigation before we can get right, but by putting them all
587  // into the globals stream WinDbg fails to display local variables of class
588  // types saying that it cannot find the type Foo *.  So as a stopgap just to
589  // keep things working, we drop them.
590  case SymbolKind::S_UDT:
591  default:
592    return false;
593  }
594}
595
596static void addGlobalSymbol(pdb::GSIStreamBuilder &Builder, ObjFile &File,
597                            const CVSymbol &Sym) {
598  switch (Sym.kind()) {
599  case SymbolKind::S_CONSTANT:
600  case SymbolKind::S_UDT:
601  case SymbolKind::S_GDATA32:
602  case SymbolKind::S_LDATA32:
603  case SymbolKind::S_PROCREF:
604  case SymbolKind::S_LPROCREF:
605    Builder.addGlobalSymbol(Sym);
606    break;
607  case SymbolKind::S_GPROC32:
608  case SymbolKind::S_LPROC32: {
609    SymbolRecordKind K = SymbolRecordKind::ProcRefSym;
610    if (Sym.kind() == SymbolKind::S_LPROC32)
611      K = SymbolRecordKind::LocalProcRef;
612    ProcRefSym PS(K);
613    PS.Module = static_cast<uint16_t>(File.ModuleDBI->getModuleIndex());
614    // For some reason, MSVC seems to add one to this value.
615    ++PS.Module;
616    PS.Name = getSymbolName(Sym);
617    PS.SumName = 0;
618    PS.SymOffset = File.ModuleDBI->getNextSymbolOffset();
619    Builder.addGlobalSymbol(PS);
620    break;
621  }
622  default:
623    llvm_unreachable("Invalid symbol kind!");
624  }
625}
626
627static void mergeSymbolRecords(BumpPtrAllocator &Alloc, ObjFile *File,
628                               pdb::GSIStreamBuilder &GsiBuilder,
629                               const CVIndexMap &IndexMap,
630                               TypeCollection &IDTable,
631                               BinaryStreamRef SymData) {
632  // FIXME: Improve error recovery by warning and skipping records when
633  // possible.
634  CVSymbolArray Syms;
635  BinaryStreamReader Reader(SymData);
636  ExitOnErr(Reader.readArray(Syms, Reader.getLength()));
637  SmallVector<SymbolScope, 4> Scopes;
638  for (CVSymbol Sym : Syms) {
639    // Discover type index references in the record. Skip it if we don't know
640    // where they are.
641    SmallVector<TiReference, 32> TypeRefs;
642    if (!discoverTypeIndicesInSymbol(Sym, TypeRefs)) {
643      log("ignoring unknown symbol record with kind 0x" + utohexstr(Sym.kind()));
644      continue;
645    }
646
647    // Copy the symbol record so we can mutate it.
648    MutableArrayRef<uint8_t> NewData = copySymbolForPdb(Sym, Alloc);
649
650    // Re-map all the type index references.
651    MutableArrayRef<uint8_t> Contents =
652        NewData.drop_front(sizeof(RecordPrefix));
653    remapTypesInSymbolRecord(File, Sym.kind(), Contents, IndexMap, TypeRefs);
654
655    // An object file may have S_xxx_ID symbols, but these get converted to
656    // "real" symbols in a PDB.
657    translateIdSymbols(NewData, IDTable);
658
659    SymbolKind NewKind = symbolKind(NewData);
660
661    // Fill in "Parent" and "End" fields by maintaining a stack of scopes.
662    CVSymbol NewSym(NewKind, NewData);
663    if (symbolOpensScope(NewKind))
664      scopeStackOpen(Scopes, File->ModuleDBI->getNextSymbolOffset(), NewSym);
665    else if (symbolEndsScope(NewKind))
666      scopeStackClose(Scopes, File->ModuleDBI->getNextSymbolOffset(), File);
667
668    // Add the symbol to the globals stream if necessary.  Do this before adding
669    // the symbol to the module since we may need to get the next symbol offset,
670    // and writing to the module's symbol stream will update that offset.
671    if (symbolGoesInGlobalsStream(NewSym))
672      addGlobalSymbol(GsiBuilder, *File, NewSym);
673
674    // Add the symbol to the module.
675    if (symbolGoesInModuleStream(NewSym))
676      File->ModuleDBI->addSymbol(NewSym);
677  }
678}
679
680// Allocate memory for a .debug$S section and relocate it.
681static ArrayRef<uint8_t> relocateDebugChunk(BumpPtrAllocator &Alloc,
682                                            SectionChunk *DebugChunk) {
683  uint8_t *Buffer = Alloc.Allocate<uint8_t>(DebugChunk->getSize());
684  assert(DebugChunk->OutputSectionOff == 0 &&
685         "debug sections should not be in output sections");
686  DebugChunk->writeTo(Buffer);
687  return consumeDebugMagic(makeArrayRef(Buffer, DebugChunk->getSize()),
688                           ".debug$S");
689}
690
691void PDBLinker::addObjFile(ObjFile *File) {
692  // Add a module descriptor for every object file. We need to put an absolute
693  // path to the object into the PDB. If this is a plain object, we make its
694  // path absolute. If it's an object in an archive, we make the archive path
695  // absolute.
696  bool InArchive = !File->ParentName.empty();
697  SmallString<128> Path = InArchive ? File->ParentName : File->getName();
698  sys::fs::make_absolute(Path);
699  sys::path::native(Path, sys::path::Style::windows);
700  StringRef Name = InArchive ? File->getName() : StringRef(Path);
701
702  File->ModuleDBI = &ExitOnErr(Builder.getDbiBuilder().addModuleInfo(Name));
703  File->ModuleDBI->setObjFileName(Path);
704
705  // Before we can process symbol substreams from .debug$S, we need to process
706  // type information, file checksums, and the string table.  Add type info to
707  // the PDB first, so that we can get the map from object file type and item
708  // indices to PDB type and item indices.
709  CVIndexMap ObjectIndexMap;
710  const CVIndexMap &IndexMap = mergeDebugT(File, ObjectIndexMap);
711
712  // Now do all live .debug$S sections.
713  for (SectionChunk *DebugChunk : File->getDebugChunks()) {
714    if (!DebugChunk->isLive() || DebugChunk->getSectionName() != ".debug$S")
715      continue;
716
717    ArrayRef<uint8_t> RelocatedDebugContents =
718        relocateDebugChunk(Alloc, DebugChunk);
719    if (RelocatedDebugContents.empty())
720      continue;
721
722    DebugSubsectionArray Subsections;
723    BinaryStreamReader Reader(RelocatedDebugContents, support::little);
724    ExitOnErr(Reader.readArray(Subsections, RelocatedDebugContents.size()));
725
726    DebugStringTableSubsectionRef CVStrTab;
727    DebugChecksumsSubsectionRef Checksums;
728    for (const DebugSubsectionRecord &SS : Subsections) {
729      switch (SS.kind()) {
730      case DebugSubsectionKind::StringTable:
731        ExitOnErr(CVStrTab.initialize(SS.getRecordData()));
732        break;
733      case DebugSubsectionKind::FileChecksums:
734        ExitOnErr(Checksums.initialize(SS.getRecordData()));
735        break;
736      case DebugSubsectionKind::Lines:
737        // We can add the relocated line table directly to the PDB without
738        // modification because the file checksum offsets will stay the same.
739        File->ModuleDBI->addDebugSubsection(SS);
740        break;
741      case DebugSubsectionKind::Symbols:
742        if (Config->DebugGHashes) {
743          mergeSymbolRecords(Alloc, File, Builder.getGsiBuilder(), IndexMap,
744                             GlobalIDTable, SS.getRecordData());
745        } else {
746          mergeSymbolRecords(Alloc, File, Builder.getGsiBuilder(), IndexMap,
747                             IDTable, SS.getRecordData());
748        }
749        break;
750      default:
751        // FIXME: Process the rest of the subsections.
752        break;
753      }
754    }
755
756    if (Checksums.valid()) {
757      // Make a new file checksum table that refers to offsets in the PDB-wide
758      // string table. Generally the string table subsection appears after the
759      // checksum table, so we have to do this after looping over all the
760      // subsections.
761      if (!CVStrTab.valid())
762        fatal(".debug$S sections must have both a string table subsection "
763              "and a checksum subsection table or neither");
764      auto NewChecksums = make_unique<DebugChecksumsSubsection>(PDBStrTab);
765      for (FileChecksumEntry &FC : Checksums) {
766        StringRef FileName = ExitOnErr(CVStrTab.getString(FC.FileNameOffset));
767        ExitOnErr(Builder.getDbiBuilder().addModuleSourceFile(*File->ModuleDBI,
768                                                              FileName));
769        NewChecksums->addChecksum(FileName, FC.Kind, FC.Checksum);
770      }
771      File->ModuleDBI->addDebugSubsection(std::move(NewChecksums));
772    }
773  }
774}
775
776static PublicSym32 createPublic(Defined *Def) {
777  PublicSym32 Pub(SymbolKind::S_PUB32);
778  Pub.Name = Def->getName();
779  if (auto *D = dyn_cast<DefinedCOFF>(Def)) {
780    if (D->getCOFFSymbol().isFunctionDefinition())
781      Pub.Flags = PublicSymFlags::Function;
782  } else if (isa<DefinedImportThunk>(Def)) {
783    Pub.Flags = PublicSymFlags::Function;
784  }
785
786  OutputSection *OS = Def->getChunk()->getOutputSection();
787  assert(OS && "all publics should be in final image");
788  Pub.Offset = Def->getRVA() - OS->getRVA();
789  Pub.Segment = OS->SectionIndex;
790  return Pub;
791}
792
793// Add all object files to the PDB. Merge .debug$T sections into IpiData and
794// TpiData.
795void PDBLinker::addObjectsToPDB() {
796  for (ObjFile *File : ObjFile::Instances)
797    addObjFile(File);
798
799  Builder.getStringTableBuilder().setStrings(PDBStrTab);
800
801  // Construct TPI and IPI stream contents.
802  if (Config->DebugGHashes) {
803    addTypeInfo(Builder.getTpiBuilder(), GlobalTypeTable);
804    addTypeInfo(Builder.getIpiBuilder(), GlobalIDTable);
805  } else {
806    addTypeInfo(Builder.getTpiBuilder(), TypeTable);
807    addTypeInfo(Builder.getIpiBuilder(), IDTable);
808  }
809
810  // Compute the public and global symbols.
811  auto &GsiBuilder = Builder.getGsiBuilder();
812  std::vector<PublicSym32> Publics;
813  Symtab->forEachSymbol([&Publics](Symbol *S) {
814    // Only emit defined, live symbols that have a chunk.
815    auto *Def = dyn_cast<Defined>(S);
816    if (Def && Def->isLive() && Def->getChunk())
817      Publics.push_back(createPublic(Def));
818  });
819
820  if (!Publics.empty()) {
821    // Sort the public symbols and add them to the stream.
822    std::sort(Publics.begin(), Publics.end(),
823              [](const PublicSym32 &L, const PublicSym32 &R) {
824                return L.Name < R.Name;
825              });
826    for (const PublicSym32 &Pub : Publics)
827      GsiBuilder.addPublicSymbol(Pub);
828  }
829}
830
831static void addCommonLinkerModuleSymbols(StringRef Path,
832                                         pdb::DbiModuleDescriptorBuilder &Mod,
833                                         BumpPtrAllocator &Allocator) {
834  ObjNameSym ONS(SymbolRecordKind::ObjNameSym);
835  Compile3Sym CS(SymbolRecordKind::Compile3Sym);
836  EnvBlockSym EBS(SymbolRecordKind::EnvBlockSym);
837
838  ONS.Name = "* Linker *";
839  ONS.Signature = 0;
840
841  CS.Machine = Config->is64() ? CPUType::X64 : CPUType::Intel80386;
842  // Interestingly, if we set the string to 0.0.0.0, then when trying to view
843  // local variables WinDbg emits an error that private symbols are not present.
844  // By setting this to a valid MSVC linker version string, local variables are
845  // displayed properly.   As such, even though it is not representative of
846  // LLVM's version information, we need this for compatibility.
847  CS.Flags = CompileSym3Flags::None;
848  CS.VersionBackendBuild = 25019;
849  CS.VersionBackendMajor = 14;
850  CS.VersionBackendMinor = 10;
851  CS.VersionBackendQFE = 0;
852
853  // MSVC also sets the frontend to 0.0.0.0 since this is specifically for the
854  // linker module (which is by definition a backend), so we don't need to do
855  // anything here.  Also, it seems we can use "LLVM Linker" for the linker name
856  // without any problems.  Only the backend version has to be hardcoded to a
857  // magic number.
858  CS.VersionFrontendBuild = 0;
859  CS.VersionFrontendMajor = 0;
860  CS.VersionFrontendMinor = 0;
861  CS.VersionFrontendQFE = 0;
862  CS.Version = "LLVM Linker";
863  CS.setLanguage(SourceLanguage::Link);
864
865  ArrayRef<StringRef> Args = makeArrayRef(Config->Argv).drop_front();
866  std::string ArgStr = llvm::join(Args, " ");
867  EBS.Fields.push_back("cwd");
868  SmallString<64> cwd;
869  sys::fs::current_path(cwd);
870  EBS.Fields.push_back(cwd);
871  EBS.Fields.push_back("exe");
872  SmallString<64> exe = Config->Argv[0];
873  llvm::sys::fs::make_absolute(exe);
874  EBS.Fields.push_back(exe);
875  EBS.Fields.push_back("pdb");
876  EBS.Fields.push_back(Path);
877  EBS.Fields.push_back("cmd");
878  EBS.Fields.push_back(ArgStr);
879  Mod.addSymbol(codeview::SymbolSerializer::writeOneSymbol(
880      ONS, Allocator, CodeViewContainer::Pdb));
881  Mod.addSymbol(codeview::SymbolSerializer::writeOneSymbol(
882      CS, Allocator, CodeViewContainer::Pdb));
883  Mod.addSymbol(codeview::SymbolSerializer::writeOneSymbol(
884      EBS, Allocator, CodeViewContainer::Pdb));
885}
886
887static void addLinkerModuleSectionSymbol(pdb::DbiModuleDescriptorBuilder &Mod,
888                                         OutputSection &OS,
889                                         BumpPtrAllocator &Allocator) {
890  SectionSym Sym(SymbolRecordKind::SectionSym);
891  Sym.Alignment = 12; // 2^12 = 4KB
892  Sym.Characteristics = OS.getCharacteristics();
893  Sym.Length = OS.getVirtualSize();
894  Sym.Name = OS.getName();
895  Sym.Rva = OS.getRVA();
896  Sym.SectionNumber = OS.SectionIndex;
897  Mod.addSymbol(codeview::SymbolSerializer::writeOneSymbol(
898      Sym, Allocator, CodeViewContainer::Pdb));
899}
900
901// Creates a PDB file.
902void coff::createPDB(SymbolTable *Symtab,
903                     ArrayRef<OutputSection *> OutputSections,
904                     ArrayRef<uint8_t> SectionTable,
905                     const llvm::codeview::DebugInfo &BuildId) {
906  PDBLinker PDB(Symtab);
907  PDB.initialize(BuildId);
908  PDB.addObjectsToPDB();
909  PDB.addSections(OutputSections, SectionTable);
910  PDB.commit();
911}
912
913void PDBLinker::initialize(const llvm::codeview::DebugInfo &BuildId) {
914  ExitOnErr(Builder.initialize(4096)); // 4096 is blocksize
915
916  // Create streams in MSF for predefined streams, namely
917  // PDB, TPI, DBI and IPI.
918  for (int I = 0; I < (int)pdb::kSpecialStreamCount; ++I)
919    ExitOnErr(Builder.getMsfBuilder().addStream(0));
920
921  // Add an Info stream.
922  auto &InfoBuilder = Builder.getInfoBuilder();
923  InfoBuilder.setAge(BuildId.PDB70.Age);
924
925  GUID uuid;
926  memcpy(&uuid, &BuildId.PDB70.Signature, sizeof(uuid));
927  InfoBuilder.setGuid(uuid);
928  InfoBuilder.setSignature(time(nullptr));
929  InfoBuilder.setVersion(pdb::PdbRaw_ImplVer::PdbImplVC70);
930
931  // Add an empty DBI stream.
932  pdb::DbiStreamBuilder &DbiBuilder = Builder.getDbiBuilder();
933  DbiBuilder.setAge(BuildId.PDB70.Age);
934  DbiBuilder.setVersionHeader(pdb::PdbDbiV70);
935  ExitOnErr(DbiBuilder.addDbgStream(pdb::DbgHeaderType::NewFPO, {}));
936}
937
938void PDBLinker::addSectionContrib(pdb::DbiModuleDescriptorBuilder &LinkerModule,
939                                  OutputSection *OS, Chunk *C) {
940  pdb::SectionContrib SC;
941  memset(&SC, 0, sizeof(SC));
942  SC.ISect = OS->SectionIndex;
943  SC.Off = C->getRVA() - OS->getRVA();
944  SC.Size = C->getSize();
945  if (auto *SecChunk = dyn_cast<SectionChunk>(C)) {
946    SC.Characteristics = SecChunk->Header->Characteristics;
947    SC.Imod = SecChunk->File->ModuleDBI->getModuleIndex();
948    ArrayRef<uint8_t> Contents = SecChunk->getContents();
949    JamCRC CRC(0);
950    ArrayRef<char> CharContents = makeArrayRef(
951        reinterpret_cast<const char *>(Contents.data()), Contents.size());
952    CRC.update(CharContents);
953    SC.DataCrc = CRC.getCRC();
954  } else {
955    SC.Characteristics = OS->getCharacteristics();
956    // FIXME: When we start creating DBI for import libraries, use those here.
957    SC.Imod = LinkerModule.getModuleIndex();
958  }
959  SC.RelocCrc = 0; // FIXME
960  Builder.getDbiBuilder().addSectionContrib(SC);
961}
962
963void PDBLinker::addSections(ArrayRef<OutputSection *> OutputSections,
964                            ArrayRef<uint8_t> SectionTable) {
965  // It's not entirely clear what this is, but the * Linker * module uses it.
966  pdb::DbiStreamBuilder &DbiBuilder = Builder.getDbiBuilder();
967  NativePath = Config->PDBPath;
968  sys::fs::make_absolute(NativePath);
969  sys::path::native(NativePath, sys::path::Style::windows);
970  uint32_t PdbFilePathNI = DbiBuilder.addECName(NativePath);
971  auto &LinkerModule = ExitOnErr(DbiBuilder.addModuleInfo("* Linker *"));
972  LinkerModule.setPdbFilePathNI(PdbFilePathNI);
973  addCommonLinkerModuleSymbols(NativePath, LinkerModule, Alloc);
974
975  // Add section contributions. They must be ordered by ascending RVA.
976  for (OutputSection *OS : OutputSections) {
977    addLinkerModuleSectionSymbol(LinkerModule, *OS, Alloc);
978    for (Chunk *C : OS->getChunks())
979      addSectionContrib(LinkerModule, OS, C);
980  }
981
982  // Add Section Map stream.
983  ArrayRef<object::coff_section> Sections = {
984      (const object::coff_section *)SectionTable.data(),
985      SectionTable.size() / sizeof(object::coff_section)};
986  SectionMap = pdb::DbiStreamBuilder::createSectionMap(Sections);
987  DbiBuilder.setSectionMap(SectionMap);
988
989  // Add COFF section header stream.
990  ExitOnErr(
991      DbiBuilder.addDbgStream(pdb::DbgHeaderType::SectionHdr, SectionTable));
992}
993
994void PDBLinker::commit() {
995  // Write to a file.
996  ExitOnErr(Builder.commit(Config->PDBPath));
997}
998