blob: 74fc805b2601bffa9c640099eb95d6fd1f261bb1 [file] [log] [blame]
Rui Ueyamae7378242015-12-04 23:11:05 +00001//===- 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
Rui Ueyama1d99ab32016-09-15 22:24:51 +000010#include "PDB.h"
Rui Ueyama09e0b5f2016-11-12 00:00:51 +000011#include "Chunks.h"
Rui Ueyamabe939b32016-11-21 17:22:35 +000012#include "Config.h"
Rui Ueyamae7378242015-12-04 23:11:05 +000013#include "Error.h"
Rui Ueyama09e0b5f2016-11-12 00:00:51 +000014#include "SymbolTable.h"
15#include "Symbols.h"
Reid Klecknereacdf042017-07-27 18:25:59 +000016#include "Writer.h"
Saleem Abdulrasooldf8a13b2017-01-04 17:56:54 +000017#include "llvm/DebugInfo/CodeView/CVDebugRecord.h"
Reid Kleckner44cdb102017-06-19 17:21:45 +000018#include "llvm/DebugInfo/CodeView/DebugSubsectionRecord.h"
Zachary Turner526f4f22017-05-19 19:26:58 +000019#include "llvm/DebugInfo/CodeView/LazyRandomTypeCollection.h"
Zachary Turneree9906d2017-08-11 19:00:03 +000020#include "llvm/DebugInfo/CodeView/RecordName.h"
Zachary Turner59e3ae82017-08-08 18:34:44 +000021#include "llvm/DebugInfo/CodeView/SymbolDeserializer.h"
Zachary Turner6708e0b2017-07-10 21:01:37 +000022#include "llvm/DebugInfo/CodeView/SymbolSerializer.h"
Reid Kleckner651db912017-07-18 00:21:25 +000023#include "llvm/DebugInfo/CodeView/TypeDeserializer.h"
Zachary Turner629cb7d2017-01-11 23:24:22 +000024#include "llvm/DebugInfo/CodeView/TypeDumpVisitor.h"
Reid Klecknerd0e6e242017-06-21 17:25:56 +000025#include "llvm/DebugInfo/CodeView/TypeIndexDiscovery.h"
Rui Ueyama52896622017-01-12 03:09:25 +000026#include "llvm/DebugInfo/CodeView/TypeStreamMerger.h"
27#include "llvm/DebugInfo/CodeView/TypeTableBuilder.h"
Rui Ueyamab28c6d42016-09-16 04:32:33 +000028#include "llvm/DebugInfo/MSF/MSFBuilder.h"
Rui Ueyama7f382992016-09-15 18:55:18 +000029#include "llvm/DebugInfo/MSF/MSFCommon.h"
Reid Kleckner651db912017-07-18 00:21:25 +000030#include "llvm/DebugInfo/PDB/GenericError.h"
Zachary Turner6708e0b2017-07-10 21:01:37 +000031#include "llvm/DebugInfo/PDB/Native/DbiModuleDescriptorBuilder.h"
Adrian McCarthy6b6b8c42017-01-25 22:38:55 +000032#include "llvm/DebugInfo/PDB/Native/DbiStream.h"
33#include "llvm/DebugInfo/PDB/Native/DbiStreamBuilder.h"
Zachary Turner946204c2017-08-09 04:23:25 +000034#include "llvm/DebugInfo/PDB/Native/GSIStreamBuilder.h"
Adrian McCarthy6b6b8c42017-01-25 22:38:55 +000035#include "llvm/DebugInfo/PDB/Native/InfoStream.h"
36#include "llvm/DebugInfo/PDB/Native/InfoStreamBuilder.h"
Reid Kleckner651db912017-07-18 00:21:25 +000037#include "llvm/DebugInfo/PDB/Native/NativeSession.h"
Adrian McCarthy6b6b8c42017-01-25 22:38:55 +000038#include "llvm/DebugInfo/PDB/Native/PDBFile.h"
39#include "llvm/DebugInfo/PDB/Native/PDBFileBuilder.h"
Rafael Espindolaa0f30da2017-05-02 20:19:42 +000040#include "llvm/DebugInfo/PDB/Native/PDBStringTableBuilder.h"
Reid Klecknerd91ca762017-07-19 17:26:07 +000041#include "llvm/DebugInfo/PDB/Native/TpiHashing.h"
Adrian McCarthy6b6b8c42017-01-25 22:38:55 +000042#include "llvm/DebugInfo/PDB/Native/TpiStream.h"
43#include "llvm/DebugInfo/PDB/Native/TpiStreamBuilder.h"
Reid Kleckner651db912017-07-18 00:21:25 +000044#include "llvm/DebugInfo/PDB/PDB.h"
Rui Ueyama20df4ec2016-10-31 21:09:21 +000045#include "llvm/Object/COFF.h"
Zachary Turnerd9dc2822017-03-02 20:52:51 +000046#include "llvm/Support/BinaryByteStream.h"
Rui Ueyama1763c0d2015-12-08 18:39:55 +000047#include "llvm/Support/Endian.h"
Rui Ueyamae7378242015-12-04 23:11:05 +000048#include "llvm/Support/FileOutputBuffer.h"
Zachary Turner676386ff2017-08-07 20:23:45 +000049#include "llvm/Support/JamCRC.h"
Zachary Turner7b327d02017-02-16 23:35:45 +000050#include "llvm/Support/Path.h"
Rui Ueyamabe939b32016-11-21 17:22:35 +000051#include "llvm/Support/ScopedPrinter.h"
Rui Ueyamae7378242015-12-04 23:11:05 +000052#include <memory>
53
Rui Ueyama1d99ab32016-09-15 22:24:51 +000054using namespace lld;
Rui Ueyama09e0b5f2016-11-12 00:00:51 +000055using namespace lld::coff;
Rui Ueyamae7378242015-12-04 23:11:05 +000056using namespace llvm;
Rui Ueyamabe939b32016-11-21 17:22:35 +000057using namespace llvm::codeview;
Rui Ueyamae7378242015-12-04 23:11:05 +000058
Rui Ueyama09e0b5f2016-11-12 00:00:51 +000059using llvm::object::coff_section;
60
Rui Ueyamab28c6d42016-09-16 04:32:33 +000061static ExitOnError ExitOnErr;
62
Reid Kleckner0faf6d72017-07-14 00:14:58 +000063namespace {
Reid Kleckner651db912017-07-18 00:21:25 +000064/// Map from type index and item index in a type server PDB to the
65/// corresponding index in the destination PDB.
66struct CVIndexMap {
67 SmallVector<TypeIndex, 0> TPIMap;
68 SmallVector<TypeIndex, 0> IPIMap;
69 bool IsTypeServerMap = false;
70};
71
Reid Kleckner0faf6d72017-07-14 00:14:58 +000072class PDBLinker {
73public:
74 PDBLinker(SymbolTable *Symtab)
75 : Alloc(), Symtab(Symtab), Builder(Alloc), TypeTable(Alloc),
76 IDTable(Alloc) {}
77
78 /// Emit the basic PDB structure: initial streams, headers, etc.
79 void initialize(const llvm::codeview::DebugInfo *DI);
80
81 /// Link CodeView from each object file in the symbol table into the PDB.
82 void addObjectsToPDB();
83
84 /// Link CodeView from a single object file into the PDB.
Rui Ueyamae1b48e02017-07-26 23:05:24 +000085 void addObjFile(ObjFile *File);
Reid Kleckner0faf6d72017-07-14 00:14:58 +000086
Reid Kleckner651db912017-07-18 00:21:25 +000087 /// Produce a mapping from the type and item indices used in the object
88 /// file to those in the destination PDB.
89 ///
90 /// If the object file uses a type server PDB (compiled with /Zi), merge TPI
91 /// and IPI from the type server PDB and return a map for it. Each unique type
92 /// server PDB is merged at most once, so this may return an existing index
93 /// mapping.
94 ///
95 /// If the object does not use a type server PDB (compiled with /Z7), we merge
96 /// all the type and item records from the .debug$S stream and fill in the
97 /// caller-provided ObjectIndexMap.
Rui Ueyamae1b48e02017-07-26 23:05:24 +000098 const CVIndexMap &mergeDebugT(ObjFile *File, CVIndexMap &ObjectIndexMap);
Reid Kleckner651db912017-07-18 00:21:25 +000099
Rui Ueyamae1b48e02017-07-26 23:05:24 +0000100 const CVIndexMap &maybeMergeTypeServerPDB(ObjFile *File,
Reid Kleckner651db912017-07-18 00:21:25 +0000101 TypeServer2Record &TS);
Reid Kleckner0faf6d72017-07-14 00:14:58 +0000102
103 /// Add the section map and section contributions to the PDB.
Reid Kleckner175af4b2017-08-03 21:15:09 +0000104 void addSections(ArrayRef<OutputSection *> OutputSections,
105 ArrayRef<uint8_t> SectionTable);
106
107 void addSectionContrib(pdb::DbiModuleDescriptorBuilder &LinkerModule,
108 OutputSection *OS, Chunk *C);
Reid Kleckner0faf6d72017-07-14 00:14:58 +0000109
110 /// Write the PDB to disk.
111 void commit();
112
113private:
114 BumpPtrAllocator Alloc;
115
116 SymbolTable *Symtab;
117
118 pdb::PDBFileBuilder Builder;
119
120 /// Type records that will go into the PDB TPI stream.
121 TypeTableBuilder TypeTable;
122
123 /// Item records that will go into the PDB IPI stream.
124 TypeTableBuilder IDTable;
125
126 /// PDBs use a single global string table for filenames in the file checksum
127 /// table.
128 DebugStringTableSubsection PDBStrTab;
129
Reid Kleckner0faf6d72017-07-14 00:14:58 +0000130 llvm::SmallString<128> NativePath;
131
132 std::vector<pdb::SecMapEntry> SectionMap;
Reid Kleckner651db912017-07-18 00:21:25 +0000133
134 /// Type index mappings of type server PDBs that we've loaded so far.
135 std::map<GUID, CVIndexMap> TypeServerIndexMappings;
Reid Kleckner0faf6d72017-07-14 00:14:58 +0000136};
137}
138
Rui Ueyamabe939b32016-11-21 17:22:35 +0000139static SectionChunk *findByName(std::vector<SectionChunk *> &Sections,
140 StringRef Name) {
141 for (SectionChunk *C : Sections)
142 if (C->getSectionName() == Name)
143 return C;
144 return nullptr;
145}
146
Reid Kleckner44cdb102017-06-19 17:21:45 +0000147static ArrayRef<uint8_t> consumeDebugMagic(ArrayRef<uint8_t> Data,
148 StringRef SecName) {
Rui Ueyamac5cb7372016-12-01 01:22:48 +0000149 // First 4 bytes are section magic.
Rui Ueyamac5cb7372016-12-01 01:22:48 +0000150 if (Data.size() < 4)
Rui Ueyama52896622017-01-12 03:09:25 +0000151 fatal(SecName + " too short");
Reid Kleckner44cdb102017-06-19 17:21:45 +0000152 if (support::endian::read32le(Data.data()) != COFF::DEBUG_SECTION_MAGIC)
Rui Ueyama52896622017-01-12 03:09:25 +0000153 fatal(SecName + " has an invalid magic");
Rui Ueyama26186c72016-12-09 04:46:54 +0000154 return Data.slice(4);
155}
Rui Ueyamac5cb7372016-12-01 01:22:48 +0000156
Rui Ueyamae1b48e02017-07-26 23:05:24 +0000157static ArrayRef<uint8_t> getDebugSection(ObjFile *File, StringRef SecName) {
Reid Kleckner44cdb102017-06-19 17:21:45 +0000158 if (SectionChunk *Sec = findByName(File->getDebugChunks(), SecName))
159 return consumeDebugMagic(Sec->getContents(), SecName);
160 return {};
161}
162
Reid Kleckner5d577522017-03-24 17:26:38 +0000163static void addTypeInfo(pdb::TpiStreamBuilder &TpiBuilder,
Reid Kleckner44cdb102017-06-19 17:21:45 +0000164 TypeTableBuilder &TypeTable) {
Reid Kleckner5d577522017-03-24 17:26:38 +0000165 // Start the TPI or IPI stream header.
166 TpiBuilder.setVersionHeader(pdb::PdbTpiV80);
Rui Ueyama52896622017-01-12 03:09:25 +0000167
Reid Klecknerd91ca762017-07-19 17:26:07 +0000168 // Flatten the in memory type table and hash each type.
Reid Kleckner5d577522017-03-24 17:26:38 +0000169 TypeTable.ForEachRecord([&](TypeIndex TI, ArrayRef<uint8_t> Rec) {
Reid Klecknerd91ca762017-07-19 17:26:07 +0000170 assert(Rec.size() >= sizeof(RecordPrefix));
171 const RecordPrefix *P = reinterpret_cast<const RecordPrefix *>(Rec.data());
172 CVType Type(static_cast<TypeLeafKind>(unsigned(P->RecordKind)), Rec);
173 auto Hash = pdb::hashTypeRecord(Type);
174 if (auto E = Hash.takeError())
175 fatal("type hashing error");
176 TpiBuilder.addTypeRecord(Rec, *Hash);
Reid Kleckner5d577522017-03-24 17:26:38 +0000177 });
Reid Kleckner5d577522017-03-24 17:26:38 +0000178}
179
Reid Kleckner651db912017-07-18 00:21:25 +0000180static Optional<TypeServer2Record>
181maybeReadTypeServerRecord(CVTypeArray &Types) {
182 auto I = Types.begin();
183 if (I == Types.end())
184 return None;
185 const CVType &Type = *I;
186 if (Type.kind() != LF_TYPESERVER2)
187 return None;
188 TypeServer2Record TS;
189 if (auto EC = TypeDeserializer::deserializeAs(const_cast<CVType &>(Type), TS))
190 fatal(EC, "error reading type server record");
191 return std::move(TS);
192}
193
Rui Ueyamae1b48e02017-07-26 23:05:24 +0000194const CVIndexMap &PDBLinker::mergeDebugT(ObjFile *File,
Reid Kleckner651db912017-07-18 00:21:25 +0000195 CVIndexMap &ObjectIndexMap) {
Reid Kleckner44cdb102017-06-19 17:21:45 +0000196 ArrayRef<uint8_t> Data = getDebugSection(File, ".debug$T");
197 if (Data.empty())
Reid Kleckner651db912017-07-18 00:21:25 +0000198 return ObjectIndexMap;
Reid Kleckner6597c282017-07-13 20:12:23 +0000199
Reid Kleckner44cdb102017-06-19 17:21:45 +0000200 BinaryByteStream Stream(Data, support::little);
201 CVTypeArray Types;
202 BinaryStreamReader Reader(Stream);
Reid Kleckner44cdb102017-06-19 17:21:45 +0000203 if (auto EC = Reader.readArray(Types, Reader.getLength()))
204 fatal(EC, "Reader::readArray failed");
Reid Kleckner651db912017-07-18 00:21:25 +0000205
206 // Look through type servers. If we've already seen this type server, don't
207 // merge any type information.
208 if (Optional<TypeServer2Record> TS = maybeReadTypeServerRecord(Types))
209 return maybeMergeTypeServerPDB(File, *TS);
210
211 // This is a /Z7 object. Fill in the temporary, caller-provided
212 // ObjectIndexMap.
213 if (auto Err = mergeTypeAndIdRecords(IDTable, TypeTable,
214 ObjectIndexMap.TPIMap, Types))
215 fatal(Err, "codeview::mergeTypeAndIdRecords failed");
216 return ObjectIndexMap;
217}
218
219static Expected<std::unique_ptr<pdb::NativeSession>>
220tryToLoadPDB(const GUID &GuidFromObj, StringRef TSPath) {
221 std::unique_ptr<pdb::IPDBSession> ThisSession;
222 if (auto EC =
223 pdb::loadDataForPDB(pdb::PDB_ReaderType::Native, TSPath, ThisSession))
224 return std::move(EC);
225
226 std::unique_ptr<pdb::NativeSession> NS(
227 static_cast<pdb::NativeSession *>(ThisSession.release()));
228 pdb::PDBFile &File = NS->getPDBFile();
229 auto ExpectedInfo = File.getPDBInfoStream();
230 // All PDB Files should have an Info stream.
231 if (!ExpectedInfo)
232 return ExpectedInfo.takeError();
233
234 // Just because a file with a matching name was found and it was an actual
235 // PDB file doesn't mean it matches. For it to match the InfoStream's GUID
236 // must match the GUID specified in the TypeServer2 record.
237 if (ExpectedInfo->getGuid() != GuidFromObj)
238 return make_error<pdb::GenericError>(
239 pdb::generic_error_code::type_server_not_found, TSPath);
240
241 return std::move(NS);
242}
243
Rui Ueyamae1b48e02017-07-26 23:05:24 +0000244const CVIndexMap &PDBLinker::maybeMergeTypeServerPDB(ObjFile *File,
Reid Kleckner651db912017-07-18 00:21:25 +0000245 TypeServer2Record &TS) {
246 // First, check if we already loaded a PDB with this GUID. Return the type
247 // index mapping if we have it.
248 auto Insertion = TypeServerIndexMappings.insert({TS.getGuid(), CVIndexMap()});
249 CVIndexMap &IndexMap = Insertion.first->second;
250 if (!Insertion.second)
251 return IndexMap;
252
253 // Mark this map as a type server map.
254 IndexMap.IsTypeServerMap = true;
255
256 // Check for a PDB at:
257 // 1. The given file path
258 // 2. Next to the object file or archive file
259 auto ExpectedSession = tryToLoadPDB(TS.getGuid(), TS.getName());
260 if (!ExpectedSession) {
261 consumeError(ExpectedSession.takeError());
262 StringRef LocalPath =
263 !File->ParentName.empty() ? File->ParentName : File->getName();
264 SmallString<128> Path = sys::path::parent_path(LocalPath);
Reid Klecknerf8522d82017-07-18 00:33:53 +0000265 sys::path::append(
266 Path, sys::path::filename(TS.getName(), sys::path::Style::windows));
Reid Kleckner651db912017-07-18 00:21:25 +0000267 ExpectedSession = tryToLoadPDB(TS.getGuid(), Path);
268 }
269 if (auto E = ExpectedSession.takeError())
270 fatal(E, "Type server PDB was not found");
271
272 // Merge TPI first, because the IPI stream will reference type indices.
273 auto ExpectedTpi = (*ExpectedSession)->getPDBFile().getPDBTpiStream();
274 if (auto E = ExpectedTpi.takeError())
275 fatal(E, "Type server does not have TPI stream");
276 if (auto Err = mergeTypeRecords(TypeTable, IndexMap.TPIMap,
277 ExpectedTpi->typeArray()))
278 fatal(Err, "codeview::mergeTypeRecords failed");
279
280 // Merge IPI.
281 auto ExpectedIpi = (*ExpectedSession)->getPDBFile().getPDBIpiStream();
282 if (auto E = ExpectedIpi.takeError())
283 fatal(E, "Type server does not have TPI stream");
284 if (auto Err = mergeIdRecords(IDTable, IndexMap.TPIMap, IndexMap.IPIMap,
285 ExpectedIpi->typeArray()))
286 fatal(Err, "codeview::mergeIdRecords failed");
287
288 return IndexMap;
Reid Kleckner44cdb102017-06-19 17:21:45 +0000289}
290
Reid Klecknerd0e6e242017-06-21 17:25:56 +0000291static bool remapTypeIndex(TypeIndex &TI, ArrayRef<TypeIndex> TypeIndexMap) {
292 if (TI.isSimple())
293 return true;
294 if (TI.toArrayIndex() >= TypeIndexMap.size())
295 return false;
296 TI = TypeIndexMap[TI.toArrayIndex()];
297 return true;
298}
299
Rui Ueyamae1b48e02017-07-26 23:05:24 +0000300static void remapTypesInSymbolRecord(ObjFile *File,
Reid Klecknerd0e6e242017-06-21 17:25:56 +0000301 MutableArrayRef<uint8_t> Contents,
Reid Kleckner651db912017-07-18 00:21:25 +0000302 const CVIndexMap &IndexMap,
Zachary Turner59e3ae82017-08-08 18:34:44 +0000303 const TypeTableBuilder &IDTable,
Reid Klecknerd0e6e242017-06-21 17:25:56 +0000304 ArrayRef<TiReference> TypeRefs) {
305 for (const TiReference &Ref : TypeRefs) {
306 unsigned ByteSize = Ref.Count * sizeof(TypeIndex);
Reid Kleckner03b5baf2017-07-12 18:49:43 +0000307 if (Contents.size() < Ref.Offset + ByteSize)
308 fatal("symbol record too short");
Reid Kleckner651db912017-07-18 00:21:25 +0000309
310 // This can be an item index or a type index. Choose the appropriate map.
311 ArrayRef<TypeIndex> TypeOrItemMap = IndexMap.TPIMap;
312 if (Ref.Kind == TiRefKind::IndexRef && IndexMap.IsTypeServerMap)
313 TypeOrItemMap = IndexMap.IPIMap;
314
Reid Klecknerd0e6e242017-06-21 17:25:56 +0000315 MutableArrayRef<TypeIndex> TIs(
316 reinterpret_cast<TypeIndex *>(Contents.data() + Ref.Offset), Ref.Count);
Reid Kleckner03b5baf2017-07-12 18:49:43 +0000317 for (TypeIndex &TI : TIs) {
Reid Kleckner651db912017-07-18 00:21:25 +0000318 if (!remapTypeIndex(TI, TypeOrItemMap)) {
Reid Kleckner03b5baf2017-07-12 18:49:43 +0000319 TI = TypeIndex(SimpleTypeKind::NotTranslated);
Reid Klecknerd0e6e242017-06-21 17:25:56 +0000320 log("ignoring symbol record in " + File->getName() +
321 " with bad type index 0x" + utohexstr(TI.getIndex()));
Reid Kleckner03b5baf2017-07-12 18:49:43 +0000322 continue;
Reid Klecknerd0e6e242017-06-21 17:25:56 +0000323 }
Reid Kleckner03b5baf2017-07-12 18:49:43 +0000324 }
Reid Klecknerd0e6e242017-06-21 17:25:56 +0000325 }
Reid Klecknerd0e6e242017-06-21 17:25:56 +0000326}
327
Zachary Turner59e3ae82017-08-08 18:34:44 +0000328static SymbolKind symbolKind(ArrayRef<uint8_t> RecordData) {
329 const RecordPrefix *Prefix =
330 reinterpret_cast<const RecordPrefix *>(RecordData.data());
331 return static_cast<SymbolKind>(uint16_t(Prefix->RecordKind));
332}
333
334/// MSVC translates S_PROC_ID_END to S_END, and S_[LG]PROC32_ID to S_[LG]PROC32
335static void translateIdSymbols(MutableArrayRef<uint8_t> &RecordData,
336 const TypeTableBuilder &IDTable) {
337 RecordPrefix *Prefix = reinterpret_cast<RecordPrefix *>(RecordData.data());
338
339 SymbolKind Kind = symbolKind(RecordData);
340
341 if (Kind == SymbolKind::S_PROC_ID_END) {
342 Prefix->RecordKind = SymbolKind::S_END;
343 return;
344 }
345
346 // In an object file, GPROC32_ID has an embedded reference which refers to the
347 // single object file type index namespace. This has already been translated
348 // to the PDB file's ID stream index space, but we need to convert this to a
349 // symbol that refers to the type stream index space. So we remap again from
350 // ID index space to type index space.
351 if (Kind == SymbolKind::S_GPROC32_ID || Kind == SymbolKind::S_LPROC32_ID) {
352 SmallVector<TiReference, 1> Refs;
353 auto Content = RecordData.drop_front(sizeof(RecordPrefix));
354 CVSymbol Sym(Kind, RecordData);
355 discoverTypeIndicesInSymbol(Sym, Refs);
356 assert(Refs.size() == 1);
357 assert(Refs.front().Count == 1);
358
359 TypeIndex *TI =
360 reinterpret_cast<TypeIndex *>(Content.data() + Refs[0].Offset);
361 // `TI` is the index of a FuncIdRecord or MemberFuncIdRecord which lives in
362 // the IPI stream, whose `FunctionType` member refers to the TPI stream.
363 // Note that LF_FUNC_ID and LF_MEMFUNC_ID have the same record layout, and
364 // in both cases we just need the second type index.
365 if (!TI->isSimple() && !TI->isNoneType()) {
366 ArrayRef<uint8_t> FuncIdData = IDTable.records()[TI->toArrayIndex()];
367 SmallVector<TypeIndex, 2> Indices;
368 discoverTypeIndices(FuncIdData, Indices);
369 assert(Indices.size() == 2);
370 *TI = Indices[1];
371 }
372
373 Kind = (Kind == SymbolKind::S_GPROC32_ID) ? SymbolKind::S_GPROC32
374 : SymbolKind::S_LPROC32;
375 Prefix->RecordKind = uint16_t(Kind);
376 }
Reid Klecknerd0e6e242017-06-21 17:25:56 +0000377}
378
379/// Copy the symbol record. In a PDB, symbol records must be 4 byte aligned.
380/// The object file may not be aligned.
381static MutableArrayRef<uint8_t> copySymbolForPdb(const CVSymbol &Sym,
382 BumpPtrAllocator &Alloc) {
383 size_t Size = alignTo(Sym.length(), alignOf(CodeViewContainer::Pdb));
384 assert(Size >= 4 && "record too short");
385 assert(Size <= MaxRecordLength && "record too long");
386 void *Mem = Alloc.Allocate(Size, 4);
387
388 // Copy the symbol record and zero out any padding bytes.
389 MutableArrayRef<uint8_t> NewData(reinterpret_cast<uint8_t *>(Mem), Size);
390 memcpy(NewData.data(), Sym.data().data(), Sym.length());
391 memset(NewData.data() + Sym.length(), 0, Size - Sym.length());
392
393 // Update the record prefix length. It should point to the beginning of the
Zachary Turner59e3ae82017-08-08 18:34:44 +0000394 // next record.
Reid Klecknerd0e6e242017-06-21 17:25:56 +0000395 auto *Prefix = reinterpret_cast<RecordPrefix *>(Mem);
Reid Klecknerd0e6e242017-06-21 17:25:56 +0000396 Prefix->RecordLen = Size - 2;
397 return NewData;
398}
399
Reid Kleckner3f851922017-07-06 16:39:32 +0000400/// Return true if this symbol opens a scope. This implies that the symbol has
401/// "parent" and "end" fields, which contain the offset of the S_END or
402/// S_INLINESITE_END record.
403static bool symbolOpensScope(SymbolKind Kind) {
404 switch (Kind) {
405 case SymbolKind::S_GPROC32:
406 case SymbolKind::S_LPROC32:
407 case SymbolKind::S_LPROC32_ID:
408 case SymbolKind::S_GPROC32_ID:
409 case SymbolKind::S_BLOCK32:
410 case SymbolKind::S_SEPCODE:
411 case SymbolKind::S_THUNK32:
412 case SymbolKind::S_INLINESITE:
413 case SymbolKind::S_INLINESITE2:
414 return true;
415 default:
416 break;
417 }
418 return false;
419}
420
421static bool symbolEndsScope(SymbolKind Kind) {
422 switch (Kind) {
423 case SymbolKind::S_END:
424 case SymbolKind::S_PROC_ID_END:
425 case SymbolKind::S_INLINESITE_END:
426 return true;
427 default:
428 break;
429 }
430 return false;
431}
432
433struct ScopeRecord {
434 ulittle32_t PtrParent;
435 ulittle32_t PtrEnd;
436};
437
438struct SymbolScope {
439 ScopeRecord *OpeningRecord;
440 uint32_t ScopeOffset;
441};
442
443static void scopeStackOpen(SmallVectorImpl<SymbolScope> &Stack,
444 uint32_t CurOffset, CVSymbol &Sym) {
445 assert(symbolOpensScope(Sym.kind()));
446 SymbolScope S;
447 S.ScopeOffset = CurOffset;
448 S.OpeningRecord = const_cast<ScopeRecord *>(
449 reinterpret_cast<const ScopeRecord *>(Sym.content().data()));
450 S.OpeningRecord->PtrParent = Stack.empty() ? 0 : Stack.back().ScopeOffset;
451 Stack.push_back(S);
452}
453
454static void scopeStackClose(SmallVectorImpl<SymbolScope> &Stack,
Rui Ueyamae1b48e02017-07-26 23:05:24 +0000455 uint32_t CurOffset, ObjFile *File) {
Reid Kleckner3f851922017-07-06 16:39:32 +0000456 if (Stack.empty()) {
457 warn("symbol scopes are not balanced in " + File->getName());
458 return;
459 }
460 SymbolScope S = Stack.pop_back_val();
461 S.OpeningRecord->PtrEnd = CurOffset;
462}
463
Zachary Turneree9906d2017-08-11 19:00:03 +0000464static bool symbolGoesInModuleStream(const CVSymbol &Sym) {
465 switch (Sym.kind()) {
466 case SymbolKind::S_GDATA32:
467 case SymbolKind::S_CONSTANT:
468 case SymbolKind::S_UDT:
469 // We really should not be seeing S_PROCREF and S_LPROCREF in the first place
470 // since they are synthesized by the linker in response to S_GPROC32 and
471 // S_LPROC32, but if we do see them, don't put them in the module stream I
472 // guess.
473 case SymbolKind::S_PROCREF:
474 case SymbolKind::S_LPROCREF:
475 return false;
476 // S_GDATA32 does not go in the module stream, but S_LDATA32 does.
477 case SymbolKind::S_LDATA32:
478 default:
479 return true;
480 }
481}
482
483static bool symbolGoesInGlobalsStream(const CVSymbol &Sym) {
484 switch (Sym.kind()) {
485 case SymbolKind::S_CONSTANT:
486 case SymbolKind::S_UDT:
487 case SymbolKind::S_GDATA32:
488 // S_LDATA32 goes in both the module stream and the globals stream.
489 case SymbolKind::S_LDATA32:
490 case SymbolKind::S_GPROC32:
491 case SymbolKind::S_LPROC32:
492 // We really should not be seeing S_PROCREF and S_LPROCREF in the first place
493 // since they are synthesized by the linker in response to S_GPROC32 and
494 // S_LPROC32, but if we do see them, copy them straight through.
495 case SymbolKind::S_PROCREF:
496 case SymbolKind::S_LPROCREF:
497 return true;
498 default:
499 return false;
500 }
501}
502
503static void addGlobalSymbol(pdb::GSIStreamBuilder &Builder, ObjFile &File,
504 const CVSymbol &Sym) {
505 switch (Sym.kind()) {
506 case SymbolKind::S_CONSTANT:
507 case SymbolKind::S_UDT:
508 case SymbolKind::S_GDATA32:
509 case SymbolKind::S_LDATA32:
510 case SymbolKind::S_PROCREF:
511 case SymbolKind::S_LPROCREF:
512 Builder.addGlobalSymbol(Sym);
513 break;
514 case SymbolKind::S_GPROC32:
515 case SymbolKind::S_LPROC32: {
516 SymbolRecordKind K = SymbolRecordKind::ProcRefSym;
517 if (Sym.kind() == SymbolKind::S_LPROC32)
518 K = SymbolRecordKind::LocalProcRef;
519 ProcRefSym PS(K);
520 PS.Module = static_cast<uint16_t>(File.ModuleDBI->getModuleIndex());
521 // For some reason, MSVC seems to add one to this value.
522 ++PS.Module;
523 PS.Name = getSymbolName(Sym);
524 PS.SumName = 0;
525 PS.SymOffset = File.ModuleDBI->getNextSymbolOffset();
526 Builder.addGlobalSymbol(PS);
527 break;
528 }
529 default:
530 llvm_unreachable("Invalid symbol kind!");
531 }
532}
533
Rui Ueyamae1b48e02017-07-26 23:05:24 +0000534static void mergeSymbolRecords(BumpPtrAllocator &Alloc, ObjFile *File,
Zachary Turneree9906d2017-08-11 19:00:03 +0000535 pdb::GSIStreamBuilder &GsiBuilder,
Reid Kleckner651db912017-07-18 00:21:25 +0000536 const CVIndexMap &IndexMap,
Zachary Turner59e3ae82017-08-08 18:34:44 +0000537 const TypeTableBuilder &IDTable,
Reid Klecknerd0e6e242017-06-21 17:25:56 +0000538 BinaryStreamRef SymData) {
539 // FIXME: Improve error recovery by warning and skipping records when
540 // possible.
541 CVSymbolArray Syms;
542 BinaryStreamReader Reader(SymData);
543 ExitOnErr(Reader.readArray(Syms, Reader.getLength()));
Reid Kleckner3f851922017-07-06 16:39:32 +0000544 SmallVector<SymbolScope, 4> Scopes;
Zachary Turner59e3ae82017-08-08 18:34:44 +0000545 for (CVSymbol Sym : Syms) {
Reid Klecknerd0e6e242017-06-21 17:25:56 +0000546 // Discover type index references in the record. Skip it if we don't know
547 // where they are.
548 SmallVector<TiReference, 32> TypeRefs;
Zachary Turner59e3ae82017-08-08 18:34:44 +0000549 if (!discoverTypeIndicesInSymbol(Sym, TypeRefs)) {
Reid Klecknerd0e6e242017-06-21 17:25:56 +0000550 log("ignoring unknown symbol record with kind 0x" + utohexstr(Sym.kind()));
551 continue;
552 }
553
554 // Copy the symbol record so we can mutate it.
555 MutableArrayRef<uint8_t> NewData = copySymbolForPdb(Sym, Alloc);
556
557 // Re-map all the type index references.
558 MutableArrayRef<uint8_t> Contents =
559 NewData.drop_front(sizeof(RecordPrefix));
Zachary Turner59e3ae82017-08-08 18:34:44 +0000560 remapTypesInSymbolRecord(File, Contents, IndexMap, IDTable, TypeRefs);
561
562 // An object file may have S_xxx_ID symbols, but these get converted to
563 // "real" symbols in a PDB.
564 translateIdSymbols(NewData, IDTable);
565
566 SymbolKind NewKind = symbolKind(NewData);
Reid Klecknerd0e6e242017-06-21 17:25:56 +0000567
Reid Kleckner3f851922017-07-06 16:39:32 +0000568 // Fill in "Parent" and "End" fields by maintaining a stack of scopes.
Zachary Turner59e3ae82017-08-08 18:34:44 +0000569 CVSymbol NewSym(NewKind, NewData);
570 if (symbolOpensScope(NewKind))
Reid Kleckner3f851922017-07-06 16:39:32 +0000571 scopeStackOpen(Scopes, File->ModuleDBI->getNextSymbolOffset(), NewSym);
Zachary Turner59e3ae82017-08-08 18:34:44 +0000572 else if (symbolEndsScope(NewKind))
Reid Kleckner3f851922017-07-06 16:39:32 +0000573 scopeStackClose(Scopes, File->ModuleDBI->getNextSymbolOffset(), File);
Reid Klecknerd0e6e242017-06-21 17:25:56 +0000574
Zachary Turneree9906d2017-08-11 19:00:03 +0000575 // Add the symbol to the globals stream if necessary. Do this before adding
576 // the symbol to the module since we may need to get the next symbol offset,
577 // and writing to the module's symbol stream will update that offset.
578 if (symbolGoesInGlobalsStream(NewSym))
579 addGlobalSymbol(GsiBuilder, *File, NewSym);
580
Reid Klecknerd0e6e242017-06-21 17:25:56 +0000581 // Add the symbol to the module.
Zachary Turneree9906d2017-08-11 19:00:03 +0000582 if (symbolGoesInModuleStream(NewSym))
583 File->ModuleDBI->addSymbol(NewSym);
Reid Klecknerd0e6e242017-06-21 17:25:56 +0000584 }
585}
586
Reid Kleckner44cdb102017-06-19 17:21:45 +0000587// Allocate memory for a .debug$S section and relocate it.
588static ArrayRef<uint8_t> relocateDebugChunk(BumpPtrAllocator &Alloc,
589 SectionChunk *DebugChunk) {
590 uint8_t *Buffer = Alloc.Allocate<uint8_t>(DebugChunk->getSize());
591 assert(DebugChunk->OutputSectionOff == 0 &&
592 "debug sections should not be in output sections");
593 DebugChunk->writeTo(Buffer);
594 return consumeDebugMagic(makeArrayRef(Buffer, DebugChunk->getSize()),
595 ".debug$S");
596}
597
Rui Ueyamae1b48e02017-07-26 23:05:24 +0000598void PDBLinker::addObjFile(ObjFile *File) {
Reid Kleckner0faf6d72017-07-14 00:14:58 +0000599 // Add a module descriptor for every object file. We need to put an absolute
600 // path to the object into the PDB. If this is a plain object, we make its
601 // path absolute. If it's an object in an archive, we make the archive path
602 // absolute.
603 bool InArchive = !File->ParentName.empty();
604 SmallString<128> Path = InArchive ? File->ParentName : File->getName();
605 sys::fs::make_absolute(Path);
606 sys::path::native(Path, sys::path::Style::windows);
607 StringRef Name = InArchive ? File->getName() : StringRef(Path);
Zachary Turner2897e032017-05-25 21:16:03 +0000608
Reid Kleckner0faf6d72017-07-14 00:14:58 +0000609 File->ModuleDBI = &ExitOnErr(Builder.getDbiBuilder().addModuleInfo(Name));
610 File->ModuleDBI->setObjFileName(Path);
Reid Kleckner44cdb102017-06-19 17:21:45 +0000611
Reid Kleckner0faf6d72017-07-14 00:14:58 +0000612 // Before we can process symbol substreams from .debug$S, we need to process
613 // type information, file checksums, and the string table. Add type info to
614 // the PDB first, so that we can get the map from object file type and item
615 // indices to PDB type and item indices.
Reid Kleckner651db912017-07-18 00:21:25 +0000616 CVIndexMap ObjectIndexMap;
617 const CVIndexMap &IndexMap = mergeDebugT(File, ObjectIndexMap);
Zachary Turner448dea42017-07-07 18:46:14 +0000618
Reid Kleckner0faf6d72017-07-14 00:14:58 +0000619 // Now do all live .debug$S sections.
620 for (SectionChunk *DebugChunk : File->getDebugChunks()) {
621 if (!DebugChunk->isLive() || DebugChunk->getSectionName() != ".debug$S")
622 continue;
Reid Kleckner8cbdd0c2017-06-13 15:49:13 +0000623
Reid Kleckner0faf6d72017-07-14 00:14:58 +0000624 ArrayRef<uint8_t> RelocatedDebugContents =
625 relocateDebugChunk(Alloc, DebugChunk);
626 if (RelocatedDebugContents.empty())
627 continue;
Reid Kleckner8cbdd0c2017-06-13 15:49:13 +0000628
Reid Kleckner0faf6d72017-07-14 00:14:58 +0000629 DebugSubsectionArray Subsections;
630 BinaryStreamReader Reader(RelocatedDebugContents, support::little);
631 ExitOnErr(Reader.readArray(Subsections, RelocatedDebugContents.size()));
Rui Ueyama52896622017-01-12 03:09:25 +0000632
Reid Kleckner0faf6d72017-07-14 00:14:58 +0000633 DebugStringTableSubsectionRef CVStrTab;
634 DebugChecksumsSubsectionRef Checksums;
635 for (const DebugSubsectionRecord &SS : Subsections) {
636 switch (SS.kind()) {
637 case DebugSubsectionKind::StringTable:
638 ExitOnErr(CVStrTab.initialize(SS.getRecordData()));
639 break;
640 case DebugSubsectionKind::FileChecksums:
641 ExitOnErr(Checksums.initialize(SS.getRecordData()));
642 break;
643 case DebugSubsectionKind::Lines:
644 // We can add the relocated line table directly to the PDB without
645 // modification because the file checksum offsets will stay the same.
646 File->ModuleDBI->addDebugSubsection(SS);
647 break;
648 case DebugSubsectionKind::Symbols:
Zachary Turneree9906d2017-08-11 19:00:03 +0000649 mergeSymbolRecords(Alloc, File, Builder.getGsiBuilder(), IndexMap,
650 IDTable, SS.getRecordData());
Reid Kleckner0faf6d72017-07-14 00:14:58 +0000651 break;
652 default:
653 // FIXME: Process the rest of the subsections.
654 break;
Reid Kleckner44cdb102017-06-19 17:21:45 +0000655 }
656 }
Rui Ueyama52896622017-01-12 03:09:25 +0000657
Reid Kleckner0faf6d72017-07-14 00:14:58 +0000658 if (Checksums.valid()) {
659 // Make a new file checksum table that refers to offsets in the PDB-wide
660 // string table. Generally the string table subsection appears after the
661 // checksum table, so we have to do this after looping over all the
662 // subsections.
663 if (!CVStrTab.valid())
664 fatal(".debug$S sections must have both a string table subsection "
665 "and a checksum subsection table or neither");
666 auto NewChecksums = make_unique<DebugChecksumsSubsection>(PDBStrTab);
667 for (FileChecksumEntry &FC : Checksums) {
668 StringRef FileName = ExitOnErr(CVStrTab.getString(FC.FileNameOffset));
669 ExitOnErr(Builder.getDbiBuilder().addModuleSourceFile(*File->ModuleDBI,
670 FileName));
671 NewChecksums->addChecksum(FileName, FC.Kind, FC.Checksum);
672 }
673 File->ModuleDBI->addDebugSubsection(std::move(NewChecksums));
674 }
675 }
676}
677
Reid Klecknereacdf042017-07-27 18:25:59 +0000678static PublicSym32 createPublic(Defined *Def) {
679 PublicSym32 Pub(SymbolKind::S_PUB32);
680 Pub.Name = Def->getName();
681 if (auto *D = dyn_cast<DefinedCOFF>(Def)) {
682 if (D->getCOFFSymbol().isFunctionDefinition())
683 Pub.Flags = PublicSymFlags::Function;
684 } else if (isa<DefinedImportThunk>(Def)) {
685 Pub.Flags = PublicSymFlags::Function;
686 }
687
688 OutputSection *OS = Def->getChunk()->getOutputSection();
689 assert(OS && "all publics should be in final image");
690 Pub.Offset = Def->getRVA() - OS->getRVA();
691 Pub.Segment = OS->SectionIndex;
692 return Pub;
693}
694
Reid Kleckner0faf6d72017-07-14 00:14:58 +0000695// Add all object files to the PDB. Merge .debug$T sections into IpiData and
696// TpiData.
697void PDBLinker::addObjectsToPDB() {
Rui Ueyamaacd632d2017-07-27 00:45:26 +0000698 for (ObjFile *File : ObjFile::Instances)
Rui Ueyamae1b48e02017-07-26 23:05:24 +0000699 addObjFile(File);
Reid Kleckner0faf6d72017-07-14 00:14:58 +0000700
701 Builder.getStringTableBuilder().setStrings(PDBStrTab);
Reid Kleckner44cdb102017-06-19 17:21:45 +0000702
Reid Kleckner5d577522017-03-24 17:26:38 +0000703 // Construct TPI stream contents.
Reid Kleckner13fc4112017-04-04 00:56:34 +0000704 addTypeInfo(Builder.getTpiBuilder(), TypeTable);
Reid Kleckner5d577522017-03-24 17:26:38 +0000705
706 // Construct IPI stream contents.
Reid Kleckner13fc4112017-04-04 00:56:34 +0000707 addTypeInfo(Builder.getIpiBuilder(), IDTable);
Reid Kleckner0faf6d72017-07-14 00:14:58 +0000708
Zachary Turneree9906d2017-08-11 19:00:03 +0000709 // Compute the public and global symbols.
710 auto &GsiBuilder = Builder.getGsiBuilder();
Reid Klecknereacdf042017-07-27 18:25:59 +0000711 std::vector<PublicSym32> Publics;
Zachary Turner964e0962017-08-11 20:37:49 +0000712 Symtab->forEachSymbol([&Publics](Symbol *S) {
Reid Klecknereacdf042017-07-27 18:25:59 +0000713 // Only emit defined, live symbols that have a chunk.
714 auto *Def = dyn_cast<Defined>(S->body());
715 if (Def && Def->isLive() && Def->getChunk())
716 Publics.push_back(createPublic(Def));
717 });
Reid Kleckner0faf6d72017-07-14 00:14:58 +0000718
Reid Klecknereacdf042017-07-27 18:25:59 +0000719 if (!Publics.empty()) {
720 // Sort the public symbols and add them to the stream.
721 std::sort(Publics.begin(), Publics.end(),
722 [](const PublicSym32 &L, const PublicSym32 &R) {
723 return L.Name < R.Name;
724 });
Reid Klecknereacdf042017-07-27 18:25:59 +0000725 for (const PublicSym32 &Pub : Publics)
Zachary Turner946204c2017-08-09 04:23:25 +0000726 GsiBuilder.addPublicSymbol(Pub);
Reid Klecknereacdf042017-07-27 18:25:59 +0000727 }
Rui Ueyama52896622017-01-12 03:09:25 +0000728}
729
Zachary Turner28e31ee2017-08-11 20:46:28 +0000730static void addCommonLinkerModuleSymbols(StringRef Path,
731 pdb::DbiModuleDescriptorBuilder &Mod,
732 BumpPtrAllocator &Allocator) {
733 SymbolSerializer Serializer(Allocator, CodeViewContainer::Pdb);
734 ObjNameSym ONS(SymbolRecordKind::ObjNameSym);
735 Compile3Sym CS(SymbolRecordKind::Compile3Sym);
736 EnvBlockSym EBS(SymbolRecordKind::EnvBlockSym);
Zachary Turner6708e0b2017-07-10 21:01:37 +0000737
738 ONS.Name = "* Linker *";
739 ONS.Signature = 0;
740
741 CS.Machine = Config->is64() ? CPUType::X64 : CPUType::Intel80386;
Zachary Turnerf6822c82017-08-11 20:46:47 +0000742 // Interestingly, if we set the string to 0.0.0.0, then when trying to view
743 // local variables WinDbg emits an error that private symbols are not present.
744 // By setting this to a valid MSVC linker version string, local variables are
745 // displayed properly. As such, even though it is not representative of
746 // LLVM's version information, we need this for compatibility.
Zachary Turner6708e0b2017-07-10 21:01:37 +0000747 CS.Flags = CompileSym3Flags::None;
Zachary Turnerf6822c82017-08-11 20:46:47 +0000748 CS.VersionBackendBuild = 25019;
749 CS.VersionBackendMajor = 14;
750 CS.VersionBackendMinor = 10;
Zachary Turner6708e0b2017-07-10 21:01:37 +0000751 CS.VersionBackendQFE = 0;
Zachary Turnerf6822c82017-08-11 20:46:47 +0000752
753 // MSVC also sets the frontend to 0.0.0.0 since this is specifically for the
754 // linker module (which is by definition a backend), so we don't need to do
755 // anything here. Also, it seems we can use "LLVM Linker" for the linker name
756 // without any problems. Only the backend version has to be hardcoded to a
757 // magic number.
Zachary Turner6708e0b2017-07-10 21:01:37 +0000758 CS.VersionFrontendBuild = 0;
759 CS.VersionFrontendMajor = 0;
760 CS.VersionFrontendMinor = 0;
761 CS.VersionFrontendQFE = 0;
762 CS.Version = "LLVM Linker";
763 CS.setLanguage(SourceLanguage::Link);
764
765 ArrayRef<StringRef> Args = makeArrayRef(Config->Argv).drop_front();
766 std::string ArgStr = llvm::join(Args, " ");
767 EBS.Fields.push_back("cwd");
768 SmallString<64> cwd;
Reid Kleckner0faf6d72017-07-14 00:14:58 +0000769 sys::fs::current_path(cwd);
Zachary Turner6708e0b2017-07-10 21:01:37 +0000770 EBS.Fields.push_back(cwd);
771 EBS.Fields.push_back("exe");
Zachary Turnerf6822c82017-08-11 20:46:47 +0000772 SmallString<64> exe = Config->Argv[0];
773 llvm::sys::fs::make_absolute(exe);
774 EBS.Fields.push_back(exe);
Zachary Turner6708e0b2017-07-10 21:01:37 +0000775 EBS.Fields.push_back("pdb");
776 EBS.Fields.push_back(Path);
777 EBS.Fields.push_back("cmd");
778 EBS.Fields.push_back(ArgStr);
779 Mod.addSymbol(codeview::SymbolSerializer::writeOneSymbol(
780 ONS, Allocator, CodeViewContainer::Pdb));
781 Mod.addSymbol(codeview::SymbolSerializer::writeOneSymbol(
782 CS, Allocator, CodeViewContainer::Pdb));
783 Mod.addSymbol(codeview::SymbolSerializer::writeOneSymbol(
784 EBS, Allocator, CodeViewContainer::Pdb));
785}
786
Zachary Turner28e31ee2017-08-11 20:46:28 +0000787static void addLinkerModuleSectionSymbol(pdb::DbiModuleDescriptorBuilder &Mod,
788 OutputSection &OS,
789 BumpPtrAllocator &Allocator) {
790 SectionSym Sym(SymbolRecordKind::SectionSym);
Zachary Turnerf6822c82017-08-11 20:46:47 +0000791 Sym.Alignment = 12; // 2^12 = 4KB
Zachary Turner28e31ee2017-08-11 20:46:28 +0000792 Sym.Characteristics = OS.getCharacteristics();
793 Sym.Length = OS.getVirtualSize();
794 Sym.Name = OS.getName();
795 Sym.Rva = OS.getRVA();
796 Sym.SectionNumber = OS.SectionIndex;
797 Mod.addSymbol(codeview::SymbolSerializer::writeOneSymbol(
798 Sym, Allocator, CodeViewContainer::Pdb));
799}
800
Rui Ueyama09e0b5f2016-11-12 00:00:51 +0000801// Creates a PDB file.
Reid Kleckner175af4b2017-08-03 21:15:09 +0000802void coff::createPDB(SymbolTable *Symtab,
803 ArrayRef<OutputSection *> OutputSections,
804 ArrayRef<uint8_t> SectionTable,
Saleem Abdulrasooldf8a13b2017-01-04 17:56:54 +0000805 const llvm::codeview::DebugInfo *DI) {
Reid Kleckner0faf6d72017-07-14 00:14:58 +0000806 PDBLinker PDB(Symtab);
807 PDB.initialize(DI);
808 PDB.addObjectsToPDB();
Reid Kleckner175af4b2017-08-03 21:15:09 +0000809 PDB.addSections(OutputSections, SectionTable);
Reid Kleckner0faf6d72017-07-14 00:14:58 +0000810 PDB.commit();
811}
812
813void PDBLinker::initialize(const llvm::codeview::DebugInfo *DI) {
Rui Ueyama12979542016-09-30 20:53:45 +0000814 ExitOnErr(Builder.initialize(4096)); // 4096 is blocksize
Rui Ueyama7f382992016-09-15 18:55:18 +0000815
Rui Ueyama8d3fb5d2016-10-05 22:08:58 +0000816 // Create streams in MSF for predefined streams, namely
817 // PDB, TPI, DBI and IPI.
818 for (int I = 0; I < (int)pdb::kSpecialStreamCount; ++I)
819 ExitOnErr(Builder.getMsfBuilder().addStream(0));
Rui Ueyama7f382992016-09-15 18:55:18 +0000820
Rui Ueyamabb542b32016-09-16 22:51:17 +0000821 // Add an Info stream.
822 auto &InfoBuilder = Builder.getInfoBuilder();
Saleem Abdulrasool0acd6dd2017-02-07 04:28:02 +0000823 InfoBuilder.setAge(DI ? DI->PDB70.Age : 0);
824
Reid Kleckner67653ee2017-07-17 23:59:44 +0000825 GUID uuid{};
Saleem Abdulrasool0acd6dd2017-02-07 04:28:02 +0000826 if (DI)
827 memcpy(&uuid, &DI->PDB70.Signature, sizeof(uuid));
828 InfoBuilder.setGuid(uuid);
Zachary Turner3a11fdf2017-07-07 20:25:39 +0000829 InfoBuilder.setSignature(time(nullptr));
Rui Ueyamabb542b32016-09-16 22:51:17 +0000830 InfoBuilder.setVersion(pdb::PdbRaw_ImplVer::PdbImplVC70);
Rui Ueyama7f382992016-09-15 18:55:18 +0000831
Zachary Turner6c4bfba2017-07-07 05:04:36 +0000832 // Add an empty DBI stream.
Reid Kleckner8cbdd0c2017-06-13 15:49:13 +0000833 pdb::DbiStreamBuilder &DbiBuilder = Builder.getDbiBuilder();
Zachary Turnerc1e93e52017-07-07 18:45:56 +0000834 DbiBuilder.setVersionHeader(pdb::PdbDbiV70);
Zachary Turner3a11fdf2017-07-07 20:25:39 +0000835 ExitOnErr(DbiBuilder.addDbgStream(pdb::DbgHeaderType::NewFPO, {}));
Reid Kleckner0faf6d72017-07-14 00:14:58 +0000836}
Rui Ueyama1343fac2016-10-06 22:52:01 +0000837
Reid Kleckner175af4b2017-08-03 21:15:09 +0000838void PDBLinker::addSectionContrib(pdb::DbiModuleDescriptorBuilder &LinkerModule,
839 OutputSection *OS, Chunk *C) {
840 pdb::SectionContrib SC;
841 memset(&SC, 0, sizeof(SC));
842 SC.ISect = OS->SectionIndex;
843 SC.Off = C->getRVA() - OS->getRVA();
844 SC.Size = C->getSize();
845 if (auto *SecChunk = dyn_cast<SectionChunk>(C)) {
846 SC.Characteristics = SecChunk->Header->Characteristics;
847 SC.Imod = SecChunk->File->ModuleDBI->getModuleIndex();
Zachary Turner676386ff2017-08-07 20:23:45 +0000848 ArrayRef<uint8_t> Contents = SecChunk->getContents();
849 JamCRC CRC(0);
850 ArrayRef<char> CharContents = makeArrayRef(
851 reinterpret_cast<const char *>(Contents.data()), Contents.size());
852 CRC.update(CharContents);
853 SC.DataCrc = CRC.getCRC();
Reid Kleckner175af4b2017-08-03 21:15:09 +0000854 } else {
855 SC.Characteristics = OS->getCharacteristics();
856 // FIXME: When we start creating DBI for import libraries, use those here.
857 SC.Imod = LinkerModule.getModuleIndex();
858 }
Reid Kleckner175af4b2017-08-03 21:15:09 +0000859 SC.RelocCrc = 0; // FIXME
860 Builder.getDbiBuilder().addSectionContrib(SC);
861}
Rui Ueyama09e0b5f2016-11-12 00:00:51 +0000862
Reid Kleckner175af4b2017-08-03 21:15:09 +0000863void PDBLinker::addSections(ArrayRef<OutputSection *> OutputSections,
864 ArrayRef<uint8_t> SectionTable) {
Reid Kleckner0faf6d72017-07-14 00:14:58 +0000865 // It's not entirely clear what this is, but the * Linker * module uses it.
Reid Kleckner175af4b2017-08-03 21:15:09 +0000866 pdb::DbiStreamBuilder &DbiBuilder = Builder.getDbiBuilder();
Reid Kleckner0faf6d72017-07-14 00:14:58 +0000867 NativePath = Config->PDBPath;
868 sys::fs::make_absolute(NativePath);
869 sys::path::native(NativePath, sys::path::Style::windows);
870 uint32_t PdbFilePathNI = DbiBuilder.addECName(NativePath);
Zachary Turner6c4bfba2017-07-07 05:04:36 +0000871 auto &LinkerModule = ExitOnErr(DbiBuilder.addModuleInfo("* Linker *"));
872 LinkerModule.setPdbFilePathNI(PdbFilePathNI);
Zachary Turner28e31ee2017-08-11 20:46:28 +0000873 addCommonLinkerModuleSymbols(NativePath, LinkerModule, Alloc);
Rui Ueyamac91f7162016-11-16 01:10:46 +0000874
Reid Kleckner175af4b2017-08-03 21:15:09 +0000875 // Add section contributions. They must be ordered by ascending RVA.
Zachary Turner28e31ee2017-08-11 20:46:28 +0000876 for (OutputSection *OS : OutputSections) {
877 addLinkerModuleSectionSymbol(LinkerModule, *OS, Alloc);
Reid Kleckner175af4b2017-08-03 21:15:09 +0000878 for (Chunk *C : OS->getChunks())
879 addSectionContrib(LinkerModule, OS, C);
Zachary Turner28e31ee2017-08-11 20:46:28 +0000880 }
Reid Kleckner175af4b2017-08-03 21:15:09 +0000881
882 // Add Section Map stream.
883 ArrayRef<object::coff_section> Sections = {
884 (const object::coff_section *)SectionTable.data(),
885 SectionTable.size() / sizeof(object::coff_section)};
886 SectionMap = pdb::DbiStreamBuilder::createSectionMap(Sections);
887 DbiBuilder.setSectionMap(SectionMap);
888
Rui Ueyama9f66f822016-10-11 19:45:07 +0000889 // Add COFF section header stream.
890 ExitOnErr(
891 DbiBuilder.addDbgStream(pdb::DbgHeaderType::SectionHdr, SectionTable));
Reid Kleckner0faf6d72017-07-14 00:14:58 +0000892}
Rui Ueyama9f66f822016-10-11 19:45:07 +0000893
Reid Kleckner0faf6d72017-07-14 00:14:58 +0000894void PDBLinker::commit() {
Rui Ueyama3e9d6bb2016-09-26 23:53:55 +0000895 // Write to a file.
Zachary Turner6708e0b2017-07-10 21:01:37 +0000896 ExitOnErr(Builder.commit(Config->PDBPath));
Rui Ueyamae7378242015-12-04 23:11:05 +0000897}