2015-12-05 07:11:05 +08:00
|
|
|
//===- PDB.cpp ------------------------------------------------------------===//
|
|
|
|
//
|
2019-01-19 16:50:56 +08:00
|
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
2015-12-05 07:11:05 +08:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2016-09-16 06:24:51 +08:00
|
|
|
#include "PDB.h"
|
2016-11-12 08:00:51 +08:00
|
|
|
#include "Chunks.h"
|
2016-11-22 01:22:35 +08:00
|
|
|
#include "Config.h"
|
[LLD][COFF] Early dependency detection
We introduce a new class hierarchy for debug types merging (in DebugTypes.h). The end-goal is to parallelize the type merging - please see the plan in D59226.
Previously, dependency discovery was done on the fly, much later, during the type merging loop. Unfortunately, parallelizing the type merging requires the dependencies to be merged in first, before any dependent ObjFile, thus this early discovery.
The overall intention for this path is to discover debug information dependencies at a much earlier stage, when processing input files. Currently, two types of dependency are supported: PDB type servers (when compiling with MSVC /Zi) and precompiled headers OBJs (when compiling with MSVC /Yc and /Yu). Once discovered, an explicit link is added into the dependent ObjFile, through the new debug types class hierarchy introduced in DebugTypes.h.
Differential Revision: https://reviews.llvm.org/D59053
llvm-svn: 357383
2019-04-01 21:36:59 +08:00
|
|
|
#include "DebugTypes.h"
|
2017-10-21 03:48:26 +08:00
|
|
|
#include "Driver.h"
|
2016-11-12 08:00:51 +08:00
|
|
|
#include "SymbolTable.h"
|
|
|
|
#include "Symbols.h"
|
2019-04-03 04:43:19 +08:00
|
|
|
#include "TypeMerger.h"
|
2017-07-28 02:25:59 +08:00
|
|
|
#include "Writer.h"
|
[lld] unified COFF and ELF error handling on new Common/ErrorHandler
Summary:
The COFF linker and the ELF linker have long had similar but separate
Error.h and Error.cpp files to implement error handling. This change
introduces new error handling code in Common/ErrorHandler.h, changes the
COFF and ELF linkers to use it, and removes the old, separate
implementations.
Reviewers: ruiu
Reviewed By: ruiu
Subscribers: smeenai, jyknight, emaste, sdardis, nemanjai, nhaehnle, mgorny, javed.absar, kbarton, fedor.sergeev, llvm-commits
Differential Revision: https://reviews.llvm.org/D39259
llvm-svn: 316624
2017-10-26 06:28:38 +08:00
|
|
|
#include "lld/Common/ErrorHandler.h"
|
2018-01-18 03:16:26 +08:00
|
|
|
#include "lld/Common/Timer.h"
|
2019-02-28 04:53:50 +08:00
|
|
|
#include "lld/Common/Threads.h"
|
2018-09-12 06:35:01 +08:00
|
|
|
#include "llvm/DebugInfo/CodeView/DebugFrameDataSubsection.h"
|
2017-06-20 01:21:45 +08:00
|
|
|
#include "llvm/DebugInfo/CodeView/DebugSubsectionRecord.h"
|
2017-12-15 02:07:04 +08:00
|
|
|
#include "llvm/DebugInfo/CodeView/GlobalTypeTableBuilder.h"
|
2017-05-20 03:26:58 +08:00
|
|
|
#include "llvm/DebugInfo/CodeView/LazyRandomTypeCollection.h"
|
2017-12-01 02:39:50 +08:00
|
|
|
#include "llvm/DebugInfo/CodeView/MergingTypeTableBuilder.h"
|
2017-08-12 03:00:03 +08:00
|
|
|
#include "llvm/DebugInfo/CodeView/RecordName.h"
|
2017-08-09 02:34:44 +08:00
|
|
|
#include "llvm/DebugInfo/CodeView/SymbolDeserializer.h"
|
2018-12-07 01:49:15 +08:00
|
|
|
#include "llvm/DebugInfo/CodeView/SymbolRecordHelpers.h"
|
2017-07-11 05:01:37 +08:00
|
|
|
#include "llvm/DebugInfo/CodeView/SymbolSerializer.h"
|
2017-07-18 08:21:25 +08:00
|
|
|
#include "llvm/DebugInfo/CodeView/TypeDeserializer.h"
|
[CodeView] Finish decoupling TypeDatabase from TypeDumper.
Previously the type dumper itself was passed around to a lot of different
places and manipulated in ways that were more appropriate on the type
database. For example, the entire TypeDumper was passed into the symbol
dumper, when all the symbol dumper wanted to do was lookup the name of a
TypeIndex so it could print it. That's what the TypeDatabase is for --
mapping type indices to names.
Another example is how if the user runs llvm-pdbdump with the option to
dump symbols but not types, we still have to visit all types so that we
can print minimal information about the type of a symbol, but just without
dumping full symbol records. The way we did this before is by hacking it
up so that we run everything through the type dumper with a null printer,
so that the output goes to /dev/null. But really, we don't need to dump
anything, all we want to do is build the type database. Since
TypeDatabaseVisitor now exists independently of TypeDumper, we can do
this. We just build a custom visitor callback pipeline that includes a
database visitor but not a dumper.
All the hackery around printers etc goes away. After this patch, we could
probably even delete the entire CVTypeDumper class since really all it is
at this point is a thin wrapper that hides the details of how to build a
useful visitation pipeline. It's not a priority though, so CVTypeDumper
remains for now.
After this patch we will be able to easily plug in a different style of
type dumper by only implementing the proper visitation methods to dump
one-line output and then sticking it on the pipeline.
Differential Revision: https://reviews.llvm.org/D28524
llvm-svn: 291724
2017-01-12 07:24:22 +08:00
|
|
|
#include "llvm/DebugInfo/CodeView/TypeDumpVisitor.h"
|
2017-06-22 01:25:56 +08:00
|
|
|
#include "llvm/DebugInfo/CodeView/TypeIndexDiscovery.h"
|
2017-01-12 11:09:25 +08:00
|
|
|
#include "llvm/DebugInfo/CodeView/TypeStreamMerger.h"
|
2016-09-16 12:32:33 +08:00
|
|
|
#include "llvm/DebugInfo/MSF/MSFBuilder.h"
|
2016-09-16 02:55:18 +08:00
|
|
|
#include "llvm/DebugInfo/MSF/MSFCommon.h"
|
2017-07-18 08:21:25 +08:00
|
|
|
#include "llvm/DebugInfo/PDB/GenericError.h"
|
2017-07-11 05:01:37 +08:00
|
|
|
#include "llvm/DebugInfo/PDB/Native/DbiModuleDescriptorBuilder.h"
|
2017-01-26 06:38:55 +08:00
|
|
|
#include "llvm/DebugInfo/PDB/Native/DbiStream.h"
|
|
|
|
#include "llvm/DebugInfo/PDB/Native/DbiStreamBuilder.h"
|
2017-08-09 12:23:25 +08:00
|
|
|
#include "llvm/DebugInfo/PDB/Native/GSIStreamBuilder.h"
|
2017-01-26 06:38:55 +08:00
|
|
|
#include "llvm/DebugInfo/PDB/Native/InfoStream.h"
|
|
|
|
#include "llvm/DebugInfo/PDB/Native/InfoStreamBuilder.h"
|
2017-07-18 08:21:25 +08:00
|
|
|
#include "llvm/DebugInfo/PDB/Native/NativeSession.h"
|
2017-01-26 06:38:55 +08:00
|
|
|
#include "llvm/DebugInfo/PDB/Native/PDBFile.h"
|
|
|
|
#include "llvm/DebugInfo/PDB/Native/PDBFileBuilder.h"
|
2017-05-03 04:19:42 +08:00
|
|
|
#include "llvm/DebugInfo/PDB/Native/PDBStringTableBuilder.h"
|
2017-07-20 01:26:07 +08:00
|
|
|
#include "llvm/DebugInfo/PDB/Native/TpiHashing.h"
|
2017-01-26 06:38:55 +08:00
|
|
|
#include "llvm/DebugInfo/PDB/Native/TpiStream.h"
|
|
|
|
#include "llvm/DebugInfo/PDB/Native/TpiStreamBuilder.h"
|
2017-07-18 08:21:25 +08:00
|
|
|
#include "llvm/DebugInfo/PDB/PDB.h"
|
2016-11-01 05:09:21 +08:00
|
|
|
#include "llvm/Object/COFF.h"
|
2018-03-27 07:43:29 +08:00
|
|
|
#include "llvm/Object/CVDebugRecord.h"
|
2017-03-03 04:52:51 +08:00
|
|
|
#include "llvm/Support/BinaryByteStream.h"
|
2015-12-09 02:39:55 +08:00
|
|
|
#include "llvm/Support/Endian.h"
|
2018-11-06 03:20:47 +08:00
|
|
|
#include "llvm/Support/Errc.h"
|
2018-01-06 03:12:40 +08:00
|
|
|
#include "llvm/Support/FormatVariadic.h"
|
2017-08-08 04:23:45 +08:00
|
|
|
#include "llvm/Support/JamCRC.h"
|
2017-02-17 07:35:45 +08:00
|
|
|
#include "llvm/Support/Path.h"
|
2016-11-22 01:22:35 +08:00
|
|
|
#include "llvm/Support/ScopedPrinter.h"
|
2015-12-05 07:11:05 +08:00
|
|
|
#include <memory>
|
|
|
|
|
2016-09-16 06:24:51 +08:00
|
|
|
using namespace lld;
|
2016-11-12 08:00:51 +08:00
|
|
|
using namespace lld::coff;
|
2015-12-05 07:11:05 +08:00
|
|
|
using namespace llvm;
|
2016-11-22 01:22:35 +08:00
|
|
|
using namespace llvm::codeview;
|
2015-12-05 07:11:05 +08:00
|
|
|
|
2016-11-12 08:00:51 +08:00
|
|
|
using llvm::object::coff_section;
|
|
|
|
|
2016-09-16 12:32:33 +08:00
|
|
|
static ExitOnError exitOnErr;
|
|
|
|
|
2018-01-18 03:16:26 +08:00
|
|
|
static Timer totalPdbLinkTimer("PDB Emission (Cumulative)", Timer::root());
|
|
|
|
|
|
|
|
static Timer addObjectsTimer("Add Objects", totalPdbLinkTimer);
|
|
|
|
static Timer typeMergingTimer("Type Merging", addObjectsTimer);
|
|
|
|
static Timer symbolMergingTimer("Symbol Merging", addObjectsTimer);
|
|
|
|
static Timer globalsLayoutTimer("Globals Stream Layout", totalPdbLinkTimer);
|
|
|
|
static Timer tpiStreamLayoutTimer("TPI Stream Layout", totalPdbLinkTimer);
|
|
|
|
static Timer diskCommitTimer("Commit to Disk", totalPdbLinkTimer);
|
|
|
|
|
2017-07-14 08:14:58 +08:00
|
|
|
namespace {
|
2018-09-13 05:02:01 +08:00
|
|
|
class DebugSHandler;
|
|
|
|
|
2017-07-14 08:14:58 +08:00
|
|
|
class PDBLinker {
|
2018-09-13 05:02:01 +08:00
|
|
|
friend DebugSHandler;
|
|
|
|
|
2017-07-14 08:14:58 +08:00
|
|
|
public:
|
|
|
|
PDBLinker(SymbolTable *symtab)
|
2019-04-03 04:43:19 +08:00
|
|
|
: alloc(), symtab(symtab), builder(alloc), tMerger(alloc) {
|
2018-03-24 02:43:39 +08:00
|
|
|
// This isn't strictly necessary, but link.exe usually puts an empty string
|
|
|
|
// as the first "valid" string in the string table, so we do the same in
|
|
|
|
// order to maintain as much byte-for-byte compatibility as possible.
|
|
|
|
pdbStrTab.insert("");
|
|
|
|
}
|
2017-07-14 08:14:58 +08:00
|
|
|
|
|
|
|
/// Emit the basic PDB structure: initial streams, headers, etc.
|
2018-09-16 02:37:22 +08:00
|
|
|
void initialize(llvm::codeview::DebugInfo *buildId);
|
2017-07-14 08:14:58 +08:00
|
|
|
|
2018-03-24 03:57:25 +08:00
|
|
|
/// Add natvis files specified on the command line.
|
|
|
|
void addNatvisFiles();
|
|
|
|
|
2017-07-14 08:14:58 +08:00
|
|
|
/// Link CodeView from each object file in the symbol table into the PDB.
|
|
|
|
void addObjectsToPDB();
|
|
|
|
|
2019-03-30 04:25:34 +08:00
|
|
|
/// Link info for each import file in the symbol table into the PDB.
|
|
|
|
void addImportFilesToPDB(ArrayRef<OutputSection *> outputSections);
|
|
|
|
|
2018-11-06 03:20:47 +08:00
|
|
|
/// Link CodeView from a single object file into the target (output) PDB.
|
|
|
|
/// When a precompiled headers object is linked, its TPI map might be provided
|
|
|
|
/// externally.
|
|
|
|
void addObjFile(ObjFile *file, CVIndexMap *externIndexMap = nullptr);
|
2017-07-14 08:14:58 +08:00
|
|
|
|
2017-07-18 08:21:25 +08:00
|
|
|
/// Produce a mapping from the type and item indices used in the object
|
|
|
|
/// file to those in the destination PDB.
|
|
|
|
///
|
|
|
|
/// If the object file uses a type server PDB (compiled with /Zi), merge TPI
|
|
|
|
/// and IPI from the type server PDB and return a map for it. Each unique type
|
|
|
|
/// server PDB is merged at most once, so this may return an existing index
|
|
|
|
/// mapping.
|
|
|
|
///
|
|
|
|
/// If the object does not use a type server PDB (compiled with /Z7), we merge
|
|
|
|
/// all the type and item records from the .debug$S stream and fill in the
|
2019-07-16 16:26:38 +08:00
|
|
|
/// caller-provided objectIndexMap.
|
2018-11-06 03:20:47 +08:00
|
|
|
Expected<const CVIndexMap &> mergeDebugT(ObjFile *file,
|
|
|
|
CVIndexMap *objectIndexMap);
|
2017-07-18 08:21:25 +08:00
|
|
|
|
2018-11-06 03:20:47 +08:00
|
|
|
/// Reads and makes available a PDB.
|
[LLD][COFF] Early dependency detection
We introduce a new class hierarchy for debug types merging (in DebugTypes.h). The end-goal is to parallelize the type merging - please see the plan in D59226.
Previously, dependency discovery was done on the fly, much later, during the type merging loop. Unfortunately, parallelizing the type merging requires the dependencies to be merged in first, before any dependent ObjFile, thus this early discovery.
The overall intention for this path is to discover debug information dependencies at a much earlier stage, when processing input files. Currently, two types of dependency are supported: PDB type servers (when compiling with MSVC /Zi) and precompiled headers OBJs (when compiling with MSVC /Yc and /Yu). Once discovered, an explicit link is added into the dependent ObjFile, through the new debug types class hierarchy introduced in DebugTypes.h.
Differential Revision: https://reviews.llvm.org/D59053
llvm-svn: 357383
2019-04-01 21:36:59 +08:00
|
|
|
Expected<const CVIndexMap &> maybeMergeTypeServerPDB(ObjFile *file);
|
2018-11-06 03:20:47 +08:00
|
|
|
|
|
|
|
/// Merges a precompiled headers TPI map into the current TPI map. The
|
|
|
|
/// precompiled headers object will also be loaded and remapped in the
|
|
|
|
/// process.
|
[LLD][COFF] Early dependency detection
We introduce a new class hierarchy for debug types merging (in DebugTypes.h). The end-goal is to parallelize the type merging - please see the plan in D59226.
Previously, dependency discovery was done on the fly, much later, during the type merging loop. Unfortunately, parallelizing the type merging requires the dependencies to be merged in first, before any dependent ObjFile, thus this early discovery.
The overall intention for this path is to discover debug information dependencies at a much earlier stage, when processing input files. Currently, two types of dependency are supported: PDB type servers (when compiling with MSVC /Zi) and precompiled headers OBJs (when compiling with MSVC /Yc and /Yu). Once discovered, an explicit link is added into the dependent ObjFile, through the new debug types class hierarchy introduced in DebugTypes.h.
Differential Revision: https://reviews.llvm.org/D59053
llvm-svn: 357383
2019-04-01 21:36:59 +08:00
|
|
|
Error mergeInPrecompHeaderObj(ObjFile *file, CVIndexMap *objectIndexMap);
|
2018-11-06 03:20:47 +08:00
|
|
|
|
|
|
|
/// Reads and makes available a precompiled headers object.
|
|
|
|
///
|
|
|
|
/// This is a requirement for objects compiled with cl.exe /Yu. In that
|
|
|
|
/// case, the referenced object (which was compiled with /Yc) has to be loaded
|
|
|
|
/// first. This is mainly because the current object's TPI stream has external
|
|
|
|
/// references to the precompiled headers object.
|
|
|
|
///
|
|
|
|
/// If the precompiled headers object was already loaded, this function will
|
|
|
|
/// simply return its (remapped) TPI map.
|
[LLD][COFF] Early dependency detection
We introduce a new class hierarchy for debug types merging (in DebugTypes.h). The end-goal is to parallelize the type merging - please see the plan in D59226.
Previously, dependency discovery was done on the fly, much later, during the type merging loop. Unfortunately, parallelizing the type merging requires the dependencies to be merged in first, before any dependent ObjFile, thus this early discovery.
The overall intention for this path is to discover debug information dependencies at a much earlier stage, when processing input files. Currently, two types of dependency are supported: PDB type servers (when compiling with MSVC /Zi) and precompiled headers OBJs (when compiling with MSVC /Yc and /Yu). Once discovered, an explicit link is added into the dependent ObjFile, through the new debug types class hierarchy introduced in DebugTypes.h.
Differential Revision: https://reviews.llvm.org/D59053
llvm-svn: 357383
2019-04-01 21:36:59 +08:00
|
|
|
Expected<const CVIndexMap &> aquirePrecompObj(ObjFile *file);
|
2018-11-06 03:20:47 +08:00
|
|
|
|
|
|
|
/// Adds a precompiled headers object signature -> TPI mapping.
|
|
|
|
std::pair<CVIndexMap &, bool /*already there*/>
|
|
|
|
registerPrecompiledHeaders(uint32_t signature);
|
2017-07-14 08:14:58 +08:00
|
|
|
|
2018-11-14 07:44:39 +08:00
|
|
|
void mergeSymbolRecords(ObjFile *file, const CVIndexMap &indexMap,
|
|
|
|
std::vector<ulittle32_t *> &stringTableRefs,
|
|
|
|
BinaryStreamRef symData);
|
|
|
|
|
2017-07-14 08:14:58 +08:00
|
|
|
/// Add the section map and section contributions to the PDB.
|
2017-08-04 05:15:09 +08:00
|
|
|
void addSections(ArrayRef<OutputSection *> outputSections,
|
|
|
|
ArrayRef<uint8_t> sectionTable);
|
|
|
|
|
2018-09-16 02:37:22 +08:00
|
|
|
/// Write the PDB to disk and store the Guid generated for it in *Guid.
|
|
|
|
void commit(codeview::GUID *guid);
|
2017-07-14 08:14:58 +08:00
|
|
|
|
2019-03-15 02:45:08 +08:00
|
|
|
// Print statistics regarding the final PDB
|
|
|
|
void printStats();
|
|
|
|
|
2017-07-14 08:14:58 +08:00
|
|
|
private:
|
|
|
|
BumpPtrAllocator alloc;
|
|
|
|
|
|
|
|
SymbolTable *symtab;
|
|
|
|
|
|
|
|
pdb::PDBFileBuilder builder;
|
|
|
|
|
2019-04-03 04:43:19 +08:00
|
|
|
TypeMerger tMerger;
|
2017-12-15 02:07:04 +08:00
|
|
|
|
2017-07-14 08:14:58 +08:00
|
|
|
/// PDBs use a single global string table for filenames in the file checksum
|
|
|
|
/// table.
|
|
|
|
DebugStringTableSubsection pdbStrTab;
|
|
|
|
|
|
|
|
llvm::SmallString<128> nativePath;
|
|
|
|
|
|
|
|
std::vector<pdb::SecMapEntry> sectionMap;
|
2017-07-18 08:21:25 +08:00
|
|
|
|
|
|
|
/// Type index mappings of type server PDBs that we've loaded so far.
|
2019-01-05 09:08:10 +08:00
|
|
|
std::map<codeview::GUID, CVIndexMap> typeServerIndexMappings;
|
2018-02-01 01:48:04 +08:00
|
|
|
|
2018-11-06 03:20:47 +08:00
|
|
|
/// Type index mappings of precompiled objects type map that we've loaded so
|
|
|
|
/// far.
|
|
|
|
std::map<uint32_t, CVIndexMap> precompTypeIndexMappings;
|
|
|
|
|
2019-03-15 02:45:08 +08:00
|
|
|
// For statistics
|
|
|
|
uint64_t globalSymbols = 0;
|
|
|
|
uint64_t moduleSymbols = 0;
|
|
|
|
uint64_t publicSymbols = 0;
|
2017-07-14 08:14:58 +08:00
|
|
|
};
|
2018-09-13 05:02:01 +08:00
|
|
|
|
|
|
|
class DebugSHandler {
|
|
|
|
PDBLinker &linker;
|
|
|
|
|
|
|
|
/// The object file whose .debug$S sections we're processing.
|
|
|
|
ObjFile &file;
|
|
|
|
|
|
|
|
/// The result of merging type indices.
|
|
|
|
const CVIndexMap &indexMap;
|
|
|
|
|
|
|
|
/// The DEBUG_S_STRINGTABLE subsection. These strings are referred to by
|
|
|
|
/// index from other records in the .debug$S section. All of these strings
|
|
|
|
/// need to be added to the global PDB string table, and all references to
|
|
|
|
/// these strings need to have their indices re-written to refer to the
|
|
|
|
/// global PDB string table.
|
|
|
|
DebugStringTableSubsectionRef cVStrTab;
|
|
|
|
|
|
|
|
/// The DEBUG_S_FILECHKSMS subsection. As above, these are referred to
|
|
|
|
/// by other records in the .debug$S section and need to be merged into the
|
|
|
|
/// PDB.
|
|
|
|
DebugChecksumsSubsectionRef checksums;
|
|
|
|
|
2019-06-04 02:15:38 +08:00
|
|
|
/// The DEBUG_S_INLINEELINES subsection. There can be only one of these per
|
|
|
|
/// object file.
|
|
|
|
DebugInlineeLinesSubsectionRef inlineeLines;
|
|
|
|
|
2018-09-13 05:02:01 +08:00
|
|
|
/// The DEBUG_S_FRAMEDATA subsection(s). There can be more than one of
|
|
|
|
/// these and they need not appear in any specific order. However, they
|
|
|
|
/// contain string table references which need to be re-written, so we
|
|
|
|
/// collect them all here and re-write them after all subsections have been
|
|
|
|
/// discovered and processed.
|
|
|
|
std::vector<DebugFrameDataSubsectionRef> newFpoFrames;
|
|
|
|
|
|
|
|
/// Pointers to raw memory that we determine have string table references
|
|
|
|
/// that need to be re-written. We first process all .debug$S subsections
|
|
|
|
/// to ensure that we can handle subsections written in any order, building
|
|
|
|
/// up this list as we go. At the end, we use the string table (which must
|
|
|
|
/// have been discovered by now else it is an error) to re-write these
|
|
|
|
/// references.
|
|
|
|
std::vector<ulittle32_t *> stringTableReferences;
|
|
|
|
|
|
|
|
public:
|
|
|
|
DebugSHandler(PDBLinker &linker, ObjFile &file, const CVIndexMap &indexMap)
|
|
|
|
: linker(linker), file(file), indexMap(indexMap) {}
|
|
|
|
|
|
|
|
void handleDebugS(lld::coff::SectionChunk &debugS);
|
2019-06-04 02:15:38 +08:00
|
|
|
|
|
|
|
std::shared_ptr<DebugInlineeLinesSubsection>
|
|
|
|
mergeInlineeLines(DebugChecksumsSubsection *newChecksums);
|
|
|
|
|
2018-09-13 05:02:01 +08:00
|
|
|
void finish();
|
|
|
|
};
|
2017-07-14 08:14:58 +08:00
|
|
|
}
|
|
|
|
|
lld-link: Use /pdbsourcepath: for more places when present.
/pdbsourcepath: was added in https://reviews.llvm.org/D48882 to make it
possible to have relative paths in the debug info that clang-cl writes.
lld-link then makes the paths absolute at link time, which debuggers require.
This way, clang-cl's output is independent of the absolute path of the build
directory, which is useful for cacheability in distcc-like systems.
This patch extends /pdbsourcepath: (if passed) to also be used for:
1. The "cwd" stored in the env block in the pdb is /pdbsourcepath: if present
2. The "exe" stored in the env block in the pdb is made absolute relative
to /pdbsourcepath: instead of the cwd
3. The "pdb" stored in the env block in the pdb is made absolute relative
to /pdbsourcepath: instead of the cwd
4. For making absolute paths to .obj files referenced from the pdb
/pdbsourcepath: is now useful in three scenarios (the first one already working
before this change):
1. When building with full debug info, passing the real build dir to
/pdbsourcepath: allows having clang-cl's output to be independent
of the build directory path. This patch effectively doesn't change
behavior for this use case (assuming the cwd is the build dir).
2. When building without compile-time debug info but linking with /debug,
a fake fixed /pdbsourcepath: can be passed to get symbolized stacks
while making the pdb and exe independent of the current build dir.
For this two work, lld-link needs to be invoked with relative paths for
the lld-link invocation itself (for "exe"), for the pdb output name, the exe
output name (for "pdb"), and the obj input files, and no absolute path
must appear on the link command (for "cmd" in the pdb's env block).
Since no full debug info is present, it doesn't matter that the absolute
path doesn't exist on disk -- we only get symbols in stacks.
3. When building production builds with full debug info that don't have
local changes, and that get source indexed and their pdbs get uploaded
to a symbol server. /pdbsourcepath: again makes the build output independent
of the current directory, and the fixed path passed to /pdbsourcepath: can
be given the source indexing transform so that it gets mapped to a
repository path. This has the same requirements as 2.
This patch also makes it possible to create PDB files containing Windows-style
absolute paths when cross-compiling on a POSIX system.
Differential Revision: https://reviews.llvm.org/D53021
llvm-svn: 344061
2018-10-10 01:52:25 +08:00
|
|
|
// Visual Studio's debugger requires absolute paths in various places in the
|
|
|
|
// PDB to work without additional configuration:
|
|
|
|
// https://docs.microsoft.com/en-us/visualstudio/debugger/debug-source-files-common-properties-solution-property-pages-dialog-box
|
|
|
|
static void pdbMakeAbsolute(SmallVectorImpl<char> &fileName) {
|
2018-10-13 01:26:19 +08:00
|
|
|
// The default behavior is to produce paths that are valid within the context
|
|
|
|
// of the machine that you perform the link on. If the linker is running on
|
|
|
|
// a POSIX system, we will output absolute POSIX paths. If the linker is
|
|
|
|
// running on a Windows system, we will output absolute Windows paths. If the
|
|
|
|
// user desires any other kind of behavior, they should explicitly pass
|
|
|
|
// /pdbsourcepath, in which case we will treat the exact string the user
|
|
|
|
// passed in as the gospel and not normalize, canonicalize it.
|
|
|
|
if (sys::path::is_absolute(fileName, sys::path::Style::windows) ||
|
|
|
|
sys::path::is_absolute(fileName, sys::path::Style::posix))
|
lld-link: Use /pdbsourcepath: for more places when present.
/pdbsourcepath: was added in https://reviews.llvm.org/D48882 to make it
possible to have relative paths in the debug info that clang-cl writes.
lld-link then makes the paths absolute at link time, which debuggers require.
This way, clang-cl's output is independent of the absolute path of the build
directory, which is useful for cacheability in distcc-like systems.
This patch extends /pdbsourcepath: (if passed) to also be used for:
1. The "cwd" stored in the env block in the pdb is /pdbsourcepath: if present
2. The "exe" stored in the env block in the pdb is made absolute relative
to /pdbsourcepath: instead of the cwd
3. The "pdb" stored in the env block in the pdb is made absolute relative
to /pdbsourcepath: instead of the cwd
4. For making absolute paths to .obj files referenced from the pdb
/pdbsourcepath: is now useful in three scenarios (the first one already working
before this change):
1. When building with full debug info, passing the real build dir to
/pdbsourcepath: allows having clang-cl's output to be independent
of the build directory path. This patch effectively doesn't change
behavior for this use case (assuming the cwd is the build dir).
2. When building without compile-time debug info but linking with /debug,
a fake fixed /pdbsourcepath: can be passed to get symbolized stacks
while making the pdb and exe independent of the current build dir.
For this two work, lld-link needs to be invoked with relative paths for
the lld-link invocation itself (for "exe"), for the pdb output name, the exe
output name (for "pdb"), and the obj input files, and no absolute path
must appear on the link command (for "cmd" in the pdb's env block).
Since no full debug info is present, it doesn't matter that the absolute
path doesn't exist on disk -- we only get symbols in stacks.
3. When building production builds with full debug info that don't have
local changes, and that get source indexed and their pdbs get uploaded
to a symbol server. /pdbsourcepath: again makes the build output independent
of the current directory, and the fixed path passed to /pdbsourcepath: can
be given the source indexing transform so that it gets mapped to a
repository path. This has the same requirements as 2.
This patch also makes it possible to create PDB files containing Windows-style
absolute paths when cross-compiling on a POSIX system.
Differential Revision: https://reviews.llvm.org/D53021
llvm-svn: 344061
2018-10-10 01:52:25 +08:00
|
|
|
return;
|
2018-10-13 01:26:19 +08:00
|
|
|
|
|
|
|
// It's not absolute in any path syntax. Relative paths necessarily refer to
|
|
|
|
// the local file system, so we can make it native without ending up with a
|
|
|
|
// nonsensical path.
|
lld-link: Use /pdbsourcepath: for more places when present.
/pdbsourcepath: was added in https://reviews.llvm.org/D48882 to make it
possible to have relative paths in the debug info that clang-cl writes.
lld-link then makes the paths absolute at link time, which debuggers require.
This way, clang-cl's output is independent of the absolute path of the build
directory, which is useful for cacheability in distcc-like systems.
This patch extends /pdbsourcepath: (if passed) to also be used for:
1. The "cwd" stored in the env block in the pdb is /pdbsourcepath: if present
2. The "exe" stored in the env block in the pdb is made absolute relative
to /pdbsourcepath: instead of the cwd
3. The "pdb" stored in the env block in the pdb is made absolute relative
to /pdbsourcepath: instead of the cwd
4. For making absolute paths to .obj files referenced from the pdb
/pdbsourcepath: is now useful in three scenarios (the first one already working
before this change):
1. When building with full debug info, passing the real build dir to
/pdbsourcepath: allows having clang-cl's output to be independent
of the build directory path. This patch effectively doesn't change
behavior for this use case (assuming the cwd is the build dir).
2. When building without compile-time debug info but linking with /debug,
a fake fixed /pdbsourcepath: can be passed to get symbolized stacks
while making the pdb and exe independent of the current build dir.
For this two work, lld-link needs to be invoked with relative paths for
the lld-link invocation itself (for "exe"), for the pdb output name, the exe
output name (for "pdb"), and the obj input files, and no absolute path
must appear on the link command (for "cmd" in the pdb's env block).
Since no full debug info is present, it doesn't matter that the absolute
path doesn't exist on disk -- we only get symbols in stacks.
3. When building production builds with full debug info that don't have
local changes, and that get source indexed and their pdbs get uploaded
to a symbol server. /pdbsourcepath: again makes the build output independent
of the current directory, and the fixed path passed to /pdbsourcepath: can
be given the source indexing transform so that it gets mapped to a
repository path. This has the same requirements as 2.
This patch also makes it possible to create PDB files containing Windows-style
absolute paths when cross-compiling on a POSIX system.
Differential Revision: https://reviews.llvm.org/D53021
llvm-svn: 344061
2018-10-10 01:52:25 +08:00
|
|
|
if (config->pdbSourcePath.empty()) {
|
2019-02-06 08:50:35 +08:00
|
|
|
sys::path::native(fileName);
|
lld-link: Use /pdbsourcepath: for more places when present.
/pdbsourcepath: was added in https://reviews.llvm.org/D48882 to make it
possible to have relative paths in the debug info that clang-cl writes.
lld-link then makes the paths absolute at link time, which debuggers require.
This way, clang-cl's output is independent of the absolute path of the build
directory, which is useful for cacheability in distcc-like systems.
This patch extends /pdbsourcepath: (if passed) to also be used for:
1. The "cwd" stored in the env block in the pdb is /pdbsourcepath: if present
2. The "exe" stored in the env block in the pdb is made absolute relative
to /pdbsourcepath: instead of the cwd
3. The "pdb" stored in the env block in the pdb is made absolute relative
to /pdbsourcepath: instead of the cwd
4. For making absolute paths to .obj files referenced from the pdb
/pdbsourcepath: is now useful in three scenarios (the first one already working
before this change):
1. When building with full debug info, passing the real build dir to
/pdbsourcepath: allows having clang-cl's output to be independent
of the build directory path. This patch effectively doesn't change
behavior for this use case (assuming the cwd is the build dir).
2. When building without compile-time debug info but linking with /debug,
a fake fixed /pdbsourcepath: can be passed to get symbolized stacks
while making the pdb and exe independent of the current build dir.
For this two work, lld-link needs to be invoked with relative paths for
the lld-link invocation itself (for "exe"), for the pdb output name, the exe
output name (for "pdb"), and the obj input files, and no absolute path
must appear on the link command (for "cmd" in the pdb's env block).
Since no full debug info is present, it doesn't matter that the absolute
path doesn't exist on disk -- we only get symbols in stacks.
3. When building production builds with full debug info that don't have
local changes, and that get source indexed and their pdbs get uploaded
to a symbol server. /pdbsourcepath: again makes the build output independent
of the current directory, and the fixed path passed to /pdbsourcepath: can
be given the source indexing transform so that it gets mapped to a
repository path. This has the same requirements as 2.
This patch also makes it possible to create PDB files containing Windows-style
absolute paths when cross-compiling on a POSIX system.
Differential Revision: https://reviews.llvm.org/D53021
llvm-svn: 344061
2018-10-10 01:52:25 +08:00
|
|
|
sys::fs::make_absolute(fileName);
|
|
|
|
return;
|
|
|
|
}
|
2018-10-13 01:26:19 +08:00
|
|
|
|
2019-02-06 08:50:35 +08:00
|
|
|
// Try to guess whether /PDBSOURCEPATH is a unix path or a windows path.
|
|
|
|
// Since PDB's are more of a Windows thing, we make this conservative and only
|
|
|
|
// decide that it's a unix path if we're fairly certain. Specifically, if
|
|
|
|
// it starts with a forward slash.
|
lld-link: Use /pdbsourcepath: for more places when present.
/pdbsourcepath: was added in https://reviews.llvm.org/D48882 to make it
possible to have relative paths in the debug info that clang-cl writes.
lld-link then makes the paths absolute at link time, which debuggers require.
This way, clang-cl's output is independent of the absolute path of the build
directory, which is useful for cacheability in distcc-like systems.
This patch extends /pdbsourcepath: (if passed) to also be used for:
1. The "cwd" stored in the env block in the pdb is /pdbsourcepath: if present
2. The "exe" stored in the env block in the pdb is made absolute relative
to /pdbsourcepath: instead of the cwd
3. The "pdb" stored in the env block in the pdb is made absolute relative
to /pdbsourcepath: instead of the cwd
4. For making absolute paths to .obj files referenced from the pdb
/pdbsourcepath: is now useful in three scenarios (the first one already working
before this change):
1. When building with full debug info, passing the real build dir to
/pdbsourcepath: allows having clang-cl's output to be independent
of the build directory path. This patch effectively doesn't change
behavior for this use case (assuming the cwd is the build dir).
2. When building without compile-time debug info but linking with /debug,
a fake fixed /pdbsourcepath: can be passed to get symbolized stacks
while making the pdb and exe independent of the current build dir.
For this two work, lld-link needs to be invoked with relative paths for
the lld-link invocation itself (for "exe"), for the pdb output name, the exe
output name (for "pdb"), and the obj input files, and no absolute path
must appear on the link command (for "cmd" in the pdb's env block).
Since no full debug info is present, it doesn't matter that the absolute
path doesn't exist on disk -- we only get symbols in stacks.
3. When building production builds with full debug info that don't have
local changes, and that get source indexed and their pdbs get uploaded
to a symbol server. /pdbsourcepath: again makes the build output independent
of the current directory, and the fixed path passed to /pdbsourcepath: can
be given the source indexing transform so that it gets mapped to a
repository path. This has the same requirements as 2.
This patch also makes it possible to create PDB files containing Windows-style
absolute paths when cross-compiling on a POSIX system.
Differential Revision: https://reviews.llvm.org/D53021
llvm-svn: 344061
2018-10-10 01:52:25 +08:00
|
|
|
SmallString<128> absoluteFileName = config->pdbSourcePath;
|
2019-02-06 08:50:35 +08:00
|
|
|
sys::path::Style guessedStyle = absoluteFileName.startswith("/")
|
|
|
|
? sys::path::Style::posix
|
|
|
|
: sys::path::Style::windows;
|
|
|
|
sys::path::append(absoluteFileName, guessedStyle, fileName);
|
|
|
|
sys::path::native(absoluteFileName, guessedStyle);
|
|
|
|
sys::path::remove_dots(absoluteFileName, true, guessedStyle);
|
|
|
|
|
lld-link: Use /pdbsourcepath: for more places when present.
/pdbsourcepath: was added in https://reviews.llvm.org/D48882 to make it
possible to have relative paths in the debug info that clang-cl writes.
lld-link then makes the paths absolute at link time, which debuggers require.
This way, clang-cl's output is independent of the absolute path of the build
directory, which is useful for cacheability in distcc-like systems.
This patch extends /pdbsourcepath: (if passed) to also be used for:
1. The "cwd" stored in the env block in the pdb is /pdbsourcepath: if present
2. The "exe" stored in the env block in the pdb is made absolute relative
to /pdbsourcepath: instead of the cwd
3. The "pdb" stored in the env block in the pdb is made absolute relative
to /pdbsourcepath: instead of the cwd
4. For making absolute paths to .obj files referenced from the pdb
/pdbsourcepath: is now useful in three scenarios (the first one already working
before this change):
1. When building with full debug info, passing the real build dir to
/pdbsourcepath: allows having clang-cl's output to be independent
of the build directory path. This patch effectively doesn't change
behavior for this use case (assuming the cwd is the build dir).
2. When building without compile-time debug info but linking with /debug,
a fake fixed /pdbsourcepath: can be passed to get symbolized stacks
while making the pdb and exe independent of the current build dir.
For this two work, lld-link needs to be invoked with relative paths for
the lld-link invocation itself (for "exe"), for the pdb output name, the exe
output name (for "pdb"), and the obj input files, and no absolute path
must appear on the link command (for "cmd" in the pdb's env block).
Since no full debug info is present, it doesn't matter that the absolute
path doesn't exist on disk -- we only get symbols in stacks.
3. When building production builds with full debug info that don't have
local changes, and that get source indexed and their pdbs get uploaded
to a symbol server. /pdbsourcepath: again makes the build output independent
of the current directory, and the fixed path passed to /pdbsourcepath: can
be given the source indexing transform so that it gets mapped to a
repository path. This has the same requirements as 2.
This patch also makes it possible to create PDB files containing Windows-style
absolute paths when cross-compiling on a POSIX system.
Differential Revision: https://reviews.llvm.org/D53021
llvm-svn: 344061
2018-10-10 01:52:25 +08:00
|
|
|
fileName = std::move(absoluteFileName);
|
|
|
|
}
|
|
|
|
|
2017-12-15 02:07:04 +08:00
|
|
|
// A COFF .debug$H section is currently a clang extension. This function checks
|
|
|
|
// if a .debug$H section is in a format that we expect / understand, so that we
|
|
|
|
// can ignore any sections which are coincidentally also named .debug$H but do
|
|
|
|
// not contain a format we recognize.
|
|
|
|
static bool canUseDebugH(ArrayRef<uint8_t> debugH) {
|
|
|
|
if (debugH.size() < sizeof(object::debug_h_header))
|
|
|
|
return false;
|
|
|
|
auto *header =
|
|
|
|
reinterpret_cast<const object::debug_h_header *>(debugH.data());
|
|
|
|
debugH = debugH.drop_front(sizeof(object::debug_h_header));
|
|
|
|
return header->Magic == COFF::DEBUG_HASHES_SECTION_MAGIC &&
|
|
|
|
header->Version == 0 &&
|
2018-05-18 06:55:15 +08:00
|
|
|
header->HashAlgorithm == uint16_t(GlobalTypeHashAlg::SHA1_8) &&
|
|
|
|
(debugH.size() % 8 == 0);
|
2017-12-15 02:07:04 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static Optional<ArrayRef<uint8_t>> getDebugH(ObjFile *file) {
|
2019-02-23 09:46:18 +08:00
|
|
|
SectionChunk *sec =
|
|
|
|
SectionChunk::findByName(file->getDebugChunks(), ".debug$H");
|
2017-12-15 02:07:04 +08:00
|
|
|
if (!sec)
|
|
|
|
return llvm::None;
|
|
|
|
ArrayRef<uint8_t> contents = sec->getContents();
|
|
|
|
if (!canUseDebugH(contents))
|
|
|
|
return None;
|
|
|
|
return contents;
|
|
|
|
}
|
|
|
|
|
|
|
|
static ArrayRef<GloballyHashedType>
|
|
|
|
getHashesFromDebugH(ArrayRef<uint8_t> debugH) {
|
|
|
|
assert(canUseDebugH(debugH));
|
|
|
|
|
|
|
|
debugH = debugH.drop_front(sizeof(object::debug_h_header));
|
|
|
|
uint32_t count = debugH.size() / sizeof(GloballyHashedType);
|
|
|
|
return {reinterpret_cast<const GloballyHashedType *>(debugH.data()), count};
|
|
|
|
}
|
|
|
|
|
2017-03-25 01:26:38 +08:00
|
|
|
static void addTypeInfo(pdb::TpiStreamBuilder &tpiBuilder,
|
2017-11-30 03:35:21 +08:00
|
|
|
TypeCollection &typeTable) {
|
2017-03-25 01:26:38 +08:00
|
|
|
// Start the TPI or IPI stream header.
|
|
|
|
tpiBuilder.setVersionHeader(pdb::PdbTpiV80);
|
|
|
|
|
2017-07-20 01:26:07 +08:00
|
|
|
// Flatten the in memory type table and hash each type.
|
2017-11-30 03:35:21 +08:00
|
|
|
typeTable.ForEachRecord([&](TypeIndex ti, const CVType &type) {
|
2017-07-20 01:26:07 +08:00
|
|
|
auto hash = pdb::hashTypeRecord(type);
|
|
|
|
if (auto e = hash.takeError())
|
|
|
|
fatal("type hashing error");
|
2017-11-30 03:35:21 +08:00
|
|
|
tpiBuilder.addTypeRecord(type.RecordData, *hash);
|
2017-03-25 01:26:38 +08:00
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2018-11-06 03:20:47 +08:00
|
|
|
Expected<const CVIndexMap &>
|
|
|
|
PDBLinker::mergeDebugT(ObjFile *file, CVIndexMap *objectIndexMap) {
|
2018-01-18 03:16:26 +08:00
|
|
|
ScopedTimer t(typeMergingTimer);
|
|
|
|
|
[LLD][COFF] Early dependency detection
We introduce a new class hierarchy for debug types merging (in DebugTypes.h). The end-goal is to parallelize the type merging - please see the plan in D59226.
Previously, dependency discovery was done on the fly, much later, during the type merging loop. Unfortunately, parallelizing the type merging requires the dependencies to be merged in first, before any dependent ObjFile, thus this early discovery.
The overall intention for this path is to discover debug information dependencies at a much earlier stage, when processing input files. Currently, two types of dependency are supported: PDB type servers (when compiling with MSVC /Zi) and precompiled headers OBJs (when compiling with MSVC /Yc and /Yu). Once discovered, an explicit link is added into the dependent ObjFile, through the new debug types class hierarchy introduced in DebugTypes.h.
Differential Revision: https://reviews.llvm.org/D59053
llvm-svn: 357383
2019-04-01 21:36:59 +08:00
|
|
|
if (!file->debugTypesObj)
|
2019-06-03 20:39:47 +08:00
|
|
|
return *objectIndexMap; // no Types stream
|
2018-11-06 03:20:47 +08:00
|
|
|
|
|
|
|
// Precompiled headers objects need to save the index map for further
|
|
|
|
// reference by other objects which use the precompiled headers.
|
[LLD][COFF] Early dependency detection
We introduce a new class hierarchy for debug types merging (in DebugTypes.h). The end-goal is to parallelize the type merging - please see the plan in D59226.
Previously, dependency discovery was done on the fly, much later, during the type merging loop. Unfortunately, parallelizing the type merging requires the dependencies to be merged in first, before any dependent ObjFile, thus this early discovery.
The overall intention for this path is to discover debug information dependencies at a much earlier stage, when processing input files. Currently, two types of dependency are supported: PDB type servers (when compiling with MSVC /Zi) and precompiled headers OBJs (when compiling with MSVC /Yc and /Yu). Once discovered, an explicit link is added into the dependent ObjFile, through the new debug types class hierarchy introduced in DebugTypes.h.
Differential Revision: https://reviews.llvm.org/D59053
llvm-svn: 357383
2019-04-01 21:36:59 +08:00
|
|
|
if (file->debugTypesObj->kind == TpiSource::PCH) {
|
2019-02-23 09:46:18 +08:00
|
|
|
uint32_t pchSignature = file->pchSignature.getValueOr(0);
|
2018-11-06 03:20:47 +08:00
|
|
|
if (pchSignature == 0)
|
|
|
|
fatal("No signature found for the precompiled headers OBJ (" +
|
|
|
|
file->getName() + ")");
|
|
|
|
|
|
|
|
// When a precompiled headers object comes first on the command-line, we
|
|
|
|
// update the mapping here. Otherwise, if an object referencing the
|
|
|
|
// precompiled headers object comes first, the mapping is created in
|
|
|
|
// aquirePrecompObj(), thus we would skip this block.
|
|
|
|
if (!objectIndexMap->isPrecompiledTypeMap) {
|
|
|
|
auto r = registerPrecompiledHeaders(pchSignature);
|
|
|
|
if (r.second)
|
|
|
|
fatal(
|
|
|
|
"A precompiled headers OBJ with the same signature was already "
|
|
|
|
"provided! (" +
|
|
|
|
file->getName() + ")");
|
|
|
|
|
|
|
|
objectIndexMap = &r.first;
|
|
|
|
}
|
|
|
|
}
|
2017-07-14 04:12:23 +08:00
|
|
|
|
[LLD][COFF] Early dependency detection
We introduce a new class hierarchy for debug types merging (in DebugTypes.h). The end-goal is to parallelize the type merging - please see the plan in D59226.
Previously, dependency discovery was done on the fly, much later, during the type merging loop. Unfortunately, parallelizing the type merging requires the dependencies to be merged in first, before any dependent ObjFile, thus this early discovery.
The overall intention for this path is to discover debug information dependencies at a much earlier stage, when processing input files. Currently, two types of dependency are supported: PDB type servers (when compiling with MSVC /Zi) and precompiled headers OBJs (when compiling with MSVC /Yc and /Yu). Once discovered, an explicit link is added into the dependent ObjFile, through the new debug types class hierarchy introduced in DebugTypes.h.
Differential Revision: https://reviews.llvm.org/D59053
llvm-svn: 357383
2019-04-01 21:36:59 +08:00
|
|
|
if (file->debugTypesObj->kind == TpiSource::UsingPDB) {
|
2018-11-06 03:20:47 +08:00
|
|
|
// Look through type servers. If we've already seen this type server,
|
|
|
|
// don't merge any type information.
|
[LLD][COFF] Early dependency detection
We introduce a new class hierarchy for debug types merging (in DebugTypes.h). The end-goal is to parallelize the type merging - please see the plan in D59226.
Previously, dependency discovery was done on the fly, much later, during the type merging loop. Unfortunately, parallelizing the type merging requires the dependencies to be merged in first, before any dependent ObjFile, thus this early discovery.
The overall intention for this path is to discover debug information dependencies at a much earlier stage, when processing input files. Currently, two types of dependency are supported: PDB type servers (when compiling with MSVC /Zi) and precompiled headers OBJs (when compiling with MSVC /Yc and /Yu). Once discovered, an explicit link is added into the dependent ObjFile, through the new debug types class hierarchy introduced in DebugTypes.h.
Differential Revision: https://reviews.llvm.org/D59053
llvm-svn: 357383
2019-04-01 21:36:59 +08:00
|
|
|
return maybeMergeTypeServerPDB(file);
|
|
|
|
}
|
|
|
|
|
|
|
|
CVTypeArray &types = *file->debugTypes;
|
|
|
|
|
|
|
|
if (file->debugTypesObj->kind == TpiSource::UsingPCH) {
|
2018-11-06 03:20:47 +08:00
|
|
|
// This object was compiled with /Yu, so process the corresponding
|
|
|
|
// precompiled headers object (/Yc) first. Some type indices in the current
|
|
|
|
// object are referencing data in the precompiled headers object, so we need
|
|
|
|
// both to be loaded.
|
[LLD][COFF] Early dependency detection
We introduce a new class hierarchy for debug types merging (in DebugTypes.h). The end-goal is to parallelize the type merging - please see the plan in D59226.
Previously, dependency discovery was done on the fly, much later, during the type merging loop. Unfortunately, parallelizing the type merging requires the dependencies to be merged in first, before any dependent ObjFile, thus this early discovery.
The overall intention for this path is to discover debug information dependencies at a much earlier stage, when processing input files. Currently, two types of dependency are supported: PDB type servers (when compiling with MSVC /Zi) and precompiled headers OBJs (when compiling with MSVC /Yc and /Yu). Once discovered, an explicit link is added into the dependent ObjFile, through the new debug types class hierarchy introduced in DebugTypes.h.
Differential Revision: https://reviews.llvm.org/D59053
llvm-svn: 357383
2019-04-01 21:36:59 +08:00
|
|
|
Error e = mergeInPrecompHeaderObj(file, objectIndexMap);
|
|
|
|
if (e)
|
|
|
|
return std::move(e);
|
|
|
|
|
|
|
|
// Drop LF_PRECOMP record from the input stream, as it has been replaced
|
|
|
|
// with the precompiled headers Type stream in the mergeInPrecompHeaderObj()
|
|
|
|
// call above. Note that we can't just call Types.drop_front(), as we
|
|
|
|
// explicitly want to rebase the stream.
|
|
|
|
CVTypeArray::Iterator firstType = types.begin();
|
2018-12-14 02:11:33 +08:00
|
|
|
types.setUnderlyingStream(
|
|
|
|
types.getUnderlyingStream().drop_front(firstType->RecordData.size()));
|
2018-11-06 03:20:47 +08:00
|
|
|
}
|
2017-07-18 08:21:25 +08:00
|
|
|
|
2018-11-06 03:20:47 +08:00
|
|
|
// Fill in the temporary, caller-provided ObjectIndexMap.
|
2017-12-15 02:07:04 +08:00
|
|
|
if (config->debugGHashes) {
|
|
|
|
ArrayRef<GloballyHashedType> hashes;
|
|
|
|
std::vector<GloballyHashedType> ownedHashes;
|
|
|
|
if (Optional<ArrayRef<uint8_t>> debugH = getDebugH(file))
|
|
|
|
hashes = getHashesFromDebugH(*debugH);
|
|
|
|
else {
|
|
|
|
ownedHashes = GloballyHashedType::hashTypes(types);
|
|
|
|
hashes = ownedHashes;
|
|
|
|
}
|
|
|
|
|
2019-04-03 04:43:19 +08:00
|
|
|
if (auto err = mergeTypeAndIdRecords(
|
|
|
|
tMerger.globalIDTable, tMerger.globalTypeTable,
|
|
|
|
objectIndexMap->tpiMap, types, hashes, file->pchSignature))
|
2017-12-15 02:07:04 +08:00
|
|
|
fatal("codeview::mergeTypeAndIdRecords failed: " +
|
|
|
|
toString(std::move(err)));
|
|
|
|
} else {
|
2019-04-03 04:43:19 +08:00
|
|
|
if (auto err = mergeTypeAndIdRecords(tMerger.iDTable, tMerger.typeTable,
|
|
|
|
objectIndexMap->tpiMap, types,
|
|
|
|
file->pchSignature))
|
2017-12-15 02:07:04 +08:00
|
|
|
fatal("codeview::mergeTypeAndIdRecords failed: " +
|
|
|
|
toString(std::move(err)));
|
|
|
|
}
|
2018-11-06 03:20:47 +08:00
|
|
|
return *objectIndexMap;
|
2017-07-18 08:21:25 +08:00
|
|
|
}
|
|
|
|
|
2019-05-29 04:57:56 +08:00
|
|
|
Expected<const CVIndexMap &> PDBLinker::maybeMergeTypeServerPDB(ObjFile *file) {
|
2019-06-03 20:39:47 +08:00
|
|
|
Expected<llvm::pdb::NativeSession *> pdbSession = findTypeServerSource(file);
|
|
|
|
if (!pdbSession)
|
|
|
|
return pdbSession.takeError();
|
2018-03-01 02:09:18 +08:00
|
|
|
|
2019-06-03 20:39:47 +08:00
|
|
|
pdb::PDBFile &pdbFile = pdbSession.get()->getPDBFile();
|
|
|
|
pdb::InfoStream &info = cantFail(pdbFile.getPDBInfoStream());
|
2019-05-29 04:57:56 +08:00
|
|
|
|
2019-06-03 20:39:47 +08:00
|
|
|
auto it = typeServerIndexMappings.emplace(info.getGuid(), CVIndexMap());
|
|
|
|
CVIndexMap &indexMap = it.first->second;
|
|
|
|
if (!it.second)
|
|
|
|
return indexMap; // already merged
|
2019-05-29 04:57:56 +08:00
|
|
|
|
2019-06-03 20:39:47 +08:00
|
|
|
// Mark this map as a type server map.
|
|
|
|
indexMap.isTypeServerMap = true;
|
2019-07-11 13:40:30 +08:00
|
|
|
|
2019-06-03 20:39:47 +08:00
|
|
|
Expected<pdb::TpiStream &> expectedTpi = pdbFile.getPDBTpiStream();
|
2017-07-18 08:21:25 +08:00
|
|
|
if (auto e = expectedTpi.takeError())
|
[lld] unified COFF and ELF error handling on new Common/ErrorHandler
Summary:
The COFF linker and the ELF linker have long had similar but separate
Error.h and Error.cpp files to implement error handling. This change
introduces new error handling code in Common/ErrorHandler.h, changes the
COFF and ELF linkers to use it, and removes the old, separate
implementations.
Reviewers: ruiu
Reviewed By: ruiu
Subscribers: smeenai, jyknight, emaste, sdardis, nemanjai, nhaehnle, mgorny, javed.absar, kbarton, fedor.sergeev, llvm-commits
Differential Revision: https://reviews.llvm.org/D39259
llvm-svn: 316624
2017-10-26 06:28:38 +08:00
|
|
|
fatal("Type server does not have TPI stream: " + toString(std::move(e)));
|
2019-06-13 06:33:16 +08:00
|
|
|
pdb::TpiStream *maybeIpi = nullptr;
|
|
|
|
if (pdbFile.hasPDBIpiStream()) {
|
|
|
|
Expected<pdb::TpiStream &> expectedIpi = pdbFile.getPDBIpiStream();
|
|
|
|
if (auto e = expectedIpi.takeError())
|
|
|
|
fatal("Error getting type server IPI stream: " + toString(std::move(e)));
|
|
|
|
maybeIpi = &*expectedIpi;
|
|
|
|
}
|
2017-12-15 02:07:04 +08:00
|
|
|
|
|
|
|
if (config->debugGHashes) {
|
|
|
|
// PDBs do not actually store global hashes, so when merging a type server
|
|
|
|
// PDB we have to synthesize global hashes. To do this, we first synthesize
|
|
|
|
// global hashes for the TPI stream, since it is independent, then we
|
|
|
|
// synthesize hashes for the IPI stream, using the hashes for the TPI stream
|
|
|
|
// as inputs.
|
|
|
|
auto tpiHashes = GloballyHashedType::hashTypes(expectedTpi->typeArray());
|
2019-01-07 21:53:16 +08:00
|
|
|
Optional<uint32_t> endPrecomp;
|
2017-12-15 02:07:04 +08:00
|
|
|
// Merge TPI first, because the IPI stream will reference type indices.
|
2019-04-03 04:43:19 +08:00
|
|
|
if (auto err =
|
|
|
|
mergeTypeRecords(tMerger.globalTypeTable, indexMap.tpiMap,
|
|
|
|
expectedTpi->typeArray(), tpiHashes, endPrecomp))
|
2017-12-15 02:07:04 +08:00
|
|
|
fatal("codeview::mergeTypeRecords failed: " + toString(std::move(err)));
|
|
|
|
|
|
|
|
// Merge IPI.
|
2019-06-13 06:33:16 +08:00
|
|
|
if (maybeIpi) {
|
|
|
|
auto ipiHashes =
|
|
|
|
GloballyHashedType::hashIds(maybeIpi->typeArray(), tpiHashes);
|
|
|
|
if (auto err =
|
|
|
|
mergeIdRecords(tMerger.globalIDTable, indexMap.tpiMap,
|
|
|
|
indexMap.ipiMap, maybeIpi->typeArray(), ipiHashes))
|
|
|
|
fatal("codeview::mergeIdRecords failed: " + toString(std::move(err)));
|
|
|
|
}
|
2017-12-15 02:07:04 +08:00
|
|
|
} else {
|
|
|
|
// Merge TPI first, because the IPI stream will reference type indices.
|
2019-04-03 04:43:19 +08:00
|
|
|
if (auto err = mergeTypeRecords(tMerger.typeTable, indexMap.tpiMap,
|
2017-12-15 02:07:04 +08:00
|
|
|
expectedTpi->typeArray()))
|
|
|
|
fatal("codeview::mergeTypeRecords failed: " + toString(std::move(err)));
|
|
|
|
|
|
|
|
// Merge IPI.
|
2019-06-13 06:33:16 +08:00
|
|
|
if (maybeIpi) {
|
|
|
|
if (auto err = mergeIdRecords(tMerger.iDTable, indexMap.tpiMap,
|
|
|
|
indexMap.ipiMap, maybeIpi->typeArray()))
|
|
|
|
fatal("codeview::mergeIdRecords failed: " + toString(std::move(err)));
|
|
|
|
}
|
2017-12-15 02:07:04 +08:00
|
|
|
}
|
2017-07-18 08:21:25 +08:00
|
|
|
|
|
|
|
return indexMap;
|
2017-06-20 01:21:45 +08:00
|
|
|
}
|
|
|
|
|
[LLD][COFF] Early dependency detection
We introduce a new class hierarchy for debug types merging (in DebugTypes.h). The end-goal is to parallelize the type merging - please see the plan in D59226.
Previously, dependency discovery was done on the fly, much later, during the type merging loop. Unfortunately, parallelizing the type merging requires the dependencies to be merged in first, before any dependent ObjFile, thus this early discovery.
The overall intention for this path is to discover debug information dependencies at a much earlier stage, when processing input files. Currently, two types of dependency are supported: PDB type servers (when compiling with MSVC /Zi) and precompiled headers OBJs (when compiling with MSVC /Yc and /Yu). Once discovered, an explicit link is added into the dependent ObjFile, through the new debug types class hierarchy introduced in DebugTypes.h.
Differential Revision: https://reviews.llvm.org/D59053
llvm-svn: 357383
2019-04-01 21:36:59 +08:00
|
|
|
Error PDBLinker::mergeInPrecompHeaderObj(ObjFile *file,
|
|
|
|
CVIndexMap *objectIndexMap) {
|
|
|
|
const PrecompRecord &precomp =
|
|
|
|
retrieveDependencyInfo<PrecompRecord>(file->debugTypesObj);
|
|
|
|
|
|
|
|
Expected<const CVIndexMap &> e = aquirePrecompObj(file);
|
2018-11-06 03:20:47 +08:00
|
|
|
if (!e)
|
2018-11-08 22:42:37 +08:00
|
|
|
return e.takeError();
|
2018-11-06 03:20:47 +08:00
|
|
|
|
|
|
|
const CVIndexMap &precompIndexMap = *e;
|
|
|
|
assert(precompIndexMap.isPrecompiledTypeMap);
|
|
|
|
|
|
|
|
if (precompIndexMap.tpiMap.empty())
|
[LLD][COFF] Early dependency detection
We introduce a new class hierarchy for debug types merging (in DebugTypes.h). The end-goal is to parallelize the type merging - please see the plan in D59226.
Previously, dependency discovery was done on the fly, much later, during the type merging loop. Unfortunately, parallelizing the type merging requires the dependencies to be merged in first, before any dependent ObjFile, thus this early discovery.
The overall intention for this path is to discover debug information dependencies at a much earlier stage, when processing input files. Currently, two types of dependency are supported: PDB type servers (when compiling with MSVC /Zi) and precompiled headers OBJs (when compiling with MSVC /Yc and /Yu). Once discovered, an explicit link is added into the dependent ObjFile, through the new debug types class hierarchy introduced in DebugTypes.h.
Differential Revision: https://reviews.llvm.org/D59053
llvm-svn: 357383
2019-04-01 21:36:59 +08:00
|
|
|
return Error::success();
|
2018-11-06 03:20:47 +08:00
|
|
|
|
|
|
|
assert(precomp.getStartTypeIndex() == TypeIndex::FirstNonSimpleIndex);
|
|
|
|
assert(precomp.getTypesCount() <= precompIndexMap.tpiMap.size());
|
|
|
|
// Use the previously remapped index map from the precompiled headers.
|
|
|
|
objectIndexMap->tpiMap.append(precompIndexMap.tpiMap.begin(),
|
|
|
|
precompIndexMap.tpiMap.begin() +
|
|
|
|
precomp.getTypesCount());
|
[LLD][COFF] Early dependency detection
We introduce a new class hierarchy for debug types merging (in DebugTypes.h). The end-goal is to parallelize the type merging - please see the plan in D59226.
Previously, dependency discovery was done on the fly, much later, during the type merging loop. Unfortunately, parallelizing the type merging requires the dependencies to be merged in first, before any dependent ObjFile, thus this early discovery.
The overall intention for this path is to discover debug information dependencies at a much earlier stage, when processing input files. Currently, two types of dependency are supported: PDB type servers (when compiling with MSVC /Zi) and precompiled headers OBJs (when compiling with MSVC /Yc and /Yu). Once discovered, an explicit link is added into the dependent ObjFile, through the new debug types class hierarchy introduced in DebugTypes.h.
Differential Revision: https://reviews.llvm.org/D59053
llvm-svn: 357383
2019-04-01 21:36:59 +08:00
|
|
|
return Error::success();
|
2018-11-06 03:20:47 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static bool equals_path(StringRef path1, StringRef path2) {
|
|
|
|
#if defined(_WIN32)
|
|
|
|
return path1.equals_lower(path2);
|
|
|
|
#else
|
|
|
|
return path1.equals(path2);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2018-11-08 22:42:37 +08:00
|
|
|
// Find by name an OBJ provided on the command line
|
|
|
|
static ObjFile *findObjByName(StringRef fileNameOnly) {
|
2018-11-06 03:20:47 +08:00
|
|
|
SmallString<128> currentPath;
|
|
|
|
|
|
|
|
for (ObjFile *f : ObjFile::instances) {
|
2018-11-08 22:42:37 +08:00
|
|
|
StringRef currentFileName = sys::path::filename(f->getName());
|
2018-11-06 03:20:47 +08:00
|
|
|
|
2018-11-08 22:42:37 +08:00
|
|
|
// Compare based solely on the file name (link.exe behavior)
|
2018-11-06 03:20:47 +08:00
|
|
|
if (equals_path(currentFileName, fileNameOnly))
|
2018-11-08 22:42:37 +08:00
|
|
|
return f;
|
2018-11-06 03:20:47 +08:00
|
|
|
}
|
2018-11-08 22:42:37 +08:00
|
|
|
return nullptr;
|
2018-11-06 03:20:47 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
std::pair<CVIndexMap &, bool /*already there*/>
|
|
|
|
PDBLinker::registerPrecompiledHeaders(uint32_t signature) {
|
|
|
|
auto insertion = precompTypeIndexMappings.insert({signature, CVIndexMap()});
|
|
|
|
CVIndexMap &indexMap = insertion.first->second;
|
|
|
|
if (!insertion.second)
|
|
|
|
return {indexMap, true};
|
|
|
|
// Mark this map as a precompiled types map.
|
|
|
|
indexMap.isPrecompiledTypeMap = true;
|
|
|
|
return {indexMap, false};
|
|
|
|
}
|
|
|
|
|
[LLD][COFF] Early dependency detection
We introduce a new class hierarchy for debug types merging (in DebugTypes.h). The end-goal is to parallelize the type merging - please see the plan in D59226.
Previously, dependency discovery was done on the fly, much later, during the type merging loop. Unfortunately, parallelizing the type merging requires the dependencies to be merged in first, before any dependent ObjFile, thus this early discovery.
The overall intention for this path is to discover debug information dependencies at a much earlier stage, when processing input files. Currently, two types of dependency are supported: PDB type servers (when compiling with MSVC /Zi) and precompiled headers OBJs (when compiling with MSVC /Yc and /Yu). Once discovered, an explicit link is added into the dependent ObjFile, through the new debug types class hierarchy introduced in DebugTypes.h.
Differential Revision: https://reviews.llvm.org/D59053
llvm-svn: 357383
2019-04-01 21:36:59 +08:00
|
|
|
Expected<const CVIndexMap &> PDBLinker::aquirePrecompObj(ObjFile *file) {
|
|
|
|
const PrecompRecord &precomp =
|
|
|
|
retrieveDependencyInfo<PrecompRecord>(file->debugTypesObj);
|
|
|
|
|
2018-11-06 03:20:47 +08:00
|
|
|
// First, check if we already loaded the precompiled headers object with this
|
|
|
|
// signature. Return the type index mapping if we've already seen it.
|
|
|
|
auto r = registerPrecompiledHeaders(precomp.getSignature());
|
|
|
|
if (r.second)
|
|
|
|
return r.first;
|
|
|
|
|
|
|
|
CVIndexMap &indexMap = r.first;
|
|
|
|
|
|
|
|
// Cross-compile warning: given that Clang doesn't generate LF_PRECOMP
|
|
|
|
// records, we assume the OBJ comes from a Windows build of cl.exe. Thusly,
|
|
|
|
// the paths embedded in the OBJs are in the Windows format.
|
2018-11-08 22:42:37 +08:00
|
|
|
SmallString<128> precompFileName = sys::path::filename(
|
|
|
|
precomp.getPrecompFilePath(), sys::path::Style::windows);
|
2018-11-06 03:20:47 +08:00
|
|
|
|
|
|
|
// link.exe requires that a precompiled headers object must always be provided
|
|
|
|
// on the command-line, even if that's not necessary.
|
2018-11-08 22:42:37 +08:00
|
|
|
auto precompFile = findObjByName(precompFileName);
|
|
|
|
if (!precompFile)
|
|
|
|
return createFileError(
|
|
|
|
precompFileName.str(),
|
|
|
|
make_error<pdb::PDBError>(pdb::pdb_error_code::external_cmdline_ref));
|
2018-11-06 03:20:47 +08:00
|
|
|
|
2018-11-08 22:42:37 +08:00
|
|
|
addObjFile(precompFile, &indexMap);
|
2018-11-06 03:20:47 +08:00
|
|
|
|
2019-01-07 21:53:16 +08:00
|
|
|
if (!precompFile->pchSignature)
|
2018-11-08 22:42:37 +08:00
|
|
|
fatal(precompFile->getName() + " is not a precompiled headers object");
|
2018-11-06 03:20:47 +08:00
|
|
|
|
2019-01-07 21:53:16 +08:00
|
|
|
if (precomp.getSignature() != precompFile->pchSignature.getValueOr(0))
|
2018-11-08 22:42:37 +08:00
|
|
|
return createFileError(
|
|
|
|
precomp.getPrecompFilePath().str(),
|
|
|
|
make_error<pdb::PDBError>(pdb::pdb_error_code::signature_out_of_date));
|
2018-11-06 03:20:47 +08:00
|
|
|
|
|
|
|
return indexMap;
|
|
|
|
}
|
|
|
|
|
2017-06-22 01:25:56 +08:00
|
|
|
static bool remapTypeIndex(TypeIndex &ti, ArrayRef<TypeIndex> typeIndexMap) {
|
|
|
|
if (ti.isSimple())
|
|
|
|
return true;
|
|
|
|
if (ti.toArrayIndex() >= typeIndexMap.size())
|
|
|
|
return false;
|
|
|
|
ti = typeIndexMap[ti.toArrayIndex()];
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2017-10-25 01:02:40 +08:00
|
|
|
static void remapTypesInSymbolRecord(ObjFile *file, SymbolKind symKind,
|
[PDB] Add symbol records in bulk
Summary:
This speeds up linking clang.exe/pdb with /DEBUG:GHASH by 31%, from
12.9s to 9.8s.
Symbol records are typically small (16.7 bytes on average), but we
processed them one at a time. CVSymbol is a relatively "large" type. It
wraps an ArrayRef<uint8_t> with a kind an optional 32-bit hash, which we
don't need. Before this change, each DbiModuleDescriptorBuilder would
maintain an array of CVSymbols, and would write them individually with a
BinaryItemStream.
With this change, we now add symbols that happen to appear contiguously
in bulk. For each .debug$S section (roughly one per function), we
allocate two copies, one for relocation, and one for realignment
purposes. For runs of symbols that go in the module stream, which is
most symbols, we now add them as a single ArrayRef<uint8_t>, so the
vector DbiModuleDescriptorBuilder is roughly linear in the number of
.debug$S sections (O(# funcs)) instead of the number of symbol records
(very large).
Some stats on symbol sizes for the curious:
PDB size: 507M
sym bytes: 316,508,016
sym count: 18,954,971
sym byte avg: 16.7
As future work, we may be able to skip copying symbol records in the
linker for realignment purposes if we make LLVM write them aligned into
the object file. We need to double check that such symbol records are
still compatible with link.exe, but if so, it's definitely worth doing,
since my profile shows we spend 500ms in memcpy in the symbol merging
code. We could potentially cut that in half by saving a copy.
Alternatively, we could apply the relocations *after* we iterate the
symbols. This would require some careful re-engineering of the
relocation processing code, though.
Reviewers: zturner, aganea, ruiu
Subscribers: hiraditya, llvm-commits
Differential Revision: https://reviews.llvm.org/D54554
llvm-svn: 347687
2018-11-28 03:00:23 +08:00
|
|
|
MutableArrayRef<uint8_t> recordBytes,
|
2017-07-18 08:21:25 +08:00
|
|
|
const CVIndexMap &indexMap,
|
2017-06-22 01:25:56 +08:00
|
|
|
ArrayRef<TiReference> typeRefs) {
|
[PDB] Add symbol records in bulk
Summary:
This speeds up linking clang.exe/pdb with /DEBUG:GHASH by 31%, from
12.9s to 9.8s.
Symbol records are typically small (16.7 bytes on average), but we
processed them one at a time. CVSymbol is a relatively "large" type. It
wraps an ArrayRef<uint8_t> with a kind an optional 32-bit hash, which we
don't need. Before this change, each DbiModuleDescriptorBuilder would
maintain an array of CVSymbols, and would write them individually with a
BinaryItemStream.
With this change, we now add symbols that happen to appear contiguously
in bulk. For each .debug$S section (roughly one per function), we
allocate two copies, one for relocation, and one for realignment
purposes. For runs of symbols that go in the module stream, which is
most symbols, we now add them as a single ArrayRef<uint8_t>, so the
vector DbiModuleDescriptorBuilder is roughly linear in the number of
.debug$S sections (O(# funcs)) instead of the number of symbol records
(very large).
Some stats on symbol sizes for the curious:
PDB size: 507M
sym bytes: 316,508,016
sym count: 18,954,971
sym byte avg: 16.7
As future work, we may be able to skip copying symbol records in the
linker for realignment purposes if we make LLVM write them aligned into
the object file. We need to double check that such symbol records are
still compatible with link.exe, but if so, it's definitely worth doing,
since my profile shows we spend 500ms in memcpy in the symbol merging
code. We could potentially cut that in half by saving a copy.
Alternatively, we could apply the relocations *after* we iterate the
symbols. This would require some careful re-engineering of the
relocation processing code, though.
Reviewers: zturner, aganea, ruiu
Subscribers: hiraditya, llvm-commits
Differential Revision: https://reviews.llvm.org/D54554
llvm-svn: 347687
2018-11-28 03:00:23 +08:00
|
|
|
MutableArrayRef<uint8_t> contents =
|
|
|
|
recordBytes.drop_front(sizeof(RecordPrefix));
|
2017-06-22 01:25:56 +08:00
|
|
|
for (const TiReference &ref : typeRefs) {
|
|
|
|
unsigned byteSize = ref.Count * sizeof(TypeIndex);
|
2017-07-13 02:49:43 +08:00
|
|
|
if (contents.size() < ref.Offset + byteSize)
|
|
|
|
fatal("symbol record too short");
|
2017-07-18 08:21:25 +08:00
|
|
|
|
|
|
|
// This can be an item index or a type index. Choose the appropriate map.
|
|
|
|
ArrayRef<TypeIndex> typeOrItemMap = indexMap.tpiMap;
|
2017-10-25 01:02:40 +08:00
|
|
|
bool isItemIndex = ref.Kind == TiRefKind::IndexRef;
|
|
|
|
if (isItemIndex && indexMap.isTypeServerMap)
|
2017-07-18 08:21:25 +08:00
|
|
|
typeOrItemMap = indexMap.ipiMap;
|
2019-07-11 13:40:30 +08:00
|
|
|
|
2017-06-22 01:25:56 +08:00
|
|
|
MutableArrayRef<TypeIndex> tIs(
|
|
|
|
reinterpret_cast<TypeIndex *>(contents.data() + ref.Offset), ref.Count);
|
2017-07-13 02:49:43 +08:00
|
|
|
for (TypeIndex &ti : tIs) {
|
2017-07-18 08:21:25 +08:00
|
|
|
if (!remapTypeIndex(ti, typeOrItemMap)) {
|
2017-10-25 01:02:40 +08:00
|
|
|
log("ignoring symbol record of kind 0x" + utohexstr(symKind) + " in " +
|
|
|
|
file->getName() + " with bad " + (isItemIndex ? "item" : "type") +
|
|
|
|
" index 0x" + utohexstr(ti.getIndex()));
|
2017-10-24 06:44:51 +08:00
|
|
|
ti = TypeIndex(SimpleTypeKind::NotTranslated);
|
2017-07-13 02:49:43 +08:00
|
|
|
continue;
|
2017-06-22 01:25:56 +08:00
|
|
|
}
|
2017-07-13 02:49:43 +08:00
|
|
|
}
|
2017-06-22 01:25:56 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-01-06 03:12:40 +08:00
|
|
|
static void
|
|
|
|
recordStringTableReferenceAtOffset(MutableArrayRef<uint8_t> contents,
|
|
|
|
uint32_t offset,
|
|
|
|
std::vector<ulittle32_t *> &strTableRefs) {
|
|
|
|
contents =
|
|
|
|
contents.drop_front(offset).take_front(sizeof(support::ulittle32_t));
|
|
|
|
ulittle32_t *index = reinterpret_cast<ulittle32_t *>(contents.data());
|
|
|
|
strTableRefs.push_back(index);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
recordStringTableReferences(SymbolKind kind, MutableArrayRef<uint8_t> contents,
|
|
|
|
std::vector<ulittle32_t *> &strTableRefs) {
|
|
|
|
// For now we only handle S_FILESTATIC, but we may need the same logic for
|
|
|
|
// S_DEFRANGE and S_DEFRANGE_SUBFIELD. However, I cannot seem to generate any
|
|
|
|
// PDBs that contain these types of records, so because of the uncertainty
|
|
|
|
// they are omitted here until we can prove that it's necessary.
|
|
|
|
switch (kind) {
|
|
|
|
case SymbolKind::S_FILESTATIC:
|
|
|
|
// FileStaticSym::ModFileOffset
|
[PDB] Add symbol records in bulk
Summary:
This speeds up linking clang.exe/pdb with /DEBUG:GHASH by 31%, from
12.9s to 9.8s.
Symbol records are typically small (16.7 bytes on average), but we
processed them one at a time. CVSymbol is a relatively "large" type. It
wraps an ArrayRef<uint8_t> with a kind an optional 32-bit hash, which we
don't need. Before this change, each DbiModuleDescriptorBuilder would
maintain an array of CVSymbols, and would write them individually with a
BinaryItemStream.
With this change, we now add symbols that happen to appear contiguously
in bulk. For each .debug$S section (roughly one per function), we
allocate two copies, one for relocation, and one for realignment
purposes. For runs of symbols that go in the module stream, which is
most symbols, we now add them as a single ArrayRef<uint8_t>, so the
vector DbiModuleDescriptorBuilder is roughly linear in the number of
.debug$S sections (O(# funcs)) instead of the number of symbol records
(very large).
Some stats on symbol sizes for the curious:
PDB size: 507M
sym bytes: 316,508,016
sym count: 18,954,971
sym byte avg: 16.7
As future work, we may be able to skip copying symbol records in the
linker for realignment purposes if we make LLVM write them aligned into
the object file. We need to double check that such symbol records are
still compatible with link.exe, but if so, it's definitely worth doing,
since my profile shows we spend 500ms in memcpy in the symbol merging
code. We could potentially cut that in half by saving a copy.
Alternatively, we could apply the relocations *after* we iterate the
symbols. This would require some careful re-engineering of the
relocation processing code, though.
Reviewers: zturner, aganea, ruiu
Subscribers: hiraditya, llvm-commits
Differential Revision: https://reviews.llvm.org/D54554
llvm-svn: 347687
2018-11-28 03:00:23 +08:00
|
|
|
recordStringTableReferenceAtOffset(contents, 8, strTableRefs);
|
2018-01-06 03:12:40 +08:00
|
|
|
break;
|
|
|
|
case SymbolKind::S_DEFRANGE:
|
|
|
|
case SymbolKind::S_DEFRANGE_SUBFIELD:
|
|
|
|
log("Not fixing up string table reference in S_DEFRANGE / "
|
|
|
|
"S_DEFRANGE_SUBFIELD record");
|
|
|
|
break;
|
2018-01-06 03:28:39 +08:00
|
|
|
default:
|
|
|
|
break;
|
2018-01-06 03:12:40 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-08-09 02:34:44 +08:00
|
|
|
static SymbolKind symbolKind(ArrayRef<uint8_t> recordData) {
|
|
|
|
const RecordPrefix *prefix =
|
|
|
|
reinterpret_cast<const RecordPrefix *>(recordData.data());
|
|
|
|
return static_cast<SymbolKind>(uint16_t(prefix->RecordKind));
|
|
|
|
}
|
|
|
|
|
|
|
|
/// MSVC translates S_PROC_ID_END to S_END, and S_[LG]PROC32_ID to S_[LG]PROC32
|
|
|
|
static void translateIdSymbols(MutableArrayRef<uint8_t> &recordData,
|
2017-11-30 03:35:21 +08:00
|
|
|
TypeCollection &iDTable) {
|
2017-08-09 02:34:44 +08:00
|
|
|
RecordPrefix *prefix = reinterpret_cast<RecordPrefix *>(recordData.data());
|
|
|
|
|
|
|
|
SymbolKind kind = symbolKind(recordData);
|
|
|
|
|
|
|
|
if (kind == SymbolKind::S_PROC_ID_END) {
|
|
|
|
prefix->RecordKind = SymbolKind::S_END;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// In an object file, GPROC32_ID has an embedded reference which refers to the
|
|
|
|
// single object file type index namespace. This has already been translated
|
|
|
|
// to the PDB file's ID stream index space, but we need to convert this to a
|
|
|
|
// symbol that refers to the type stream index space. So we remap again from
|
|
|
|
// ID index space to type index space.
|
|
|
|
if (kind == SymbolKind::S_GPROC32_ID || kind == SymbolKind::S_LPROC32_ID) {
|
|
|
|
SmallVector<TiReference, 1> refs;
|
|
|
|
auto content = recordData.drop_front(sizeof(RecordPrefix));
|
2019-04-04 08:28:48 +08:00
|
|
|
CVSymbol sym(recordData);
|
2017-08-09 02:34:44 +08:00
|
|
|
discoverTypeIndicesInSymbol(sym, refs);
|
|
|
|
assert(refs.size() == 1);
|
|
|
|
assert(refs.front().Count == 1);
|
2019-07-11 13:40:30 +08:00
|
|
|
|
2017-08-09 02:34:44 +08:00
|
|
|
TypeIndex *ti =
|
|
|
|
reinterpret_cast<TypeIndex *>(content.data() + refs[0].Offset);
|
2019-07-16 16:26:38 +08:00
|
|
|
// `ti` is the index of a FuncIdRecord or MemberFuncIdRecord which lives in
|
2017-08-09 02:34:44 +08:00
|
|
|
// the IPI stream, whose `FunctionType` member refers to the TPI stream.
|
|
|
|
// Note that LF_FUNC_ID and LF_MEMFUNC_ID have the same record layout, and
|
|
|
|
// in both cases we just need the second type index.
|
|
|
|
if (!ti->isSimple() && !ti->isNoneType()) {
|
2017-11-30 03:35:21 +08:00
|
|
|
CVType funcIdData = iDTable.getType(*ti);
|
2017-08-09 02:34:44 +08:00
|
|
|
SmallVector<TypeIndex, 2> indices;
|
|
|
|
discoverTypeIndices(funcIdData, indices);
|
|
|
|
assert(indices.size() == 2);
|
|
|
|
*ti = indices[1];
|
|
|
|
}
|
|
|
|
|
|
|
|
kind = (kind == SymbolKind::S_GPROC32_ID) ? SymbolKind::S_GPROC32
|
|
|
|
: SymbolKind::S_LPROC32;
|
|
|
|
prefix->RecordKind = uint16_t(kind);
|
|
|
|
}
|
2017-06-22 01:25:56 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Copy the symbol record. In a PDB, symbol records must be 4 byte aligned.
|
|
|
|
/// The object file may not be aligned.
|
[PDB] Add symbol records in bulk
Summary:
This speeds up linking clang.exe/pdb with /DEBUG:GHASH by 31%, from
12.9s to 9.8s.
Symbol records are typically small (16.7 bytes on average), but we
processed them one at a time. CVSymbol is a relatively "large" type. It
wraps an ArrayRef<uint8_t> with a kind an optional 32-bit hash, which we
don't need. Before this change, each DbiModuleDescriptorBuilder would
maintain an array of CVSymbols, and would write them individually with a
BinaryItemStream.
With this change, we now add symbols that happen to appear contiguously
in bulk. For each .debug$S section (roughly one per function), we
allocate two copies, one for relocation, and one for realignment
purposes. For runs of symbols that go in the module stream, which is
most symbols, we now add them as a single ArrayRef<uint8_t>, so the
vector DbiModuleDescriptorBuilder is roughly linear in the number of
.debug$S sections (O(# funcs)) instead of the number of symbol records
(very large).
Some stats on symbol sizes for the curious:
PDB size: 507M
sym bytes: 316,508,016
sym count: 18,954,971
sym byte avg: 16.7
As future work, we may be able to skip copying symbol records in the
linker for realignment purposes if we make LLVM write them aligned into
the object file. We need to double check that such symbol records are
still compatible with link.exe, but if so, it's definitely worth doing,
since my profile shows we spend 500ms in memcpy in the symbol merging
code. We could potentially cut that in half by saving a copy.
Alternatively, we could apply the relocations *after* we iterate the
symbols. This would require some careful re-engineering of the
relocation processing code, though.
Reviewers: zturner, aganea, ruiu
Subscribers: hiraditya, llvm-commits
Differential Revision: https://reviews.llvm.org/D54554
llvm-svn: 347687
2018-11-28 03:00:23 +08:00
|
|
|
static MutableArrayRef<uint8_t>
|
|
|
|
copyAndAlignSymbol(const CVSymbol &sym, MutableArrayRef<uint8_t> &alignedMem) {
|
2017-06-22 01:25:56 +08:00
|
|
|
size_t size = alignTo(sym.length(), alignOf(CodeViewContainer::Pdb));
|
|
|
|
assert(size >= 4 && "record too short");
|
|
|
|
assert(size <= MaxRecordLength && "record too long");
|
[PDB] Add symbol records in bulk
Summary:
This speeds up linking clang.exe/pdb with /DEBUG:GHASH by 31%, from
12.9s to 9.8s.
Symbol records are typically small (16.7 bytes on average), but we
processed them one at a time. CVSymbol is a relatively "large" type. It
wraps an ArrayRef<uint8_t> with a kind an optional 32-bit hash, which we
don't need. Before this change, each DbiModuleDescriptorBuilder would
maintain an array of CVSymbols, and would write them individually with a
BinaryItemStream.
With this change, we now add symbols that happen to appear contiguously
in bulk. For each .debug$S section (roughly one per function), we
allocate two copies, one for relocation, and one for realignment
purposes. For runs of symbols that go in the module stream, which is
most symbols, we now add them as a single ArrayRef<uint8_t>, so the
vector DbiModuleDescriptorBuilder is roughly linear in the number of
.debug$S sections (O(# funcs)) instead of the number of symbol records
(very large).
Some stats on symbol sizes for the curious:
PDB size: 507M
sym bytes: 316,508,016
sym count: 18,954,971
sym byte avg: 16.7
As future work, we may be able to skip copying symbol records in the
linker for realignment purposes if we make LLVM write them aligned into
the object file. We need to double check that such symbol records are
still compatible with link.exe, but if so, it's definitely worth doing,
since my profile shows we spend 500ms in memcpy in the symbol merging
code. We could potentially cut that in half by saving a copy.
Alternatively, we could apply the relocations *after* we iterate the
symbols. This would require some careful re-engineering of the
relocation processing code, though.
Reviewers: zturner, aganea, ruiu
Subscribers: hiraditya, llvm-commits
Differential Revision: https://reviews.llvm.org/D54554
llvm-svn: 347687
2018-11-28 03:00:23 +08:00
|
|
|
assert(alignedMem.size() >= size && "didn't preallocate enough");
|
2017-06-22 01:25:56 +08:00
|
|
|
|
|
|
|
// Copy the symbol record and zero out any padding bytes.
|
[PDB] Add symbol records in bulk
Summary:
This speeds up linking clang.exe/pdb with /DEBUG:GHASH by 31%, from
12.9s to 9.8s.
Symbol records are typically small (16.7 bytes on average), but we
processed them one at a time. CVSymbol is a relatively "large" type. It
wraps an ArrayRef<uint8_t> with a kind an optional 32-bit hash, which we
don't need. Before this change, each DbiModuleDescriptorBuilder would
maintain an array of CVSymbols, and would write them individually with a
BinaryItemStream.
With this change, we now add symbols that happen to appear contiguously
in bulk. For each .debug$S section (roughly one per function), we
allocate two copies, one for relocation, and one for realignment
purposes. For runs of symbols that go in the module stream, which is
most symbols, we now add them as a single ArrayRef<uint8_t>, so the
vector DbiModuleDescriptorBuilder is roughly linear in the number of
.debug$S sections (O(# funcs)) instead of the number of symbol records
(very large).
Some stats on symbol sizes for the curious:
PDB size: 507M
sym bytes: 316,508,016
sym count: 18,954,971
sym byte avg: 16.7
As future work, we may be able to skip copying symbol records in the
linker for realignment purposes if we make LLVM write them aligned into
the object file. We need to double check that such symbol records are
still compatible with link.exe, but if so, it's definitely worth doing,
since my profile shows we spend 500ms in memcpy in the symbol merging
code. We could potentially cut that in half by saving a copy.
Alternatively, we could apply the relocations *after* we iterate the
symbols. This would require some careful re-engineering of the
relocation processing code, though.
Reviewers: zturner, aganea, ruiu
Subscribers: hiraditya, llvm-commits
Differential Revision: https://reviews.llvm.org/D54554
llvm-svn: 347687
2018-11-28 03:00:23 +08:00
|
|
|
MutableArrayRef<uint8_t> newData = alignedMem.take_front(size);
|
|
|
|
alignedMem = alignedMem.drop_front(size);
|
2017-06-22 01:25:56 +08:00
|
|
|
memcpy(newData.data(), sym.data().data(), sym.length());
|
|
|
|
memset(newData.data() + sym.length(), 0, size - sym.length());
|
|
|
|
|
|
|
|
// Update the record prefix length. It should point to the beginning of the
|
2017-08-09 02:34:44 +08:00
|
|
|
// next record.
|
[PDB] Add symbol records in bulk
Summary:
This speeds up linking clang.exe/pdb with /DEBUG:GHASH by 31%, from
12.9s to 9.8s.
Symbol records are typically small (16.7 bytes on average), but we
processed them one at a time. CVSymbol is a relatively "large" type. It
wraps an ArrayRef<uint8_t> with a kind an optional 32-bit hash, which we
don't need. Before this change, each DbiModuleDescriptorBuilder would
maintain an array of CVSymbols, and would write them individually with a
BinaryItemStream.
With this change, we now add symbols that happen to appear contiguously
in bulk. For each .debug$S section (roughly one per function), we
allocate two copies, one for relocation, and one for realignment
purposes. For runs of symbols that go in the module stream, which is
most symbols, we now add them as a single ArrayRef<uint8_t>, so the
vector DbiModuleDescriptorBuilder is roughly linear in the number of
.debug$S sections (O(# funcs)) instead of the number of symbol records
(very large).
Some stats on symbol sizes for the curious:
PDB size: 507M
sym bytes: 316,508,016
sym count: 18,954,971
sym byte avg: 16.7
As future work, we may be able to skip copying symbol records in the
linker for realignment purposes if we make LLVM write them aligned into
the object file. We need to double check that such symbol records are
still compatible with link.exe, but if so, it's definitely worth doing,
since my profile shows we spend 500ms in memcpy in the symbol merging
code. We could potentially cut that in half by saving a copy.
Alternatively, we could apply the relocations *after* we iterate the
symbols. This would require some careful re-engineering of the
relocation processing code, though.
Reviewers: zturner, aganea, ruiu
Subscribers: hiraditya, llvm-commits
Differential Revision: https://reviews.llvm.org/D54554
llvm-svn: 347687
2018-11-28 03:00:23 +08:00
|
|
|
auto *prefix = reinterpret_cast<RecordPrefix *>(newData.data());
|
2017-06-22 01:25:56 +08:00
|
|
|
prefix->RecordLen = size - 2;
|
|
|
|
return newData;
|
|
|
|
}
|
|
|
|
|
2017-07-07 00:39:32 +08:00
|
|
|
struct ScopeRecord {
|
|
|
|
ulittle32_t ptrParent;
|
|
|
|
ulittle32_t ptrEnd;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct SymbolScope {
|
|
|
|
ScopeRecord *openingRecord;
|
|
|
|
uint32_t scopeOffset;
|
|
|
|
};
|
|
|
|
|
|
|
|
static void scopeStackOpen(SmallVectorImpl<SymbolScope> &stack,
|
|
|
|
uint32_t curOffset, CVSymbol &sym) {
|
|
|
|
assert(symbolOpensScope(sym.kind()));
|
|
|
|
SymbolScope s;
|
|
|
|
s.scopeOffset = curOffset;
|
|
|
|
s.openingRecord = const_cast<ScopeRecord *>(
|
|
|
|
reinterpret_cast<const ScopeRecord *>(sym.content().data()));
|
|
|
|
s.openingRecord->ptrParent = stack.empty() ? 0 : stack.back().scopeOffset;
|
|
|
|
stack.push_back(s);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void scopeStackClose(SmallVectorImpl<SymbolScope> &stack,
|
2019-03-30 04:25:34 +08:00
|
|
|
uint32_t curOffset, InputFile *file) {
|
2017-07-07 00:39:32 +08:00
|
|
|
if (stack.empty()) {
|
|
|
|
warn("symbol scopes are not balanced in " + file->getName());
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
SymbolScope s = stack.pop_back_val();
|
|
|
|
s.openingRecord->ptrEnd = curOffset;
|
|
|
|
}
|
|
|
|
|
2018-12-05 05:48:46 +08:00
|
|
|
static bool symbolGoesInModuleStream(const CVSymbol &sym, bool isGlobalScope) {
|
2017-08-12 03:00:03 +08:00
|
|
|
switch (sym.kind()) {
|
|
|
|
case SymbolKind::S_GDATA32:
|
|
|
|
case SymbolKind::S_CONSTANT:
|
|
|
|
// We really should not be seeing S_PROCREF and S_LPROCREF in the first place
|
|
|
|
// since they are synthesized by the linker in response to S_GPROC32 and
|
|
|
|
// S_LPROC32, but if we do see them, don't put them in the module stream I
|
|
|
|
// guess.
|
|
|
|
case SymbolKind::S_PROCREF:
|
|
|
|
case SymbolKind::S_LPROCREF:
|
|
|
|
return false;
|
2018-12-05 05:48:46 +08:00
|
|
|
// S_UDT records go in the module stream if it is not a global S_UDT.
|
|
|
|
case SymbolKind::S_UDT:
|
|
|
|
return !isGlobalScope;
|
2017-08-12 03:00:03 +08:00
|
|
|
// S_GDATA32 does not go in the module stream, but S_LDATA32 does.
|
|
|
|
case SymbolKind::S_LDATA32:
|
|
|
|
default:
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-12-05 05:48:46 +08:00
|
|
|
static bool symbolGoesInGlobalsStream(const CVSymbol &sym, bool isGlobalScope) {
|
2017-08-12 03:00:03 +08:00
|
|
|
switch (sym.kind()) {
|
|
|
|
case SymbolKind::S_CONSTANT:
|
|
|
|
case SymbolKind::S_GDATA32:
|
|
|
|
// S_LDATA32 goes in both the module stream and the globals stream.
|
|
|
|
case SymbolKind::S_LDATA32:
|
|
|
|
case SymbolKind::S_GPROC32:
|
|
|
|
case SymbolKind::S_LPROC32:
|
|
|
|
// We really should not be seeing S_PROCREF and S_LPROCREF in the first place
|
|
|
|
// since they are synthesized by the linker in response to S_GPROC32 and
|
|
|
|
// S_LPROC32, but if we do see them, copy them straight through.
|
|
|
|
case SymbolKind::S_PROCREF:
|
|
|
|
case SymbolKind::S_LPROCREF:
|
|
|
|
return true;
|
2018-12-05 05:48:46 +08:00
|
|
|
// S_UDT records go in the globals stream if it is a global S_UDT.
|
2017-08-15 02:44:58 +08:00
|
|
|
case SymbolKind::S_UDT:
|
2018-12-05 05:48:46 +08:00
|
|
|
return isGlobalScope;
|
2017-08-12 03:00:03 +08:00
|
|
|
default:
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
[PDB] Add symbol records in bulk
Summary:
This speeds up linking clang.exe/pdb with /DEBUG:GHASH by 31%, from
12.9s to 9.8s.
Symbol records are typically small (16.7 bytes on average), but we
processed them one at a time. CVSymbol is a relatively "large" type. It
wraps an ArrayRef<uint8_t> with a kind an optional 32-bit hash, which we
don't need. Before this change, each DbiModuleDescriptorBuilder would
maintain an array of CVSymbols, and would write them individually with a
BinaryItemStream.
With this change, we now add symbols that happen to appear contiguously
in bulk. For each .debug$S section (roughly one per function), we
allocate two copies, one for relocation, and one for realignment
purposes. For runs of symbols that go in the module stream, which is
most symbols, we now add them as a single ArrayRef<uint8_t>, so the
vector DbiModuleDescriptorBuilder is roughly linear in the number of
.debug$S sections (O(# funcs)) instead of the number of symbol records
(very large).
Some stats on symbol sizes for the curious:
PDB size: 507M
sym bytes: 316,508,016
sym count: 18,954,971
sym byte avg: 16.7
As future work, we may be able to skip copying symbol records in the
linker for realignment purposes if we make LLVM write them aligned into
the object file. We need to double check that such symbol records are
still compatible with link.exe, but if so, it's definitely worth doing,
since my profile shows we spend 500ms in memcpy in the symbol merging
code. We could potentially cut that in half by saving a copy.
Alternatively, we could apply the relocations *after* we iterate the
symbols. This would require some careful re-engineering of the
relocation processing code, though.
Reviewers: zturner, aganea, ruiu
Subscribers: hiraditya, llvm-commits
Differential Revision: https://reviews.llvm.org/D54554
llvm-svn: 347687
2018-11-28 03:00:23 +08:00
|
|
|
static void addGlobalSymbol(pdb::GSIStreamBuilder &builder, uint16_t modIndex,
|
|
|
|
unsigned symOffset, const CVSymbol &sym) {
|
2017-08-12 03:00:03 +08:00
|
|
|
switch (sym.kind()) {
|
|
|
|
case SymbolKind::S_CONSTANT:
|
|
|
|
case SymbolKind::S_UDT:
|
|
|
|
case SymbolKind::S_GDATA32:
|
|
|
|
case SymbolKind::S_LDATA32:
|
|
|
|
case SymbolKind::S_PROCREF:
|
|
|
|
case SymbolKind::S_LPROCREF:
|
|
|
|
builder.addGlobalSymbol(sym);
|
|
|
|
break;
|
|
|
|
case SymbolKind::S_GPROC32:
|
|
|
|
case SymbolKind::S_LPROC32: {
|
|
|
|
SymbolRecordKind k = SymbolRecordKind::ProcRefSym;
|
|
|
|
if (sym.kind() == SymbolKind::S_LPROC32)
|
|
|
|
k = SymbolRecordKind::LocalProcRef;
|
|
|
|
ProcRefSym ps(k);
|
[PDB] Add symbol records in bulk
Summary:
This speeds up linking clang.exe/pdb with /DEBUG:GHASH by 31%, from
12.9s to 9.8s.
Symbol records are typically small (16.7 bytes on average), but we
processed them one at a time. CVSymbol is a relatively "large" type. It
wraps an ArrayRef<uint8_t> with a kind an optional 32-bit hash, which we
don't need. Before this change, each DbiModuleDescriptorBuilder would
maintain an array of CVSymbols, and would write them individually with a
BinaryItemStream.
With this change, we now add symbols that happen to appear contiguously
in bulk. For each .debug$S section (roughly one per function), we
allocate two copies, one for relocation, and one for realignment
purposes. For runs of symbols that go in the module stream, which is
most symbols, we now add them as a single ArrayRef<uint8_t>, so the
vector DbiModuleDescriptorBuilder is roughly linear in the number of
.debug$S sections (O(# funcs)) instead of the number of symbol records
(very large).
Some stats on symbol sizes for the curious:
PDB size: 507M
sym bytes: 316,508,016
sym count: 18,954,971
sym byte avg: 16.7
As future work, we may be able to skip copying symbol records in the
linker for realignment purposes if we make LLVM write them aligned into
the object file. We need to double check that such symbol records are
still compatible with link.exe, but if so, it's definitely worth doing,
since my profile shows we spend 500ms in memcpy in the symbol merging
code. We could potentially cut that in half by saving a copy.
Alternatively, we could apply the relocations *after* we iterate the
symbols. This would require some careful re-engineering of the
relocation processing code, though.
Reviewers: zturner, aganea, ruiu
Subscribers: hiraditya, llvm-commits
Differential Revision: https://reviews.llvm.org/D54554
llvm-svn: 347687
2018-11-28 03:00:23 +08:00
|
|
|
ps.Module = modIndex;
|
2017-08-12 03:00:03 +08:00
|
|
|
// For some reason, MSVC seems to add one to this value.
|
|
|
|
++ps.Module;
|
|
|
|
ps.Name = getSymbolName(sym);
|
|
|
|
ps.SumName = 0;
|
[PDB] Add symbol records in bulk
Summary:
This speeds up linking clang.exe/pdb with /DEBUG:GHASH by 31%, from
12.9s to 9.8s.
Symbol records are typically small (16.7 bytes on average), but we
processed them one at a time. CVSymbol is a relatively "large" type. It
wraps an ArrayRef<uint8_t> with a kind an optional 32-bit hash, which we
don't need. Before this change, each DbiModuleDescriptorBuilder would
maintain an array of CVSymbols, and would write them individually with a
BinaryItemStream.
With this change, we now add symbols that happen to appear contiguously
in bulk. For each .debug$S section (roughly one per function), we
allocate two copies, one for relocation, and one for realignment
purposes. For runs of symbols that go in the module stream, which is
most symbols, we now add them as a single ArrayRef<uint8_t>, so the
vector DbiModuleDescriptorBuilder is roughly linear in the number of
.debug$S sections (O(# funcs)) instead of the number of symbol records
(very large).
Some stats on symbol sizes for the curious:
PDB size: 507M
sym bytes: 316,508,016
sym count: 18,954,971
sym byte avg: 16.7
As future work, we may be able to skip copying symbol records in the
linker for realignment purposes if we make LLVM write them aligned into
the object file. We need to double check that such symbol records are
still compatible with link.exe, but if so, it's definitely worth doing,
since my profile shows we spend 500ms in memcpy in the symbol merging
code. We could potentially cut that in half by saving a copy.
Alternatively, we could apply the relocations *after* we iterate the
symbols. This would require some careful re-engineering of the
relocation processing code, though.
Reviewers: zturner, aganea, ruiu
Subscribers: hiraditya, llvm-commits
Differential Revision: https://reviews.llvm.org/D54554
llvm-svn: 347687
2018-11-28 03:00:23 +08:00
|
|
|
ps.SymOffset = symOffset;
|
2017-08-12 03:00:03 +08:00
|
|
|
builder.addGlobalSymbol(ps);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
llvm_unreachable("Invalid symbol kind!");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-11-14 07:44:39 +08:00
|
|
|
void PDBLinker::mergeSymbolRecords(ObjFile *file, const CVIndexMap &indexMap,
|
|
|
|
std::vector<ulittle32_t *> &stringTableRefs,
|
|
|
|
BinaryStreamRef symData) {
|
2018-01-19 02:35:01 +08:00
|
|
|
ArrayRef<uint8_t> symsBuffer;
|
|
|
|
cantFail(symData.readBytes(0, symData.getLength(), symsBuffer));
|
2017-07-07 00:39:32 +08:00
|
|
|
SmallVector<SymbolScope, 4> scopes;
|
2018-01-06 03:12:40 +08:00
|
|
|
|
[PDB] Add symbol records in bulk
Summary:
This speeds up linking clang.exe/pdb with /DEBUG:GHASH by 31%, from
12.9s to 9.8s.
Symbol records are typically small (16.7 bytes on average), but we
processed them one at a time. CVSymbol is a relatively "large" type. It
wraps an ArrayRef<uint8_t> with a kind an optional 32-bit hash, which we
don't need. Before this change, each DbiModuleDescriptorBuilder would
maintain an array of CVSymbols, and would write them individually with a
BinaryItemStream.
With this change, we now add symbols that happen to appear contiguously
in bulk. For each .debug$S section (roughly one per function), we
allocate two copies, one for relocation, and one for realignment
purposes. For runs of symbols that go in the module stream, which is
most symbols, we now add them as a single ArrayRef<uint8_t>, so the
vector DbiModuleDescriptorBuilder is roughly linear in the number of
.debug$S sections (O(# funcs)) instead of the number of symbol records
(very large).
Some stats on symbol sizes for the curious:
PDB size: 507M
sym bytes: 316,508,016
sym count: 18,954,971
sym byte avg: 16.7
As future work, we may be able to skip copying symbol records in the
linker for realignment purposes if we make LLVM write them aligned into
the object file. We need to double check that such symbol records are
still compatible with link.exe, but if so, it's definitely worth doing,
since my profile shows we spend 500ms in memcpy in the symbol merging
code. We could potentially cut that in half by saving a copy.
Alternatively, we could apply the relocations *after* we iterate the
symbols. This would require some careful re-engineering of the
relocation processing code, though.
Reviewers: zturner, aganea, ruiu
Subscribers: hiraditya, llvm-commits
Differential Revision: https://reviews.llvm.org/D54554
llvm-svn: 347687
2018-11-28 03:00:23 +08:00
|
|
|
// Iterate every symbol to check if any need to be realigned, and if so, how
|
|
|
|
// much space we need to allocate for them.
|
|
|
|
bool needsRealignment = false;
|
2018-12-18 09:14:05 +08:00
|
|
|
unsigned totalRealignedSize = 0;
|
2018-01-19 02:35:01 +08:00
|
|
|
auto ec = forEachCodeViewRecord<CVSymbol>(
|
2018-11-14 07:44:39 +08:00
|
|
|
symsBuffer, [&](CVSymbol sym) -> llvm::Error {
|
2018-12-18 09:14:05 +08:00
|
|
|
unsigned realignedSize =
|
|
|
|
alignTo(sym.length(), alignOf(CodeViewContainer::Pdb));
|
[PDB] Add symbol records in bulk
Summary:
This speeds up linking clang.exe/pdb with /DEBUG:GHASH by 31%, from
12.9s to 9.8s.
Symbol records are typically small (16.7 bytes on average), but we
processed them one at a time. CVSymbol is a relatively "large" type. It
wraps an ArrayRef<uint8_t> with a kind an optional 32-bit hash, which we
don't need. Before this change, each DbiModuleDescriptorBuilder would
maintain an array of CVSymbols, and would write them individually with a
BinaryItemStream.
With this change, we now add symbols that happen to appear contiguously
in bulk. For each .debug$S section (roughly one per function), we
allocate two copies, one for relocation, and one for realignment
purposes. For runs of symbols that go in the module stream, which is
most symbols, we now add them as a single ArrayRef<uint8_t>, so the
vector DbiModuleDescriptorBuilder is roughly linear in the number of
.debug$S sections (O(# funcs)) instead of the number of symbol records
(very large).
Some stats on symbol sizes for the curious:
PDB size: 507M
sym bytes: 316,508,016
sym count: 18,954,971
sym byte avg: 16.7
As future work, we may be able to skip copying symbol records in the
linker for realignment purposes if we make LLVM write them aligned into
the object file. We need to double check that such symbol records are
still compatible with link.exe, but if so, it's definitely worth doing,
since my profile shows we spend 500ms in memcpy in the symbol merging
code. We could potentially cut that in half by saving a copy.
Alternatively, we could apply the relocations *after* we iterate the
symbols. This would require some careful re-engineering of the
relocation processing code, though.
Reviewers: zturner, aganea, ruiu
Subscribers: hiraditya, llvm-commits
Differential Revision: https://reviews.llvm.org/D54554
llvm-svn: 347687
2018-11-28 03:00:23 +08:00
|
|
|
needsRealignment |= realignedSize != sym.length();
|
2018-12-18 09:14:05 +08:00
|
|
|
totalRealignedSize += realignedSize;
|
[PDB] Add symbol records in bulk
Summary:
This speeds up linking clang.exe/pdb with /DEBUG:GHASH by 31%, from
12.9s to 9.8s.
Symbol records are typically small (16.7 bytes on average), but we
processed them one at a time. CVSymbol is a relatively "large" type. It
wraps an ArrayRef<uint8_t> with a kind an optional 32-bit hash, which we
don't need. Before this change, each DbiModuleDescriptorBuilder would
maintain an array of CVSymbols, and would write them individually with a
BinaryItemStream.
With this change, we now add symbols that happen to appear contiguously
in bulk. For each .debug$S section (roughly one per function), we
allocate two copies, one for relocation, and one for realignment
purposes. For runs of symbols that go in the module stream, which is
most symbols, we now add them as a single ArrayRef<uint8_t>, so the
vector DbiModuleDescriptorBuilder is roughly linear in the number of
.debug$S sections (O(# funcs)) instead of the number of symbol records
(very large).
Some stats on symbol sizes for the curious:
PDB size: 507M
sym bytes: 316,508,016
sym count: 18,954,971
sym byte avg: 16.7
As future work, we may be able to skip copying symbol records in the
linker for realignment purposes if we make LLVM write them aligned into
the object file. We need to double check that such symbol records are
still compatible with link.exe, but if so, it's definitely worth doing,
since my profile shows we spend 500ms in memcpy in the symbol merging
code. We could potentially cut that in half by saving a copy.
Alternatively, we could apply the relocations *after* we iterate the
symbols. This would require some careful re-engineering of the
relocation processing code, though.
Reviewers: zturner, aganea, ruiu
Subscribers: hiraditya, llvm-commits
Differential Revision: https://reviews.llvm.org/D54554
llvm-svn: 347687
2018-11-28 03:00:23 +08:00
|
|
|
return Error::success();
|
|
|
|
});
|
|
|
|
|
|
|
|
// If any of the symbol record lengths was corrupt, ignore them all, warn
|
|
|
|
// about it, and move on.
|
|
|
|
if (ec) {
|
|
|
|
warn("corrupt symbol records in " + file->getName());
|
|
|
|
consumeError(std::move(ec));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// If any symbol needed realignment, allocate enough contiguous memory for
|
|
|
|
// them all. Typically symbol subsections are small enough that this will not
|
|
|
|
// cause fragmentation.
|
|
|
|
MutableArrayRef<uint8_t> alignedSymbolMem;
|
|
|
|
if (needsRealignment) {
|
|
|
|
void *alignedData =
|
2018-12-18 09:14:05 +08:00
|
|
|
alloc.Allocate(totalRealignedSize, alignOf(CodeViewContainer::Pdb));
|
[PDB] Add symbol records in bulk
Summary:
This speeds up linking clang.exe/pdb with /DEBUG:GHASH by 31%, from
12.9s to 9.8s.
Symbol records are typically small (16.7 bytes on average), but we
processed them one at a time. CVSymbol is a relatively "large" type. It
wraps an ArrayRef<uint8_t> with a kind an optional 32-bit hash, which we
don't need. Before this change, each DbiModuleDescriptorBuilder would
maintain an array of CVSymbols, and would write them individually with a
BinaryItemStream.
With this change, we now add symbols that happen to appear contiguously
in bulk. For each .debug$S section (roughly one per function), we
allocate two copies, one for relocation, and one for realignment
purposes. For runs of symbols that go in the module stream, which is
most symbols, we now add them as a single ArrayRef<uint8_t>, so the
vector DbiModuleDescriptorBuilder is roughly linear in the number of
.debug$S sections (O(# funcs)) instead of the number of symbol records
(very large).
Some stats on symbol sizes for the curious:
PDB size: 507M
sym bytes: 316,508,016
sym count: 18,954,971
sym byte avg: 16.7
As future work, we may be able to skip copying symbol records in the
linker for realignment purposes if we make LLVM write them aligned into
the object file. We need to double check that such symbol records are
still compatible with link.exe, but if so, it's definitely worth doing,
since my profile shows we spend 500ms in memcpy in the symbol merging
code. We could potentially cut that in half by saving a copy.
Alternatively, we could apply the relocations *after* we iterate the
symbols. This would require some careful re-engineering of the
relocation processing code, though.
Reviewers: zturner, aganea, ruiu
Subscribers: hiraditya, llvm-commits
Differential Revision: https://reviews.llvm.org/D54554
llvm-svn: 347687
2018-11-28 03:00:23 +08:00
|
|
|
alignedSymbolMem = makeMutableArrayRef(
|
2018-12-18 09:14:05 +08:00
|
|
|
reinterpret_cast<uint8_t *>(alignedData), totalRealignedSize);
|
[PDB] Add symbol records in bulk
Summary:
This speeds up linking clang.exe/pdb with /DEBUG:GHASH by 31%, from
12.9s to 9.8s.
Symbol records are typically small (16.7 bytes on average), but we
processed them one at a time. CVSymbol is a relatively "large" type. It
wraps an ArrayRef<uint8_t> with a kind an optional 32-bit hash, which we
don't need. Before this change, each DbiModuleDescriptorBuilder would
maintain an array of CVSymbols, and would write them individually with a
BinaryItemStream.
With this change, we now add symbols that happen to appear contiguously
in bulk. For each .debug$S section (roughly one per function), we
allocate two copies, one for relocation, and one for realignment
purposes. For runs of symbols that go in the module stream, which is
most symbols, we now add them as a single ArrayRef<uint8_t>, so the
vector DbiModuleDescriptorBuilder is roughly linear in the number of
.debug$S sections (O(# funcs)) instead of the number of symbol records
(very large).
Some stats on symbol sizes for the curious:
PDB size: 507M
sym bytes: 316,508,016
sym count: 18,954,971
sym byte avg: 16.7
As future work, we may be able to skip copying symbol records in the
linker for realignment purposes if we make LLVM write them aligned into
the object file. We need to double check that such symbol records are
still compatible with link.exe, but if so, it's definitely worth doing,
since my profile shows we spend 500ms in memcpy in the symbol merging
code. We could potentially cut that in half by saving a copy.
Alternatively, we could apply the relocations *after* we iterate the
symbols. This would require some careful re-engineering of the
relocation processing code, though.
Reviewers: zturner, aganea, ruiu
Subscribers: hiraditya, llvm-commits
Differential Revision: https://reviews.llvm.org/D54554
llvm-svn: 347687
2018-11-28 03:00:23 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// Iterate again, this time doing the real work.
|
|
|
|
unsigned curSymOffset = file->moduleDBI->getNextSymbolOffset();
|
|
|
|
ArrayRef<uint8_t> bulkSymbols;
|
|
|
|
cantFail(forEachCodeViewRecord<CVSymbol>(
|
|
|
|
symsBuffer, [&](CVSymbol sym) -> llvm::Error {
|
|
|
|
// Align the record if required.
|
|
|
|
MutableArrayRef<uint8_t> recordBytes;
|
|
|
|
if (needsRealignment) {
|
|
|
|
recordBytes = copyAndAlignSymbol(sym, alignedSymbolMem);
|
2019-04-04 08:28:48 +08:00
|
|
|
sym = CVSymbol(recordBytes);
|
[PDB] Add symbol records in bulk
Summary:
This speeds up linking clang.exe/pdb with /DEBUG:GHASH by 31%, from
12.9s to 9.8s.
Symbol records are typically small (16.7 bytes on average), but we
processed them one at a time. CVSymbol is a relatively "large" type. It
wraps an ArrayRef<uint8_t> with a kind an optional 32-bit hash, which we
don't need. Before this change, each DbiModuleDescriptorBuilder would
maintain an array of CVSymbols, and would write them individually with a
BinaryItemStream.
With this change, we now add symbols that happen to appear contiguously
in bulk. For each .debug$S section (roughly one per function), we
allocate two copies, one for relocation, and one for realignment
purposes. For runs of symbols that go in the module stream, which is
most symbols, we now add them as a single ArrayRef<uint8_t>, so the
vector DbiModuleDescriptorBuilder is roughly linear in the number of
.debug$S sections (O(# funcs)) instead of the number of symbol records
(very large).
Some stats on symbol sizes for the curious:
PDB size: 507M
sym bytes: 316,508,016
sym count: 18,954,971
sym byte avg: 16.7
As future work, we may be able to skip copying symbol records in the
linker for realignment purposes if we make LLVM write them aligned into
the object file. We need to double check that such symbol records are
still compatible with link.exe, but if so, it's definitely worth doing,
since my profile shows we spend 500ms in memcpy in the symbol merging
code. We could potentially cut that in half by saving a copy.
Alternatively, we could apply the relocations *after* we iterate the
symbols. This would require some careful re-engineering of the
relocation processing code, though.
Reviewers: zturner, aganea, ruiu
Subscribers: hiraditya, llvm-commits
Differential Revision: https://reviews.llvm.org/D54554
llvm-svn: 347687
2018-11-28 03:00:23 +08:00
|
|
|
} else {
|
|
|
|
// Otherwise, we can actually mutate the symbol directly, since we
|
|
|
|
// copied it to apply relocations.
|
|
|
|
recordBytes = makeMutableArrayRef(
|
|
|
|
const_cast<uint8_t *>(sym.data().data()), sym.length());
|
|
|
|
}
|
|
|
|
|
2018-01-19 02:35:01 +08:00
|
|
|
// Discover type index references in the record. Skip it if we don't
|
|
|
|
// know where they are.
|
|
|
|
SmallVector<TiReference, 32> typeRefs;
|
|
|
|
if (!discoverTypeIndicesInSymbol(sym, typeRefs)) {
|
|
|
|
log("ignoring unknown symbol record with kind 0x" +
|
|
|
|
utohexstr(sym.kind()));
|
|
|
|
return Error::success();
|
|
|
|
}
|
|
|
|
|
|
|
|
// Re-map all the type index references.
|
[PDB] Add symbol records in bulk
Summary:
This speeds up linking clang.exe/pdb with /DEBUG:GHASH by 31%, from
12.9s to 9.8s.
Symbol records are typically small (16.7 bytes on average), but we
processed them one at a time. CVSymbol is a relatively "large" type. It
wraps an ArrayRef<uint8_t> with a kind an optional 32-bit hash, which we
don't need. Before this change, each DbiModuleDescriptorBuilder would
maintain an array of CVSymbols, and would write them individually with a
BinaryItemStream.
With this change, we now add symbols that happen to appear contiguously
in bulk. For each .debug$S section (roughly one per function), we
allocate two copies, one for relocation, and one for realignment
purposes. For runs of symbols that go in the module stream, which is
most symbols, we now add them as a single ArrayRef<uint8_t>, so the
vector DbiModuleDescriptorBuilder is roughly linear in the number of
.debug$S sections (O(# funcs)) instead of the number of symbol records
(very large).
Some stats on symbol sizes for the curious:
PDB size: 507M
sym bytes: 316,508,016
sym count: 18,954,971
sym byte avg: 16.7
As future work, we may be able to skip copying symbol records in the
linker for realignment purposes if we make LLVM write them aligned into
the object file. We need to double check that such symbol records are
still compatible with link.exe, but if so, it's definitely worth doing,
since my profile shows we spend 500ms in memcpy in the symbol merging
code. We could potentially cut that in half by saving a copy.
Alternatively, we could apply the relocations *after* we iterate the
symbols. This would require some careful re-engineering of the
relocation processing code, though.
Reviewers: zturner, aganea, ruiu
Subscribers: hiraditya, llvm-commits
Differential Revision: https://reviews.llvm.org/D54554
llvm-svn: 347687
2018-11-28 03:00:23 +08:00
|
|
|
remapTypesInSymbolRecord(file, sym.kind(), recordBytes, indexMap,
|
2018-01-19 02:35:01 +08:00
|
|
|
typeRefs);
|
|
|
|
|
|
|
|
// An object file may have S_xxx_ID symbols, but these get converted to
|
|
|
|
// "real" symbols in a PDB.
|
2019-04-03 04:43:19 +08:00
|
|
|
translateIdSymbols(recordBytes, tMerger.getIDTable());
|
2019-04-04 08:28:48 +08:00
|
|
|
sym = CVSymbol(recordBytes);
|
2018-01-19 02:35:01 +08:00
|
|
|
|
|
|
|
// If this record refers to an offset in the object file's string table,
|
|
|
|
// add that item to the global PDB string table and re-write the index.
|
[PDB] Add symbol records in bulk
Summary:
This speeds up linking clang.exe/pdb with /DEBUG:GHASH by 31%, from
12.9s to 9.8s.
Symbol records are typically small (16.7 bytes on average), but we
processed them one at a time. CVSymbol is a relatively "large" type. It
wraps an ArrayRef<uint8_t> with a kind an optional 32-bit hash, which we
don't need. Before this change, each DbiModuleDescriptorBuilder would
maintain an array of CVSymbols, and would write them individually with a
BinaryItemStream.
With this change, we now add symbols that happen to appear contiguously
in bulk. For each .debug$S section (roughly one per function), we
allocate two copies, one for relocation, and one for realignment
purposes. For runs of symbols that go in the module stream, which is
most symbols, we now add them as a single ArrayRef<uint8_t>, so the
vector DbiModuleDescriptorBuilder is roughly linear in the number of
.debug$S sections (O(# funcs)) instead of the number of symbol records
(very large).
Some stats on symbol sizes for the curious:
PDB size: 507M
sym bytes: 316,508,016
sym count: 18,954,971
sym byte avg: 16.7
As future work, we may be able to skip copying symbol records in the
linker for realignment purposes if we make LLVM write them aligned into
the object file. We need to double check that such symbol records are
still compatible with link.exe, but if so, it's definitely worth doing,
since my profile shows we spend 500ms in memcpy in the symbol merging
code. We could potentially cut that in half by saving a copy.
Alternatively, we could apply the relocations *after* we iterate the
symbols. This would require some careful re-engineering of the
relocation processing code, though.
Reviewers: zturner, aganea, ruiu
Subscribers: hiraditya, llvm-commits
Differential Revision: https://reviews.llvm.org/D54554
llvm-svn: 347687
2018-11-28 03:00:23 +08:00
|
|
|
recordStringTableReferences(sym.kind(), recordBytes, stringTableRefs);
|
2018-01-19 02:35:01 +08:00
|
|
|
|
|
|
|
// Fill in "Parent" and "End" fields by maintaining a stack of scopes.
|
2018-11-14 07:44:39 +08:00
|
|
|
if (symbolOpensScope(sym.kind()))
|
[PDB] Add symbol records in bulk
Summary:
This speeds up linking clang.exe/pdb with /DEBUG:GHASH by 31%, from
12.9s to 9.8s.
Symbol records are typically small (16.7 bytes on average), but we
processed them one at a time. CVSymbol is a relatively "large" type. It
wraps an ArrayRef<uint8_t> with a kind an optional 32-bit hash, which we
don't need. Before this change, each DbiModuleDescriptorBuilder would
maintain an array of CVSymbols, and would write them individually with a
BinaryItemStream.
With this change, we now add symbols that happen to appear contiguously
in bulk. For each .debug$S section (roughly one per function), we
allocate two copies, one for relocation, and one for realignment
purposes. For runs of symbols that go in the module stream, which is
most symbols, we now add them as a single ArrayRef<uint8_t>, so the
vector DbiModuleDescriptorBuilder is roughly linear in the number of
.debug$S sections (O(# funcs)) instead of the number of symbol records
(very large).
Some stats on symbol sizes for the curious:
PDB size: 507M
sym bytes: 316,508,016
sym count: 18,954,971
sym byte avg: 16.7
As future work, we may be able to skip copying symbol records in the
linker for realignment purposes if we make LLVM write them aligned into
the object file. We need to double check that such symbol records are
still compatible with link.exe, but if so, it's definitely worth doing,
since my profile shows we spend 500ms in memcpy in the symbol merging
code. We could potentially cut that in half by saving a copy.
Alternatively, we could apply the relocations *after* we iterate the
symbols. This would require some careful re-engineering of the
relocation processing code, though.
Reviewers: zturner, aganea, ruiu
Subscribers: hiraditya, llvm-commits
Differential Revision: https://reviews.llvm.org/D54554
llvm-svn: 347687
2018-11-28 03:00:23 +08:00
|
|
|
scopeStackOpen(scopes, curSymOffset, sym);
|
2018-11-14 07:44:39 +08:00
|
|
|
else if (symbolEndsScope(sym.kind()))
|
[PDB] Add symbol records in bulk
Summary:
This speeds up linking clang.exe/pdb with /DEBUG:GHASH by 31%, from
12.9s to 9.8s.
Symbol records are typically small (16.7 bytes on average), but we
processed them one at a time. CVSymbol is a relatively "large" type. It
wraps an ArrayRef<uint8_t> with a kind an optional 32-bit hash, which we
don't need. Before this change, each DbiModuleDescriptorBuilder would
maintain an array of CVSymbols, and would write them individually with a
BinaryItemStream.
With this change, we now add symbols that happen to appear contiguously
in bulk. For each .debug$S section (roughly one per function), we
allocate two copies, one for relocation, and one for realignment
purposes. For runs of symbols that go in the module stream, which is
most symbols, we now add them as a single ArrayRef<uint8_t>, so the
vector DbiModuleDescriptorBuilder is roughly linear in the number of
.debug$S sections (O(# funcs)) instead of the number of symbol records
(very large).
Some stats on symbol sizes for the curious:
PDB size: 507M
sym bytes: 316,508,016
sym count: 18,954,971
sym byte avg: 16.7
As future work, we may be able to skip copying symbol records in the
linker for realignment purposes if we make LLVM write them aligned into
the object file. We need to double check that such symbol records are
still compatible with link.exe, but if so, it's definitely worth doing,
since my profile shows we spend 500ms in memcpy in the symbol merging
code. We could potentially cut that in half by saving a copy.
Alternatively, we could apply the relocations *after* we iterate the
symbols. This would require some careful re-engineering of the
relocation processing code, though.
Reviewers: zturner, aganea, ruiu
Subscribers: hiraditya, llvm-commits
Differential Revision: https://reviews.llvm.org/D54554
llvm-svn: 347687
2018-11-28 03:00:23 +08:00
|
|
|
scopeStackClose(scopes, curSymOffset, file);
|
2018-01-19 02:35:01 +08:00
|
|
|
|
|
|
|
// Add the symbol to the globals stream if necessary. Do this before
|
|
|
|
// adding the symbol to the module since we may need to get the next
|
|
|
|
// symbol offset, and writing to the module's symbol stream will update
|
|
|
|
// that offset.
|
2019-03-15 02:45:08 +08:00
|
|
|
if (symbolGoesInGlobalsStream(sym, scopes.empty())) {
|
[PDB] Add symbol records in bulk
Summary:
This speeds up linking clang.exe/pdb with /DEBUG:GHASH by 31%, from
12.9s to 9.8s.
Symbol records are typically small (16.7 bytes on average), but we
processed them one at a time. CVSymbol is a relatively "large" type. It
wraps an ArrayRef<uint8_t> with a kind an optional 32-bit hash, which we
don't need. Before this change, each DbiModuleDescriptorBuilder would
maintain an array of CVSymbols, and would write them individually with a
BinaryItemStream.
With this change, we now add symbols that happen to appear contiguously
in bulk. For each .debug$S section (roughly one per function), we
allocate two copies, one for relocation, and one for realignment
purposes. For runs of symbols that go in the module stream, which is
most symbols, we now add them as a single ArrayRef<uint8_t>, so the
vector DbiModuleDescriptorBuilder is roughly linear in the number of
.debug$S sections (O(# funcs)) instead of the number of symbol records
(very large).
Some stats on symbol sizes for the curious:
PDB size: 507M
sym bytes: 316,508,016
sym count: 18,954,971
sym byte avg: 16.7
As future work, we may be able to skip copying symbol records in the
linker for realignment purposes if we make LLVM write them aligned into
the object file. We need to double check that such symbol records are
still compatible with link.exe, but if so, it's definitely worth doing,
since my profile shows we spend 500ms in memcpy in the symbol merging
code. We could potentially cut that in half by saving a copy.
Alternatively, we could apply the relocations *after* we iterate the
symbols. This would require some careful re-engineering of the
relocation processing code, though.
Reviewers: zturner, aganea, ruiu
Subscribers: hiraditya, llvm-commits
Differential Revision: https://reviews.llvm.org/D54554
llvm-svn: 347687
2018-11-28 03:00:23 +08:00
|
|
|
addGlobalSymbol(builder.getGsiBuilder(),
|
|
|
|
file->moduleDBI->getModuleIndex(), curSymOffset, sym);
|
2019-03-15 02:45:08 +08:00
|
|
|
++globalSymbols;
|
|
|
|
}
|
[PDB] Add symbol records in bulk
Summary:
This speeds up linking clang.exe/pdb with /DEBUG:GHASH by 31%, from
12.9s to 9.8s.
Symbol records are typically small (16.7 bytes on average), but we
processed them one at a time. CVSymbol is a relatively "large" type. It
wraps an ArrayRef<uint8_t> with a kind an optional 32-bit hash, which we
don't need. Before this change, each DbiModuleDescriptorBuilder would
maintain an array of CVSymbols, and would write them individually with a
BinaryItemStream.
With this change, we now add symbols that happen to appear contiguously
in bulk. For each .debug$S section (roughly one per function), we
allocate two copies, one for relocation, and one for realignment
purposes. For runs of symbols that go in the module stream, which is
most symbols, we now add them as a single ArrayRef<uint8_t>, so the
vector DbiModuleDescriptorBuilder is roughly linear in the number of
.debug$S sections (O(# funcs)) instead of the number of symbol records
(very large).
Some stats on symbol sizes for the curious:
PDB size: 507M
sym bytes: 316,508,016
sym count: 18,954,971
sym byte avg: 16.7
As future work, we may be able to skip copying symbol records in the
linker for realignment purposes if we make LLVM write them aligned into
the object file. We need to double check that such symbol records are
still compatible with link.exe, but if so, it's definitely worth doing,
since my profile shows we spend 500ms in memcpy in the symbol merging
code. We could potentially cut that in half by saving a copy.
Alternatively, we could apply the relocations *after* we iterate the
symbols. This would require some careful re-engineering of the
relocation processing code, though.
Reviewers: zturner, aganea, ruiu
Subscribers: hiraditya, llvm-commits
Differential Revision: https://reviews.llvm.org/D54554
llvm-svn: 347687
2018-11-28 03:00:23 +08:00
|
|
|
|
2018-12-05 05:48:46 +08:00
|
|
|
if (symbolGoesInModuleStream(sym, scopes.empty())) {
|
[PDB] Add symbol records in bulk
Summary:
This speeds up linking clang.exe/pdb with /DEBUG:GHASH by 31%, from
12.9s to 9.8s.
Symbol records are typically small (16.7 bytes on average), but we
processed them one at a time. CVSymbol is a relatively "large" type. It
wraps an ArrayRef<uint8_t> with a kind an optional 32-bit hash, which we
don't need. Before this change, each DbiModuleDescriptorBuilder would
maintain an array of CVSymbols, and would write them individually with a
BinaryItemStream.
With this change, we now add symbols that happen to appear contiguously
in bulk. For each .debug$S section (roughly one per function), we
allocate two copies, one for relocation, and one for realignment
purposes. For runs of symbols that go in the module stream, which is
most symbols, we now add them as a single ArrayRef<uint8_t>, so the
vector DbiModuleDescriptorBuilder is roughly linear in the number of
.debug$S sections (O(# funcs)) instead of the number of symbol records
(very large).
Some stats on symbol sizes for the curious:
PDB size: 507M
sym bytes: 316,508,016
sym count: 18,954,971
sym byte avg: 16.7
As future work, we may be able to skip copying symbol records in the
linker for realignment purposes if we make LLVM write them aligned into
the object file. We need to double check that such symbol records are
still compatible with link.exe, but if so, it's definitely worth doing,
since my profile shows we spend 500ms in memcpy in the symbol merging
code. We could potentially cut that in half by saving a copy.
Alternatively, we could apply the relocations *after* we iterate the
symbols. This would require some careful re-engineering of the
relocation processing code, though.
Reviewers: zturner, aganea, ruiu
Subscribers: hiraditya, llvm-commits
Differential Revision: https://reviews.llvm.org/D54554
llvm-svn: 347687
2018-11-28 03:00:23 +08:00
|
|
|
// Add symbols to the module in bulk. If this symbol is contiguous
|
|
|
|
// with the previous run of symbols to add, combine the ranges. If
|
|
|
|
// not, close the previous range of symbols and start a new one.
|
|
|
|
if (sym.data().data() == bulkSymbols.end()) {
|
|
|
|
bulkSymbols = makeArrayRef(bulkSymbols.data(),
|
|
|
|
bulkSymbols.size() + sym.length());
|
|
|
|
} else {
|
|
|
|
file->moduleDBI->addSymbolsInBulk(bulkSymbols);
|
|
|
|
bulkSymbols = recordBytes;
|
|
|
|
}
|
|
|
|
curSymOffset += sym.length();
|
2019-03-15 02:45:08 +08:00
|
|
|
++moduleSymbols;
|
[PDB] Add symbol records in bulk
Summary:
This speeds up linking clang.exe/pdb with /DEBUG:GHASH by 31%, from
12.9s to 9.8s.
Symbol records are typically small (16.7 bytes on average), but we
processed them one at a time. CVSymbol is a relatively "large" type. It
wraps an ArrayRef<uint8_t> with a kind an optional 32-bit hash, which we
don't need. Before this change, each DbiModuleDescriptorBuilder would
maintain an array of CVSymbols, and would write them individually with a
BinaryItemStream.
With this change, we now add symbols that happen to appear contiguously
in bulk. For each .debug$S section (roughly one per function), we
allocate two copies, one for relocation, and one for realignment
purposes. For runs of symbols that go in the module stream, which is
most symbols, we now add them as a single ArrayRef<uint8_t>, so the
vector DbiModuleDescriptorBuilder is roughly linear in the number of
.debug$S sections (O(# funcs)) instead of the number of symbol records
(very large).
Some stats on symbol sizes for the curious:
PDB size: 507M
sym bytes: 316,508,016
sym count: 18,954,971
sym byte avg: 16.7
As future work, we may be able to skip copying symbol records in the
linker for realignment purposes if we make LLVM write them aligned into
the object file. We need to double check that such symbol records are
still compatible with link.exe, but if so, it's definitely worth doing,
since my profile shows we spend 500ms in memcpy in the symbol merging
code. We could potentially cut that in half by saving a copy.
Alternatively, we could apply the relocations *after* we iterate the
symbols. This would require some careful re-engineering of the
relocation processing code, though.
Reviewers: zturner, aganea, ruiu
Subscribers: hiraditya, llvm-commits
Differential Revision: https://reviews.llvm.org/D54554
llvm-svn: 347687
2018-11-28 03:00:23 +08:00
|
|
|
}
|
2018-01-19 02:35:01 +08:00
|
|
|
return Error::success();
|
[PDB] Add symbol records in bulk
Summary:
This speeds up linking clang.exe/pdb with /DEBUG:GHASH by 31%, from
12.9s to 9.8s.
Symbol records are typically small (16.7 bytes on average), but we
processed them one at a time. CVSymbol is a relatively "large" type. It
wraps an ArrayRef<uint8_t> with a kind an optional 32-bit hash, which we
don't need. Before this change, each DbiModuleDescriptorBuilder would
maintain an array of CVSymbols, and would write them individually with a
BinaryItemStream.
With this change, we now add symbols that happen to appear contiguously
in bulk. For each .debug$S section (roughly one per function), we
allocate two copies, one for relocation, and one for realignment
purposes. For runs of symbols that go in the module stream, which is
most symbols, we now add them as a single ArrayRef<uint8_t>, so the
vector DbiModuleDescriptorBuilder is roughly linear in the number of
.debug$S sections (O(# funcs)) instead of the number of symbol records
(very large).
Some stats on symbol sizes for the curious:
PDB size: 507M
sym bytes: 316,508,016
sym count: 18,954,971
sym byte avg: 16.7
As future work, we may be able to skip copying symbol records in the
linker for realignment purposes if we make LLVM write them aligned into
the object file. We need to double check that such symbol records are
still compatible with link.exe, but if so, it's definitely worth doing,
since my profile shows we spend 500ms in memcpy in the symbol merging
code. We could potentially cut that in half by saving a copy.
Alternatively, we could apply the relocations *after* we iterate the
symbols. This would require some careful re-engineering of the
relocation processing code, though.
Reviewers: zturner, aganea, ruiu
Subscribers: hiraditya, llvm-commits
Differential Revision: https://reviews.llvm.org/D54554
llvm-svn: 347687
2018-11-28 03:00:23 +08:00
|
|
|
}));
|
|
|
|
|
|
|
|
// Add any remaining symbols we've accumulated.
|
|
|
|
file->moduleDBI->addSymbolsInBulk(bulkSymbols);
|
2017-06-22 01:25:56 +08:00
|
|
|
}
|
|
|
|
|
2018-09-13 05:02:01 +08:00
|
|
|
// Allocate memory for a .debug$S / .debug$F section and relocate it.
|
2017-06-20 01:21:45 +08:00
|
|
|
static ArrayRef<uint8_t> relocateDebugChunk(BumpPtrAllocator &alloc,
|
2018-09-13 05:02:01 +08:00
|
|
|
SectionChunk &debugChunk) {
|
|
|
|
uint8_t *buffer = alloc.Allocate<uint8_t>(debugChunk.getSize());
|
2019-05-25 02:25:49 +08:00
|
|
|
assert(debugChunk.getOutputSectionIdx() == 0 &&
|
2017-06-20 01:21:45 +08:00
|
|
|
"debug sections should not be in output sections");
|
2018-09-13 05:02:01 +08:00
|
|
|
debugChunk.writeTo(buffer);
|
|
|
|
return makeArrayRef(buffer, debugChunk.getSize());
|
2017-06-20 01:21:45 +08:00
|
|
|
}
|
|
|
|
|
2018-04-21 02:00:46 +08:00
|
|
|
static pdb::SectionContrib createSectionContrib(const Chunk *c, uint32_t modi) {
|
2019-03-19 03:13:23 +08:00
|
|
|
OutputSection *os = c ? c->getOutputSection() : nullptr;
|
2018-04-21 02:00:46 +08:00
|
|
|
pdb::SectionContrib sc;
|
|
|
|
memset(&sc, 0, sizeof(sc));
|
2019-03-19 03:13:23 +08:00
|
|
|
sc.ISect = os ? os->sectionIndex : llvm::pdb::kInvalidStreamIndex;
|
|
|
|
sc.Off = c && os ? c->getRVA() - os->getRVA() : 0;
|
|
|
|
sc.Size = c ? c->getSize() : -1;
|
|
|
|
if (auto *secChunk = dyn_cast_or_null<SectionChunk>(c)) {
|
2018-04-21 02:00:46 +08:00
|
|
|
sc.Characteristics = secChunk->header->Characteristics;
|
|
|
|
sc.Imod = secChunk->file->moduleDBI->getModuleIndex();
|
|
|
|
ArrayRef<uint8_t> contents = secChunk->getContents();
|
|
|
|
JamCRC crc(0);
|
|
|
|
ArrayRef<char> charContents = makeArrayRef(
|
|
|
|
reinterpret_cast<const char *>(contents.data()), contents.size());
|
|
|
|
crc.update(charContents);
|
|
|
|
sc.DataCrc = crc.getCRC();
|
|
|
|
} else {
|
2019-03-19 03:13:23 +08:00
|
|
|
sc.Characteristics = os ? os->header.Characteristics : 0;
|
2018-04-21 02:00:46 +08:00
|
|
|
sc.Imod = modi;
|
|
|
|
}
|
|
|
|
sc.RelocCrc = 0; // FIXME
|
|
|
|
|
|
|
|
return sc;
|
|
|
|
}
|
|
|
|
|
2018-09-12 06:35:01 +08:00
|
|
|
static uint32_t
|
|
|
|
translateStringTableIndex(uint32_t objIndex,
|
|
|
|
const DebugStringTableSubsectionRef &objStrTable,
|
|
|
|
DebugStringTableSubsection &pdbStrTable) {
|
|
|
|
auto expectedString = objStrTable.getString(objIndex);
|
|
|
|
if (!expectedString) {
|
|
|
|
warn("Invalid string table reference");
|
|
|
|
consumeError(expectedString.takeError());
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return pdbStrTable.insert(*expectedString);
|
|
|
|
}
|
|
|
|
|
2018-09-13 05:02:01 +08:00
|
|
|
void DebugSHandler::handleDebugS(lld::coff::SectionChunk &debugS) {
|
|
|
|
DebugSubsectionArray subsections;
|
|
|
|
|
2019-02-23 09:46:18 +08:00
|
|
|
ArrayRef<uint8_t> relocatedDebugContents = SectionChunk::consumeDebugMagic(
|
2018-09-13 05:02:01 +08:00
|
|
|
relocateDebugChunk(linker.alloc, debugS), debugS.getSectionName());
|
|
|
|
|
|
|
|
BinaryStreamReader reader(relocatedDebugContents, support::little);
|
|
|
|
exitOnErr(reader.readArray(subsections, relocatedDebugContents.size()));
|
|
|
|
|
|
|
|
for (const DebugSubsectionRecord &ss : subsections) {
|
2019-06-19 03:41:25 +08:00
|
|
|
// Ignore subsections with the 'ignore' bit. Some versions of the Visual C++
|
|
|
|
// runtime have subsections with this bit set.
|
|
|
|
if (uint32_t(ss.kind()) & codeview::SubsectionIgnoreFlag)
|
|
|
|
continue;
|
|
|
|
|
2018-09-13 05:02:01 +08:00
|
|
|
switch (ss.kind()) {
|
|
|
|
case DebugSubsectionKind::StringTable: {
|
|
|
|
assert(!cVStrTab.valid() &&
|
|
|
|
"Encountered multiple string table subsections!");
|
|
|
|
exitOnErr(cVStrTab.initialize(ss.getRecordData()));
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case DebugSubsectionKind::FileChecksums:
|
|
|
|
assert(!checksums.valid() &&
|
|
|
|
"Encountered multiple checksum subsections!");
|
|
|
|
exitOnErr(checksums.initialize(ss.getRecordData()));
|
|
|
|
break;
|
|
|
|
case DebugSubsectionKind::Lines:
|
|
|
|
// We can add the relocated line table directly to the PDB without
|
|
|
|
// modification because the file checksum offsets will stay the same.
|
|
|
|
file.moduleDBI->addDebugSubsection(ss);
|
|
|
|
break;
|
2019-06-04 02:15:38 +08:00
|
|
|
case DebugSubsectionKind::InlineeLines:
|
|
|
|
assert(!inlineeLines.valid() &&
|
|
|
|
"Encountered multiple inlinee lines subsections!");
|
|
|
|
exitOnErr(inlineeLines.initialize(ss.getRecordData()));
|
|
|
|
break;
|
2018-09-13 05:02:01 +08:00
|
|
|
case DebugSubsectionKind::FrameData: {
|
|
|
|
// We need to re-write string table indices here, so save off all
|
|
|
|
// frame data subsections until we've processed the entire list of
|
|
|
|
// subsections so that we can be sure we have the string table.
|
|
|
|
DebugFrameDataSubsectionRef fds;
|
|
|
|
exitOnErr(fds.initialize(ss.getRecordData()));
|
|
|
|
newFpoFrames.push_back(std::move(fds));
|
|
|
|
break;
|
|
|
|
}
|
2018-11-10 09:36:02 +08:00
|
|
|
case DebugSubsectionKind::Symbols: {
|
2018-11-14 07:44:39 +08:00
|
|
|
linker.mergeSymbolRecords(&file, indexMap, stringTableReferences,
|
|
|
|
ss.getRecordData());
|
2018-09-13 05:02:01 +08:00
|
|
|
break;
|
2018-11-10 09:36:02 +08:00
|
|
|
}
|
2019-06-04 02:15:38 +08:00
|
|
|
|
|
|
|
case DebugSubsectionKind::CrossScopeImports:
|
|
|
|
case DebugSubsectionKind::CrossScopeExports:
|
|
|
|
// These appear to relate to cross-module optimization, so we might use
|
|
|
|
// these for ThinLTO.
|
|
|
|
break;
|
|
|
|
|
|
|
|
case DebugSubsectionKind::ILLines:
|
|
|
|
case DebugSubsectionKind::FuncMDTokenMap:
|
|
|
|
case DebugSubsectionKind::TypeMDTokenMap:
|
|
|
|
case DebugSubsectionKind::MergedAssemblyInput:
|
|
|
|
// These appear to relate to .Net assembly info.
|
|
|
|
break;
|
|
|
|
|
|
|
|
case DebugSubsectionKind::CoffSymbolRVA:
|
|
|
|
// Unclear what this is for.
|
|
|
|
break;
|
|
|
|
|
2018-09-13 05:02:01 +08:00
|
|
|
default:
|
2019-06-04 02:15:38 +08:00
|
|
|
warn("ignoring unknown debug$S subsection kind 0x" +
|
2019-06-15 06:03:23 +08:00
|
|
|
utohexstr(uint32_t(ss.kind())) + " in file " + toString(&file));
|
2018-09-13 05:02:01 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-04 02:15:38 +08:00
|
|
|
static Expected<StringRef>
|
|
|
|
getFileName(const DebugStringTableSubsectionRef &strings,
|
|
|
|
const DebugChecksumsSubsectionRef &checksums, uint32_t fileID) {
|
|
|
|
auto iter = checksums.getArray().at(fileID);
|
|
|
|
if (iter == checksums.getArray().end())
|
|
|
|
return make_error<CodeViewError>(cv_error_code::no_records);
|
|
|
|
uint32_t offset = iter->FileNameOffset;
|
|
|
|
return strings.getString(offset);
|
|
|
|
}
|
|
|
|
|
|
|
|
std::shared_ptr<DebugInlineeLinesSubsection>
|
|
|
|
DebugSHandler::mergeInlineeLines(DebugChecksumsSubsection *newChecksums) {
|
|
|
|
auto newInlineeLines = std::make_shared<DebugInlineeLinesSubsection>(
|
|
|
|
*newChecksums, inlineeLines.hasExtraFiles());
|
2019-07-11 13:40:30 +08:00
|
|
|
|
2019-06-04 02:15:38 +08:00
|
|
|
for (const InlineeSourceLine &line : inlineeLines) {
|
|
|
|
TypeIndex inlinee = line.Header->Inlinee;
|
|
|
|
uint32_t fileID = line.Header->FileID;
|
|
|
|
uint32_t sourceLine = line.Header->SourceLineNum;
|
2019-07-11 13:40:30 +08:00
|
|
|
|
2019-06-04 02:15:38 +08:00
|
|
|
ArrayRef<TypeIndex> typeOrItemMap =
|
|
|
|
indexMap.isTypeServerMap ? indexMap.ipiMap : indexMap.tpiMap;
|
|
|
|
if (!remapTypeIndex(inlinee, typeOrItemMap)) {
|
|
|
|
log("ignoring inlinee line record in " + file.getName() +
|
|
|
|
" with bad inlinee index 0x" + utohexstr(inlinee.getIndex()));
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
SmallString<128> filename =
|
|
|
|
exitOnErr(getFileName(cVStrTab, checksums, fileID));
|
|
|
|
pdbMakeAbsolute(filename);
|
|
|
|
newInlineeLines->addInlineSite(inlinee, filename, sourceLine);
|
|
|
|
|
|
|
|
if (inlineeLines.hasExtraFiles()) {
|
|
|
|
for (uint32_t extraFileId : line.ExtraFiles) {
|
|
|
|
filename = exitOnErr(getFileName(cVStrTab, checksums, extraFileId));
|
|
|
|
pdbMakeAbsolute(filename);
|
|
|
|
newInlineeLines->addExtraFile(filename);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return newInlineeLines;
|
|
|
|
}
|
|
|
|
|
2018-09-13 05:02:01 +08:00
|
|
|
void DebugSHandler::finish() {
|
|
|
|
pdb::DbiStreamBuilder &dbiBuilder = linker.builder.getDbiBuilder();
|
|
|
|
|
|
|
|
// We should have seen all debug subsections across the entire object file now
|
|
|
|
// which means that if a StringTable subsection and Checksums subsection were
|
|
|
|
// present, now is the time to handle them.
|
|
|
|
if (!cVStrTab.valid()) {
|
|
|
|
if (checksums.valid())
|
|
|
|
fatal(".debug$S sections with a checksums subsection must also contain a "
|
|
|
|
"string table subsection");
|
|
|
|
|
|
|
|
if (!stringTableReferences.empty())
|
|
|
|
warn("No StringTable subsection was encountered, but there are string "
|
|
|
|
"table references");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Rewrite string table indices in the Fpo Data and symbol records to refer to
|
|
|
|
// the global PDB string table instead of the object file string table.
|
|
|
|
for (DebugFrameDataSubsectionRef &fds : newFpoFrames) {
|
2018-11-21 05:30:11 +08:00
|
|
|
const ulittle32_t *reloc = fds.getRelocPtr();
|
2018-09-13 05:02:01 +08:00
|
|
|
for (codeview::FrameData fd : fds) {
|
|
|
|
fd.RvaStart += *reloc;
|
|
|
|
fd.FrameFunc =
|
|
|
|
translateStringTableIndex(fd.FrameFunc, cVStrTab, linker.pdbStrTab);
|
|
|
|
dbiBuilder.addNewFpoData(fd);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for (ulittle32_t *ref : stringTableReferences)
|
|
|
|
*ref = translateStringTableIndex(*ref, cVStrTab, linker.pdbStrTab);
|
|
|
|
|
|
|
|
// Make a new file checksum table that refers to offsets in the PDB-wide
|
|
|
|
// string table. Generally the string table subsection appears after the
|
|
|
|
// checksum table, so we have to do this after looping over all the
|
|
|
|
// subsections.
|
2019-08-15 06:28:17 +08:00
|
|
|
auto newChecksums = std::make_unique<DebugChecksumsSubsection>(linker.pdbStrTab);
|
2018-09-13 05:02:01 +08:00
|
|
|
for (FileChecksumEntry &fc : checksums) {
|
2019-06-04 02:15:38 +08:00
|
|
|
SmallString<128> filename =
|
2018-09-13 05:02:01 +08:00
|
|
|
exitOnErr(cVStrTab.getString(fc.FileNameOffset));
|
2019-06-04 02:15:38 +08:00
|
|
|
pdbMakeAbsolute(filename);
|
|
|
|
exitOnErr(dbiBuilder.addModuleSourceFile(*file.moduleDBI, filename));
|
|
|
|
newChecksums->addChecksum(filename, fc.Kind, fc.Checksum);
|
2018-09-13 05:02:01 +08:00
|
|
|
}
|
2019-06-04 02:15:38 +08:00
|
|
|
|
|
|
|
// Rewrite inlinee item indices if present.
|
|
|
|
if (inlineeLines.valid())
|
|
|
|
file.moduleDBI->addDebugSubsection(mergeInlineeLines(newChecksums.get()));
|
|
|
|
|
2018-09-13 05:02:01 +08:00
|
|
|
file.moduleDBI->addDebugSubsection(std::move(newChecksums));
|
|
|
|
}
|
|
|
|
|
2018-11-06 03:20:47 +08:00
|
|
|
void PDBLinker::addObjFile(ObjFile *file, CVIndexMap *externIndexMap) {
|
2019-03-23 06:07:27 +08:00
|
|
|
if (file->mergedIntoPDB)
|
2018-11-06 03:20:47 +08:00
|
|
|
return;
|
2019-03-23 06:07:27 +08:00
|
|
|
file->mergedIntoPDB = true;
|
2018-04-21 02:00:46 +08:00
|
|
|
|
2017-07-14 08:14:58 +08:00
|
|
|
// Before we can process symbol substreams from .debug$S, we need to process
|
|
|
|
// type information, file checksums, and the string table. Add type info to
|
|
|
|
// the PDB first, so that we can get the map from object file type and item
|
|
|
|
// indices to PDB type and item indices.
|
2017-07-18 08:21:25 +08:00
|
|
|
CVIndexMap objectIndexMap;
|
2018-11-06 03:20:47 +08:00
|
|
|
auto indexMapResult =
|
|
|
|
mergeDebugT(file, externIndexMap ? externIndexMap : &objectIndexMap);
|
2018-02-01 01:48:04 +08:00
|
|
|
|
|
|
|
// If the .debug$T sections fail to merge, assume there is no debug info.
|
|
|
|
if (!indexMapResult) {
|
2019-01-12 04:39:38 +08:00
|
|
|
if (!config->warnDebugInfoUnusable) {
|
|
|
|
consumeError(indexMapResult.takeError());
|
2019-01-12 03:10:01 +08:00
|
|
|
return;
|
2019-01-12 04:39:38 +08:00
|
|
|
}
|
2019-03-23 06:07:27 +08:00
|
|
|
warn("Cannot use debug info for '" + toString(file) + "' [LNK4099]\n" +
|
2018-09-10 21:51:21 +08:00
|
|
|
">>> failed to load reference " +
|
|
|
|
StringRef(toString(indexMapResult.takeError())));
|
2018-02-01 01:48:04 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2018-01-18 03:16:26 +08:00
|
|
|
ScopedTimer t(symbolMergingTimer);
|
|
|
|
|
2019-03-23 06:07:27 +08:00
|
|
|
pdb::DbiStreamBuilder &dbiBuilder = builder.getDbiBuilder();
|
2018-09-13 05:02:01 +08:00
|
|
|
DebugSHandler dsh(*this, *file, *indexMapResult);
|
|
|
|
// Now do all live .debug$S and .debug$F sections.
|
2017-07-14 08:14:58 +08:00
|
|
|
for (SectionChunk *debugChunk : file->getDebugChunks()) {
|
2018-09-13 05:02:01 +08:00
|
|
|
if (!debugChunk->live || debugChunk->getSize() == 0)
|
2017-07-14 08:14:58 +08:00
|
|
|
continue;
|
2017-06-20 01:21:45 +08:00
|
|
|
|
2018-09-13 05:02:01 +08:00
|
|
|
if (debugChunk->getSectionName() == ".debug$S") {
|
|
|
|
dsh.handleDebugS(*debugChunk);
|
2017-07-14 08:14:58 +08:00
|
|
|
continue;
|
|
|
|
}
|
2017-06-20 01:21:45 +08:00
|
|
|
|
2018-09-13 05:02:01 +08:00
|
|
|
if (debugChunk->getSectionName() == ".debug$F") {
|
|
|
|
ArrayRef<uint8_t> relocatedDebugContents =
|
|
|
|
relocateDebugChunk(alloc, *debugChunk);
|
2018-01-06 03:12:40 +08:00
|
|
|
|
2018-09-13 05:02:01 +08:00
|
|
|
FixedStreamArray<object::FpoData> fpoRecords;
|
|
|
|
BinaryStreamReader reader(relocatedDebugContents, support::little);
|
|
|
|
uint32_t count = relocatedDebugContents.size() / sizeof(object::FpoData);
|
|
|
|
exitOnErr(reader.readArray(fpoRecords, count));
|
2018-01-06 03:12:40 +08:00
|
|
|
|
2018-09-13 05:02:01 +08:00
|
|
|
// These are already relocated and don't refer to the string table, so we
|
|
|
|
// can just copy it.
|
|
|
|
for (const object::FpoData &fd : fpoRecords)
|
|
|
|
dbiBuilder.addOldFpoData(fd);
|
|
|
|
continue;
|
2017-06-20 01:21:45 +08:00
|
|
|
}
|
2018-01-06 03:12:40 +08:00
|
|
|
}
|
|
|
|
|
2018-09-13 05:02:01 +08:00
|
|
|
// Do any post-processing now that all .debug$S sections have been processed.
|
|
|
|
dsh.finish();
|
2017-07-14 08:14:58 +08:00
|
|
|
}
|
2017-01-12 11:09:25 +08:00
|
|
|
|
2019-03-23 06:07:27 +08:00
|
|
|
// Add a module descriptor for every object file. We need to put an absolute
|
|
|
|
// path to the object into the PDB. If this is a plain object, we make its
|
|
|
|
// path absolute. If it's an object in an archive, we make the archive path
|
|
|
|
// absolute.
|
|
|
|
static void createModuleDBI(pdb::PDBFileBuilder &builder) {
|
|
|
|
pdb::DbiStreamBuilder &dbiBuilder = builder.getDbiBuilder();
|
|
|
|
SmallString<128> objName;
|
|
|
|
|
|
|
|
for (ObjFile *file : ObjFile::instances) {
|
|
|
|
|
|
|
|
bool inArchive = !file->parentName.empty();
|
|
|
|
objName = inArchive ? file->parentName : file->getName();
|
|
|
|
pdbMakeAbsolute(objName);
|
|
|
|
StringRef modName = inArchive ? file->getName() : StringRef(objName);
|
|
|
|
|
|
|
|
file->moduleDBI = &exitOnErr(dbiBuilder.addModuleInfo(modName));
|
|
|
|
file->moduleDBI->setObjFileName(objName);
|
|
|
|
|
|
|
|
ArrayRef<Chunk *> chunks = file->getChunks();
|
|
|
|
uint32_t modi = file->moduleDBI->getModuleIndex();
|
|
|
|
|
|
|
|
for (Chunk *c : chunks) {
|
|
|
|
auto *secChunk = dyn_cast<SectionChunk>(c);
|
|
|
|
if (!secChunk || !secChunk->live)
|
|
|
|
continue;
|
|
|
|
pdb::SectionContrib sc = createSectionContrib(secChunk, modi);
|
|
|
|
file->moduleDBI->setFirstSectionContrib(sc);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-07-28 02:25:59 +08:00
|
|
|
static PublicSym32 createPublic(Defined *def) {
|
|
|
|
PublicSym32 pub(SymbolKind::S_PUB32);
|
|
|
|
pub.Name = def->getName();
|
|
|
|
if (auto *d = dyn_cast<DefinedCOFF>(def)) {
|
|
|
|
if (d->getCOFFSymbol().isFunctionDefinition())
|
|
|
|
pub.Flags = PublicSymFlags::Function;
|
|
|
|
} else if (isa<DefinedImportThunk>(def)) {
|
|
|
|
pub.Flags = PublicSymFlags::Function;
|
|
|
|
}
|
|
|
|
|
|
|
|
OutputSection *os = def->getChunk()->getOutputSection();
|
|
|
|
assert(os && "all publics should be in final image");
|
|
|
|
pub.Offset = def->getRVA() - os->getRVA();
|
|
|
|
pub.Segment = os->sectionIndex;
|
|
|
|
return pub;
|
|
|
|
}
|
|
|
|
|
2017-07-14 08:14:58 +08:00
|
|
|
// Add all object files to the PDB. Merge .debug$T sections into IpiData and
|
|
|
|
// TpiData.
|
|
|
|
void PDBLinker::addObjectsToPDB() {
|
2018-01-18 03:16:26 +08:00
|
|
|
ScopedTimer t1(addObjectsTimer);
|
2019-03-23 06:07:27 +08:00
|
|
|
|
|
|
|
createModuleDBI(builder);
|
|
|
|
|
2017-07-27 08:45:26 +08:00
|
|
|
for (ObjFile *file : ObjFile::instances)
|
2017-07-27 07:05:24 +08:00
|
|
|
addObjFile(file);
|
2017-07-14 08:14:58 +08:00
|
|
|
|
|
|
|
builder.getStringTableBuilder().setStrings(pdbStrTab);
|
2018-01-18 03:16:26 +08:00
|
|
|
t1.stop();
|
2017-06-20 01:21:45 +08:00
|
|
|
|
2017-12-15 02:07:04 +08:00
|
|
|
// Construct TPI and IPI stream contents.
|
2018-01-18 03:16:26 +08:00
|
|
|
ScopedTimer t2(tpiStreamLayoutTimer);
|
2019-04-03 04:43:19 +08:00
|
|
|
addTypeInfo(builder.getTpiBuilder(), tMerger.getTypeTable());
|
|
|
|
addTypeInfo(builder.getIpiBuilder(), tMerger.getIDTable());
|
2018-01-18 03:16:26 +08:00
|
|
|
t2.stop();
|
2017-07-14 08:14:58 +08:00
|
|
|
|
2018-01-18 03:16:26 +08:00
|
|
|
ScopedTimer t3(globalsLayoutTimer);
|
2017-08-12 03:00:03 +08:00
|
|
|
// Compute the public and global symbols.
|
|
|
|
auto &gsiBuilder = builder.getGsiBuilder();
|
2017-07-28 02:25:59 +08:00
|
|
|
std::vector<PublicSym32> publics;
|
2017-11-04 05:21:47 +08:00
|
|
|
symtab->forEachSymbol([&publics](Symbol *s) {
|
2017-07-28 02:25:59 +08:00
|
|
|
// Only emit defined, live symbols that have a chunk.
|
2017-11-01 00:10:24 +08:00
|
|
|
auto *def = dyn_cast<Defined>(s);
|
2017-07-28 02:25:59 +08:00
|
|
|
if (def && def->isLive() && def->getChunk())
|
|
|
|
publics.push_back(createPublic(def));
|
|
|
|
});
|
2017-07-14 08:14:58 +08:00
|
|
|
|
2017-07-28 02:25:59 +08:00
|
|
|
if (!publics.empty()) {
|
2019-03-15 02:45:08 +08:00
|
|
|
publicSymbols = publics.size();
|
2017-07-28 02:25:59 +08:00
|
|
|
// Sort the public symbols and add them to the stream.
|
2019-02-28 04:53:50 +08:00
|
|
|
parallelSort(publics, [](const PublicSym32 &l, const PublicSym32 &r) {
|
|
|
|
return l.Name < r.Name;
|
|
|
|
});
|
2017-07-28 02:25:59 +08:00
|
|
|
for (const PublicSym32 &pub : publics)
|
2017-08-09 12:23:25 +08:00
|
|
|
gsiBuilder.addPublicSymbol(pub);
|
2017-07-28 02:25:59 +08:00
|
|
|
}
|
2017-01-12 11:09:25 +08:00
|
|
|
}
|
|
|
|
|
2019-03-15 02:45:08 +08:00
|
|
|
void PDBLinker::printStats() {
|
|
|
|
if (!config->showSummary)
|
|
|
|
return;
|
|
|
|
|
|
|
|
SmallString<256> buffer;
|
|
|
|
raw_svector_ostream stream(buffer);
|
|
|
|
|
|
|
|
stream << center_justify("Summary", 80) << '\n'
|
|
|
|
<< std::string(80, '-') << '\n';
|
|
|
|
|
|
|
|
auto print = [&](uint64_t v, StringRef s) {
|
|
|
|
stream << format_decimal(v, 15) << " " << s << '\n';
|
|
|
|
};
|
|
|
|
|
|
|
|
print(ObjFile::instances.size(),
|
|
|
|
"Input OBJ files (expanded from all cmd-line inputs)");
|
|
|
|
print(typeServerIndexMappings.size(), "PDB type server dependencies");
|
|
|
|
print(precompTypeIndexMappings.size(), "Precomp OBJ dependencies");
|
2019-04-03 04:43:19 +08:00
|
|
|
print(tMerger.getTypeTable().size() + tMerger.getIDTable().size(),
|
|
|
|
"Merged TPI records");
|
2019-03-15 02:45:08 +08:00
|
|
|
print(pdbStrTab.size(), "Output PDB strings");
|
|
|
|
print(globalSymbols, "Global symbol records");
|
|
|
|
print(moduleSymbols, "Module symbol records");
|
|
|
|
print(publicSymbols, "Public symbol records");
|
|
|
|
|
|
|
|
message(buffer);
|
|
|
|
}
|
|
|
|
|
2018-03-24 03:57:25 +08:00
|
|
|
void PDBLinker::addNatvisFiles() {
|
|
|
|
for (StringRef file : config->natvisFiles) {
|
|
|
|
ErrorOr<std::unique_ptr<MemoryBuffer>> dataOrErr =
|
|
|
|
MemoryBuffer::getFile(file);
|
|
|
|
if (!dataOrErr) {
|
|
|
|
warn("Cannot open input file: " + file);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
builder.addInjectedSource(file, std::move(*dataOrErr));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-04-17 02:17:13 +08:00
|
|
|
static codeview::CPUType toCodeViewMachine(COFF::MachineTypes machine) {
|
|
|
|
switch (machine) {
|
|
|
|
case COFF::IMAGE_FILE_MACHINE_AMD64:
|
|
|
|
return codeview::CPUType::X64;
|
|
|
|
case COFF::IMAGE_FILE_MACHINE_ARM:
|
|
|
|
return codeview::CPUType::ARM7;
|
|
|
|
case COFF::IMAGE_FILE_MACHINE_ARM64:
|
|
|
|
return codeview::CPUType::ARM64;
|
|
|
|
case COFF::IMAGE_FILE_MACHINE_ARMNT:
|
|
|
|
return codeview::CPUType::ARMNT;
|
|
|
|
case COFF::IMAGE_FILE_MACHINE_I386:
|
|
|
|
return codeview::CPUType::Intel80386;
|
|
|
|
default:
|
|
|
|
llvm_unreachable("Unsupported CPU Type");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-12-01 00:36:40 +08:00
|
|
|
// Mimic MSVC which surrounds arguments containing whitespace with quotes.
|
|
|
|
// Double double-quotes are handled, so that the resulting string can be
|
|
|
|
// executed again on the cmd-line.
|
|
|
|
static std::string quote(ArrayRef<StringRef> args) {
|
|
|
|
std::string r;
|
|
|
|
r.reserve(256);
|
|
|
|
for (StringRef a : args) {
|
|
|
|
if (!r.empty())
|
|
|
|
r.push_back(' ');
|
|
|
|
bool hasWS = a.find(' ') != StringRef::npos;
|
|
|
|
bool hasQ = a.find('"') != StringRef::npos;
|
|
|
|
if (hasWS || hasQ)
|
|
|
|
r.push_back('"');
|
|
|
|
if (hasQ) {
|
|
|
|
SmallVector<StringRef, 4> s;
|
|
|
|
a.split(s, '"');
|
|
|
|
r.append(join(s, "\"\""));
|
|
|
|
} else {
|
|
|
|
r.append(a);
|
|
|
|
}
|
|
|
|
if (hasWS || hasQ)
|
|
|
|
r.push_back('"');
|
|
|
|
}
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2019-03-30 04:25:34 +08:00
|
|
|
static void fillLinkerVerRecord(Compile3Sym &cs) {
|
2018-04-17 02:17:13 +08:00
|
|
|
cs.Machine = toCodeViewMachine(config->machine);
|
2017-08-12 05:14:01 +08:00
|
|
|
// Interestingly, if we set the string to 0.0.0.0, then when trying to view
|
|
|
|
// local variables WinDbg emits an error that private symbols are not present.
|
|
|
|
// By setting this to a valid MSVC linker version string, local variables are
|
|
|
|
// displayed properly. As such, even though it is not representative of
|
2017-08-12 04:46:47 +08:00
|
|
|
// LLVM's version information, we need this for compatibility.
|
2017-07-11 05:01:37 +08:00
|
|
|
cs.Flags = CompileSym3Flags::None;
|
2017-08-12 04:46:47 +08:00
|
|
|
cs.VersionBackendBuild = 25019;
|
|
|
|
cs.VersionBackendMajor = 14;
|
|
|
|
cs.VersionBackendMinor = 10;
|
2017-07-11 05:01:37 +08:00
|
|
|
cs.VersionBackendQFE = 0;
|
2017-08-12 04:46:47 +08:00
|
|
|
|
|
|
|
// MSVC also sets the frontend to 0.0.0.0 since this is specifically for the
|
|
|
|
// linker module (which is by definition a backend), so we don't need to do
|
|
|
|
// anything here. Also, it seems we can use "LLVM Linker" for the linker name
|
|
|
|
// without any problems. Only the backend version has to be hardcoded to a
|
|
|
|
// magic number.
|
2017-07-11 05:01:37 +08:00
|
|
|
cs.VersionFrontendBuild = 0;
|
|
|
|
cs.VersionFrontendMajor = 0;
|
|
|
|
cs.VersionFrontendMinor = 0;
|
|
|
|
cs.VersionFrontendQFE = 0;
|
|
|
|
cs.Version = "LLVM Linker";
|
|
|
|
cs.setLanguage(SourceLanguage::Link);
|
2019-03-30 04:25:34 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void addCommonLinkerModuleSymbols(StringRef path,
|
|
|
|
pdb::DbiModuleDescriptorBuilder &mod,
|
|
|
|
BumpPtrAllocator &allocator) {
|
|
|
|
ObjNameSym ons(SymbolRecordKind::ObjNameSym);
|
|
|
|
EnvBlockSym ebs(SymbolRecordKind::EnvBlockSym);
|
|
|
|
Compile3Sym cs(SymbolRecordKind::Compile3Sym);
|
|
|
|
fillLinkerVerRecord(cs);
|
|
|
|
|
|
|
|
ons.Name = "* Linker *";
|
|
|
|
ons.Signature = 0;
|
2017-07-11 05:01:37 +08:00
|
|
|
|
|
|
|
ArrayRef<StringRef> args = makeArrayRef(config->argv).drop_front();
|
2018-12-01 00:36:40 +08:00
|
|
|
std::string argStr = quote(args);
|
2017-07-11 05:01:37 +08:00
|
|
|
ebs.Fields.push_back("cwd");
|
|
|
|
SmallString<64> cwd;
|
2018-12-07 01:49:15 +08:00
|
|
|
if (config->pdbSourcePath.empty())
|
lld-link: Use /pdbsourcepath: for more places when present.
/pdbsourcepath: was added in https://reviews.llvm.org/D48882 to make it
possible to have relative paths in the debug info that clang-cl writes.
lld-link then makes the paths absolute at link time, which debuggers require.
This way, clang-cl's output is independent of the absolute path of the build
directory, which is useful for cacheability in distcc-like systems.
This patch extends /pdbsourcepath: (if passed) to also be used for:
1. The "cwd" stored in the env block in the pdb is /pdbsourcepath: if present
2. The "exe" stored in the env block in the pdb is made absolute relative
to /pdbsourcepath: instead of the cwd
3. The "pdb" stored in the env block in the pdb is made absolute relative
to /pdbsourcepath: instead of the cwd
4. For making absolute paths to .obj files referenced from the pdb
/pdbsourcepath: is now useful in three scenarios (the first one already working
before this change):
1. When building with full debug info, passing the real build dir to
/pdbsourcepath: allows having clang-cl's output to be independent
of the build directory path. This patch effectively doesn't change
behavior for this use case (assuming the cwd is the build dir).
2. When building without compile-time debug info but linking with /debug,
a fake fixed /pdbsourcepath: can be passed to get symbolized stacks
while making the pdb and exe independent of the current build dir.
For this two work, lld-link needs to be invoked with relative paths for
the lld-link invocation itself (for "exe"), for the pdb output name, the exe
output name (for "pdb"), and the obj input files, and no absolute path
must appear on the link command (for "cmd" in the pdb's env block).
Since no full debug info is present, it doesn't matter that the absolute
path doesn't exist on disk -- we only get symbols in stacks.
3. When building production builds with full debug info that don't have
local changes, and that get source indexed and their pdbs get uploaded
to a symbol server. /pdbsourcepath: again makes the build output independent
of the current directory, and the fixed path passed to /pdbsourcepath: can
be given the source indexing transform so that it gets mapped to a
repository path. This has the same requirements as 2.
This patch also makes it possible to create PDB files containing Windows-style
absolute paths when cross-compiling on a POSIX system.
Differential Revision: https://reviews.llvm.org/D53021
llvm-svn: 344061
2018-10-10 01:52:25 +08:00
|
|
|
sys::fs::current_path(cwd);
|
|
|
|
else
|
|
|
|
cwd = config->pdbSourcePath;
|
2017-07-11 05:01:37 +08:00
|
|
|
ebs.Fields.push_back(cwd);
|
|
|
|
ebs.Fields.push_back("exe");
|
2017-08-12 04:46:47 +08:00
|
|
|
SmallString<64> exe = config->argv[0];
|
lld-link: Use /pdbsourcepath: for more places when present.
/pdbsourcepath: was added in https://reviews.llvm.org/D48882 to make it
possible to have relative paths in the debug info that clang-cl writes.
lld-link then makes the paths absolute at link time, which debuggers require.
This way, clang-cl's output is independent of the absolute path of the build
directory, which is useful for cacheability in distcc-like systems.
This patch extends /pdbsourcepath: (if passed) to also be used for:
1. The "cwd" stored in the env block in the pdb is /pdbsourcepath: if present
2. The "exe" stored in the env block in the pdb is made absolute relative
to /pdbsourcepath: instead of the cwd
3. The "pdb" stored in the env block in the pdb is made absolute relative
to /pdbsourcepath: instead of the cwd
4. For making absolute paths to .obj files referenced from the pdb
/pdbsourcepath: is now useful in three scenarios (the first one already working
before this change):
1. When building with full debug info, passing the real build dir to
/pdbsourcepath: allows having clang-cl's output to be independent
of the build directory path. This patch effectively doesn't change
behavior for this use case (assuming the cwd is the build dir).
2. When building without compile-time debug info but linking with /debug,
a fake fixed /pdbsourcepath: can be passed to get symbolized stacks
while making the pdb and exe independent of the current build dir.
For this two work, lld-link needs to be invoked with relative paths for
the lld-link invocation itself (for "exe"), for the pdb output name, the exe
output name (for "pdb"), and the obj input files, and no absolute path
must appear on the link command (for "cmd" in the pdb's env block).
Since no full debug info is present, it doesn't matter that the absolute
path doesn't exist on disk -- we only get symbols in stacks.
3. When building production builds with full debug info that don't have
local changes, and that get source indexed and their pdbs get uploaded
to a symbol server. /pdbsourcepath: again makes the build output independent
of the current directory, and the fixed path passed to /pdbsourcepath: can
be given the source indexing transform so that it gets mapped to a
repository path. This has the same requirements as 2.
This patch also makes it possible to create PDB files containing Windows-style
absolute paths when cross-compiling on a POSIX system.
Differential Revision: https://reviews.llvm.org/D53021
llvm-svn: 344061
2018-10-10 01:52:25 +08:00
|
|
|
pdbMakeAbsolute(exe);
|
2017-08-12 04:46:47 +08:00
|
|
|
ebs.Fields.push_back(exe);
|
2017-07-11 05:01:37 +08:00
|
|
|
ebs.Fields.push_back("pdb");
|
|
|
|
ebs.Fields.push_back(path);
|
|
|
|
ebs.Fields.push_back("cmd");
|
|
|
|
ebs.Fields.push_back(argStr);
|
|
|
|
mod.addSymbol(codeview::SymbolSerializer::writeOneSymbol(
|
|
|
|
ons, allocator, CodeViewContainer::Pdb));
|
|
|
|
mod.addSymbol(codeview::SymbolSerializer::writeOneSymbol(
|
|
|
|
cs, allocator, CodeViewContainer::Pdb));
|
|
|
|
mod.addSymbol(codeview::SymbolSerializer::writeOneSymbol(
|
|
|
|
ebs, allocator, CodeViewContainer::Pdb));
|
|
|
|
}
|
|
|
|
|
2019-03-30 04:25:34 +08:00
|
|
|
static void addLinkerModuleCoffGroup(PartialSection *sec,
|
|
|
|
pdb::DbiModuleDescriptorBuilder &mod,
|
|
|
|
OutputSection &os,
|
|
|
|
BumpPtrAllocator &allocator) {
|
|
|
|
// If there's a section, there's at least one chunk
|
|
|
|
assert(!sec->chunks.empty());
|
|
|
|
const Chunk *firstChunk = *sec->chunks.begin();
|
|
|
|
const Chunk *lastChunk = *sec->chunks.rbegin();
|
|
|
|
|
|
|
|
// Emit COFF group
|
|
|
|
CoffGroupSym cgs(SymbolRecordKind::CoffGroupSym);
|
|
|
|
cgs.Name = sec->name;
|
|
|
|
cgs.Segment = os.sectionIndex;
|
|
|
|
cgs.Offset = firstChunk->getRVA() - os.getRVA();
|
|
|
|
cgs.Size = lastChunk->getRVA() + lastChunk->getSize() - firstChunk->getRVA();
|
|
|
|
cgs.Characteristics = sec->characteristics;
|
|
|
|
|
|
|
|
// Somehow .idata sections & sections groups in the debug symbol stream have
|
|
|
|
// the "write" flag set. However the section header for the corresponding
|
|
|
|
// .idata section doesn't have it.
|
|
|
|
if (cgs.Name.startswith(".idata"))
|
|
|
|
cgs.Characteristics |= llvm::COFF::IMAGE_SCN_MEM_WRITE;
|
|
|
|
|
|
|
|
mod.addSymbol(codeview::SymbolSerializer::writeOneSymbol(
|
|
|
|
cgs, allocator, CodeViewContainer::Pdb));
|
|
|
|
}
|
|
|
|
|
2017-08-12 04:46:28 +08:00
|
|
|
static void addLinkerModuleSectionSymbol(pdb::DbiModuleDescriptorBuilder &mod,
|
|
|
|
OutputSection &os,
|
|
|
|
BumpPtrAllocator &allocator) {
|
|
|
|
SectionSym sym(SymbolRecordKind::SectionSym);
|
2017-08-12 04:46:47 +08:00
|
|
|
sym.Alignment = 12; // 2^12 = 4KB
|
2018-04-20 05:48:37 +08:00
|
|
|
sym.Characteristics = os.header.Characteristics;
|
2017-08-12 04:46:28 +08:00
|
|
|
sym.Length = os.getVirtualSize();
|
2018-03-16 05:13:46 +08:00
|
|
|
sym.Name = os.name;
|
2017-08-12 04:46:28 +08:00
|
|
|
sym.Rva = os.getRVA();
|
|
|
|
sym.SectionNumber = os.sectionIndex;
|
|
|
|
mod.addSymbol(codeview::SymbolSerializer::writeOneSymbol(
|
|
|
|
sym, allocator, CodeViewContainer::Pdb));
|
2019-03-30 04:25:34 +08:00
|
|
|
|
|
|
|
// Skip COFF groups in MinGW because it adds a significant footprint to the
|
|
|
|
// PDB, due to each function being in its own section
|
|
|
|
if (config->mingw)
|
|
|
|
return;
|
|
|
|
|
|
|
|
// Output COFF groups for individual chunks of this section.
|
|
|
|
for (PartialSection *sec : os.contribSections) {
|
|
|
|
addLinkerModuleCoffGroup(sec, mod, os, allocator);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Add all import files as modules to the PDB.
|
|
|
|
void PDBLinker::addImportFilesToPDB(ArrayRef<OutputSection *> outputSections) {
|
|
|
|
if (ImportFile::instances.empty())
|
|
|
|
return;
|
|
|
|
|
|
|
|
std::map<std::string, llvm::pdb::DbiModuleDescriptorBuilder *> dllToModuleDbi;
|
|
|
|
|
|
|
|
for (ImportFile *file : ImportFile::instances) {
|
|
|
|
if (!file->live)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (!file->thunkSym)
|
|
|
|
continue;
|
|
|
|
|
2019-03-30 05:24:19 +08:00
|
|
|
if (!file->thunkLive)
|
|
|
|
continue;
|
|
|
|
|
2019-03-30 04:25:34 +08:00
|
|
|
std::string dll = StringRef(file->dllName).lower();
|
|
|
|
llvm::pdb::DbiModuleDescriptorBuilder *&mod = dllToModuleDbi[dll];
|
|
|
|
if (!mod) {
|
|
|
|
pdb::DbiStreamBuilder &dbiBuilder = builder.getDbiBuilder();
|
|
|
|
SmallString<128> libPath = file->parentName;
|
|
|
|
pdbMakeAbsolute(libPath);
|
|
|
|
sys::path::native(libPath);
|
|
|
|
|
|
|
|
// Name modules similar to MSVC's link.exe.
|
|
|
|
// The first module is the simple dll filename
|
|
|
|
llvm::pdb::DbiModuleDescriptorBuilder &firstMod =
|
|
|
|
exitOnErr(dbiBuilder.addModuleInfo(file->dllName));
|
|
|
|
firstMod.setObjFileName(libPath);
|
|
|
|
pdb::SectionContrib sc =
|
|
|
|
createSectionContrib(nullptr, llvm::pdb::kInvalidStreamIndex);
|
|
|
|
firstMod.setFirstSectionContrib(sc);
|
|
|
|
|
|
|
|
// The second module is where the import stream goes.
|
|
|
|
mod = &exitOnErr(dbiBuilder.addModuleInfo("Import:" + file->dllName));
|
|
|
|
mod->setObjFileName(libPath);
|
|
|
|
}
|
|
|
|
|
|
|
|
DefinedImportThunk *thunk = cast<DefinedImportThunk>(file->thunkSym);
|
2019-05-10 05:21:22 +08:00
|
|
|
Chunk *thunkChunk = thunk->getChunk();
|
|
|
|
OutputSection *thunkOS = thunkChunk->getOutputSection();
|
2019-03-30 04:25:34 +08:00
|
|
|
|
|
|
|
ObjNameSym ons(SymbolRecordKind::ObjNameSym);
|
|
|
|
Compile3Sym cs(SymbolRecordKind::Compile3Sym);
|
|
|
|
Thunk32Sym ts(SymbolRecordKind::Thunk32Sym);
|
|
|
|
ScopeEndSym es(SymbolRecordKind::ScopeEndSym);
|
|
|
|
|
|
|
|
ons.Name = file->dllName;
|
|
|
|
ons.Signature = 0;
|
|
|
|
|
|
|
|
fillLinkerVerRecord(cs);
|
|
|
|
|
|
|
|
ts.Name = thunk->getName();
|
|
|
|
ts.Parent = 0;
|
|
|
|
ts.End = 0;
|
|
|
|
ts.Next = 0;
|
|
|
|
ts.Thunk = ThunkOrdinal::Standard;
|
2019-05-10 05:21:22 +08:00
|
|
|
ts.Length = thunkChunk->getSize();
|
|
|
|
ts.Segment = thunkOS->sectionIndex;
|
|
|
|
ts.Offset = thunkChunk->getRVA() - thunkOS->getRVA();
|
2019-03-30 04:25:34 +08:00
|
|
|
|
|
|
|
mod->addSymbol(codeview::SymbolSerializer::writeOneSymbol(
|
|
|
|
ons, alloc, CodeViewContainer::Pdb));
|
|
|
|
mod->addSymbol(codeview::SymbolSerializer::writeOneSymbol(
|
|
|
|
cs, alloc, CodeViewContainer::Pdb));
|
|
|
|
|
|
|
|
SmallVector<SymbolScope, 4> scopes;
|
|
|
|
CVSymbol newSym = codeview::SymbolSerializer::writeOneSymbol(
|
|
|
|
ts, alloc, CodeViewContainer::Pdb);
|
|
|
|
scopeStackOpen(scopes, mod->getNextSymbolOffset(), newSym);
|
|
|
|
|
|
|
|
mod->addSymbol(newSym);
|
|
|
|
|
|
|
|
newSym = codeview::SymbolSerializer::writeOneSymbol(es, alloc,
|
|
|
|
CodeViewContainer::Pdb);
|
|
|
|
scopeStackClose(scopes, mod->getNextSymbolOffset(), file);
|
|
|
|
|
|
|
|
mod->addSymbol(newSym);
|
|
|
|
|
|
|
|
pdb::SectionContrib sc =
|
|
|
|
createSectionContrib(thunk->getChunk(), mod->getModuleIndex());
|
|
|
|
mod->setFirstSectionContrib(sc);
|
|
|
|
}
|
2017-08-12 04:46:28 +08:00
|
|
|
}
|
|
|
|
|
2016-11-12 08:00:51 +08:00
|
|
|
// Creates a PDB file.
|
2017-08-04 05:15:09 +08:00
|
|
|
void coff::createPDB(SymbolTable *symtab,
|
|
|
|
ArrayRef<OutputSection *> outputSections,
|
|
|
|
ArrayRef<uint8_t> sectionTable,
|
2018-09-16 02:37:22 +08:00
|
|
|
llvm::codeview::DebugInfo *buildId) {
|
2018-01-18 03:16:26 +08:00
|
|
|
ScopedTimer t1(totalPdbLinkTimer);
|
2017-07-14 08:14:58 +08:00
|
|
|
PDBLinker pdb(symtab);
|
2019-07-11 13:40:30 +08:00
|
|
|
|
[LLD COFF/PDB] Incrementally update the build id.
Previously, our algorithm to compute a build id involved hashing the
executable and storing that as the GUID in the CV Debug Record chunk,
and setting the age to 1.
This breaks down in one very obvious case: a user adds some newlines to
a file, rebuilds, but changes nothing else. This causes new line
information and new file checksums to get written to the PDB, meaning
that the debug info is different, but the generated code would be the
same, so we would write the same build over again with an age of 1.
Anyone using a symbol cache would have a problem now, because the
debugger would open the executable, look at the age and guid, find a
matching PDB in the symbol cache and then load it. It would never copy
the new PDB to the symbol cache.
This patch implements the canonical Windows algorithm for updating
a build id, which is to check the existing executable first, and
re-use an existing GUID while bumping the age if it already
exists.
Differential Revision: https://reviews.llvm.org/D36758
llvm-svn: 310961
2017-08-16 05:31:41 +08:00
|
|
|
pdb.initialize(buildId);
|
2017-07-14 08:14:58 +08:00
|
|
|
pdb.addObjectsToPDB();
|
2019-03-30 04:25:34 +08:00
|
|
|
pdb.addImportFilesToPDB(outputSections);
|
2017-08-04 05:15:09 +08:00
|
|
|
pdb.addSections(outputSections, sectionTable);
|
2018-03-24 03:57:25 +08:00
|
|
|
pdb.addNatvisFiles();
|
2019-07-11 13:40:30 +08:00
|
|
|
|
2018-01-18 03:16:26 +08:00
|
|
|
ScopedTimer t2(diskCommitTimer);
|
2018-09-16 02:37:22 +08:00
|
|
|
codeview::GUID guid;
|
|
|
|
pdb.commit(&guid);
|
|
|
|
memcpy(&buildId->PDB70.Signature, &guid, 16);
|
2019-07-11 13:40:30 +08:00
|
|
|
|
2019-03-15 02:45:08 +08:00
|
|
|
t2.stop();
|
|
|
|
t1.stop();
|
|
|
|
pdb.printStats();
|
2017-07-14 08:14:58 +08:00
|
|
|
}
|
|
|
|
|
2018-09-16 02:37:22 +08:00
|
|
|
void PDBLinker::initialize(llvm::codeview::DebugInfo *buildId) {
|
2016-10-01 04:53:45 +08:00
|
|
|
exitOnErr(builder.initialize(4096)); // 4096 is blocksize
|
2016-09-16 02:55:18 +08:00
|
|
|
|
2018-09-16 02:37:22 +08:00
|
|
|
buildId->Signature.CVSignature = OMF::Signature::PDB70;
|
|
|
|
// Signature is set to a hash of the PDB contents when the PDB is done.
|
|
|
|
memset(buildId->PDB70.Signature, 0, 16);
|
|
|
|
buildId->PDB70.Age = 1;
|
|
|
|
|
2016-10-06 06:08:58 +08:00
|
|
|
// Create streams in MSF for predefined streams, namely
|
|
|
|
// PDB, TPI, DBI and IPI.
|
|
|
|
for (int i = 0; i < (int)pdb::kSpecialStreamCount; ++i)
|
|
|
|
exitOnErr(builder.getMsfBuilder().addStream(0));
|
2016-09-16 02:55:18 +08:00
|
|
|
|
2016-09-17 06:51:17 +08:00
|
|
|
// Add an Info stream.
|
|
|
|
auto &infoBuilder = builder.getInfoBuilder();
|
|
|
|
infoBuilder.setVersion(pdb::PdbRaw_ImplVer::PdbImplVC70);
|
2018-09-16 02:37:22 +08:00
|
|
|
infoBuilder.setHashPDBContentsToGUID(true);
|
2016-09-16 02:55:18 +08:00
|
|
|
|
2017-07-07 13:04:36 +08:00
|
|
|
// Add an empty DBI stream.
|
2017-06-13 23:49:13 +08:00
|
|
|
pdb::DbiStreamBuilder &dbiBuilder = builder.getDbiBuilder();
|
2018-09-16 02:37:22 +08:00
|
|
|
dbiBuilder.setAge(buildId->PDB70.Age);
|
Fix some differences between lld and MSVC generated PDBs.
A couple of things were different about our generated PDBs.
1) We were outputting the wrong Version on the PDB Stream.
The version we were setting was newer than what MSVC is setting.
It's not clear what the implications are, but we change LLD
to use PdbImplVC70, as MSVC does.
2) For the optional debug stream indices in the DBI Stream, we
were outputting 0 to mean "the stream is not present". MSVC
outputs uint16_t(-1), which is the "correct" way to specify
that a stream is not present. So we fix that as well.
3) We were setting the PDB Stream signature to 0. This is supposed
to be the result of calling time(nullptr). Although this leads
to non-deterministic builds, a better way to solve that is by
having a command line option explicitly for generating a
reproducible build, and have the default behavior of lld-link
match the default behavior of link.
To test this, I'm making use of the new and improved `pdb diff`
sub command. To make it suitable for writing tests against, I had
to modify the diff subcommand slightly to print less verbose output.
Previously it would always print | <column> | <value1> | <value2> |
which is quite verbose, and the values are fragile. All we really
want to know is "did we produce the same value as link?" So I added
command line options to print a single character representing the
result status (different, identical, equivalent), and another to
hide the value display. Note that just inspecting the diff output
used to write the test, you can see some things that are obviously
wrong. That is just reflective of the fact that this is the state
of affairs today, not that we're asserting that this is "correct".
We can use this as a starting point to discover differences, fix
them, and update the test.
Differential Revision: https://reviews.llvm.org/D35086
llvm-svn: 307422
2017-07-08 02:45:56 +08:00
|
|
|
dbiBuilder.setVersionHeader(pdb::PdbDbiV70);
|
2018-04-17 04:42:06 +08:00
|
|
|
dbiBuilder.setMachineType(config->machine);
|
2018-04-17 02:17:13 +08:00
|
|
|
// Technically we are not link.exe 14.11, but there are known cases where
|
|
|
|
// debugging tools on Windows expect Microsoft-specific version numbers or
|
|
|
|
// they fail to work at all. Since we know we produce PDBs that are
|
|
|
|
// compatible with LINK 14.11, we set that version number here.
|
|
|
|
dbiBuilder.setBuildNumber(14, 11);
|
2017-07-14 08:14:58 +08:00
|
|
|
}
|
2016-10-07 06:52:01 +08:00
|
|
|
|
2017-08-04 05:15:09 +08:00
|
|
|
void PDBLinker::addSections(ArrayRef<OutputSection *> outputSections,
|
|
|
|
ArrayRef<uint8_t> sectionTable) {
|
2017-07-14 08:14:58 +08:00
|
|
|
// It's not entirely clear what this is, but the * Linker * module uses it.
|
2017-08-04 05:15:09 +08:00
|
|
|
pdb::DbiStreamBuilder &dbiBuilder = builder.getDbiBuilder();
|
2017-07-14 08:14:58 +08:00
|
|
|
nativePath = config->pdbPath;
|
lld-link: Use /pdbsourcepath: for more places when present.
/pdbsourcepath: was added in https://reviews.llvm.org/D48882 to make it
possible to have relative paths in the debug info that clang-cl writes.
lld-link then makes the paths absolute at link time, which debuggers require.
This way, clang-cl's output is independent of the absolute path of the build
directory, which is useful for cacheability in distcc-like systems.
This patch extends /pdbsourcepath: (if passed) to also be used for:
1. The "cwd" stored in the env block in the pdb is /pdbsourcepath: if present
2. The "exe" stored in the env block in the pdb is made absolute relative
to /pdbsourcepath: instead of the cwd
3. The "pdb" stored in the env block in the pdb is made absolute relative
to /pdbsourcepath: instead of the cwd
4. For making absolute paths to .obj files referenced from the pdb
/pdbsourcepath: is now useful in three scenarios (the first one already working
before this change):
1. When building with full debug info, passing the real build dir to
/pdbsourcepath: allows having clang-cl's output to be independent
of the build directory path. This patch effectively doesn't change
behavior for this use case (assuming the cwd is the build dir).
2. When building without compile-time debug info but linking with /debug,
a fake fixed /pdbsourcepath: can be passed to get symbolized stacks
while making the pdb and exe independent of the current build dir.
For this two work, lld-link needs to be invoked with relative paths for
the lld-link invocation itself (for "exe"), for the pdb output name, the exe
output name (for "pdb"), and the obj input files, and no absolute path
must appear on the link command (for "cmd" in the pdb's env block).
Since no full debug info is present, it doesn't matter that the absolute
path doesn't exist on disk -- we only get symbols in stacks.
3. When building production builds with full debug info that don't have
local changes, and that get source indexed and their pdbs get uploaded
to a symbol server. /pdbsourcepath: again makes the build output independent
of the current directory, and the fixed path passed to /pdbsourcepath: can
be given the source indexing transform so that it gets mapped to a
repository path. This has the same requirements as 2.
This patch also makes it possible to create PDB files containing Windows-style
absolute paths when cross-compiling on a POSIX system.
Differential Revision: https://reviews.llvm.org/D53021
llvm-svn: 344061
2018-10-10 01:52:25 +08:00
|
|
|
pdbMakeAbsolute(nativePath);
|
2017-07-14 08:14:58 +08:00
|
|
|
uint32_t pdbFilePathNI = dbiBuilder.addECName(nativePath);
|
2017-07-07 13:04:36 +08:00
|
|
|
auto &linkerModule = exitOnErr(dbiBuilder.addModuleInfo("* Linker *"));
|
|
|
|
linkerModule.setPdbFilePathNI(pdbFilePathNI);
|
2017-08-12 04:46:28 +08:00
|
|
|
addCommonLinkerModuleSymbols(nativePath, linkerModule, alloc);
|
2016-11-16 09:10:46 +08:00
|
|
|
|
2017-08-04 05:15:09 +08:00
|
|
|
// Add section contributions. They must be ordered by ascending RVA.
|
2017-08-12 04:46:28 +08:00
|
|
|
for (OutputSection *os : outputSections) {
|
|
|
|
addLinkerModuleSectionSymbol(linkerModule, *os, alloc);
|
2018-09-25 18:59:29 +08:00
|
|
|
for (Chunk *c : os->chunks) {
|
2018-04-21 02:00:46 +08:00
|
|
|
pdb::SectionContrib sc =
|
|
|
|
createSectionContrib(c, linkerModule.getModuleIndex());
|
|
|
|
builder.getDbiBuilder().addSectionContrib(sc);
|
|
|
|
}
|
2017-08-12 04:46:28 +08:00
|
|
|
}
|
2017-08-04 05:15:09 +08:00
|
|
|
|
2019-03-19 03:13:23 +08:00
|
|
|
// The * Linker * first section contrib is only used along with /INCREMENTAL,
|
|
|
|
// to provide trampolines thunks for incremental function patching. Set this
|
|
|
|
// as "unused" because LLD doesn't support /INCREMENTAL link.
|
|
|
|
pdb::SectionContrib sc =
|
|
|
|
createSectionContrib(nullptr, llvm::pdb::kInvalidStreamIndex);
|
|
|
|
linkerModule.setFirstSectionContrib(sc);
|
|
|
|
|
2017-08-04 05:15:09 +08:00
|
|
|
// Add Section Map stream.
|
|
|
|
ArrayRef<object::coff_section> sections = {
|
|
|
|
(const object::coff_section *)sectionTable.data(),
|
|
|
|
sectionTable.size() / sizeof(object::coff_section)};
|
|
|
|
sectionMap = pdb::DbiStreamBuilder::createSectionMap(sections);
|
|
|
|
dbiBuilder.setSectionMap(sectionMap);
|
|
|
|
|
2016-10-12 03:45:07 +08:00
|
|
|
// Add COFF section header stream.
|
|
|
|
exitOnErr(
|
|
|
|
dbiBuilder.addDbgStream(pdb::DbgHeaderType::SectionHdr, sectionTable));
|
2017-07-14 08:14:58 +08:00
|
|
|
}
|
2016-10-12 03:45:07 +08:00
|
|
|
|
2018-09-16 02:37:22 +08:00
|
|
|
void PDBLinker::commit(codeview::GUID *guid) {
|
2019-08-21 02:56:48 +08:00
|
|
|
ExitOnError exitOnErr((config->pdbPath + ": ").str());
|
2016-09-27 07:53:55 +08:00
|
|
|
// Write to a file.
|
2018-09-16 02:37:22 +08:00
|
|
|
exitOnErr(builder.commit(config->pdbPath, guid));
|
2015-12-05 07:11:05 +08:00
|
|
|
}
|
2018-04-18 07:32:33 +08:00
|
|
|
|
|
|
|
static uint32_t getSecrelReloc() {
|
|
|
|
switch (config->machine) {
|
|
|
|
case AMD64:
|
|
|
|
return COFF::IMAGE_REL_AMD64_SECREL;
|
|
|
|
case I386:
|
|
|
|
return COFF::IMAGE_REL_I386_SECREL;
|
|
|
|
case ARMNT:
|
|
|
|
return COFF::IMAGE_REL_ARM_SECREL;
|
|
|
|
case ARM64:
|
|
|
|
return COFF::IMAGE_REL_ARM64_SECREL;
|
|
|
|
default:
|
|
|
|
llvm_unreachable("unknown machine type");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Try to find a line table for the given offset Addr into the given chunk C.
|
|
|
|
// If a line table was found, the line table, the string and checksum tables
|
|
|
|
// that are used to interpret the line table, and the offset of Addr in the line
|
|
|
|
// table are stored in the output arguments. Returns whether a line table was
|
|
|
|
// found.
|
|
|
|
static bool findLineTable(const SectionChunk *c, uint32_t addr,
|
|
|
|
DebugStringTableSubsectionRef &cVStrTab,
|
|
|
|
DebugChecksumsSubsectionRef &checksums,
|
|
|
|
DebugLinesSubsectionRef &lines,
|
|
|
|
uint32_t &offsetInLinetable) {
|
|
|
|
ExitOnError exitOnErr;
|
|
|
|
uint32_t secrelReloc = getSecrelReloc();
|
2019-07-11 13:40:30 +08:00
|
|
|
|
2018-04-18 07:32:33 +08:00
|
|
|
for (SectionChunk *dbgC : c->file->getDebugChunks()) {
|
|
|
|
if (dbgC->getSectionName() != ".debug$S")
|
|
|
|
continue;
|
|
|
|
|
2019-07-16 16:26:38 +08:00
|
|
|
// Build a mapping of SECREL relocations in dbgC that refer to `c`.
|
2018-04-18 07:32:33 +08:00
|
|
|
DenseMap<uint32_t, uint32_t> secrels;
|
2019-05-04 04:17:14 +08:00
|
|
|
for (const coff_relocation &r : dbgC->getRelocs()) {
|
2018-04-18 07:32:33 +08:00
|
|
|
if (r.Type != secrelReloc)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (auto *s = dyn_cast_or_null<DefinedRegular>(
|
|
|
|
c->file->getSymbols()[r.SymbolTableIndex]))
|
|
|
|
if (s->getChunk() == c)
|
|
|
|
secrels[r.VirtualAddress] = s->getValue();
|
|
|
|
}
|
|
|
|
|
|
|
|
ArrayRef<uint8_t> contents =
|
2019-02-23 09:46:18 +08:00
|
|
|
SectionChunk::consumeDebugMagic(dbgC->getContents(), ".debug$S");
|
2018-04-18 07:32:33 +08:00
|
|
|
DebugSubsectionArray subsections;
|
|
|
|
BinaryStreamReader reader(contents, support::little);
|
|
|
|
exitOnErr(reader.readArray(subsections, contents.size()));
|
|
|
|
|
|
|
|
for (const DebugSubsectionRecord &ss : subsections) {
|
|
|
|
switch (ss.kind()) {
|
|
|
|
case DebugSubsectionKind::StringTable: {
|
|
|
|
assert(!cVStrTab.valid() &&
|
|
|
|
"Encountered multiple string table subsections!");
|
|
|
|
exitOnErr(cVStrTab.initialize(ss.getRecordData()));
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case DebugSubsectionKind::FileChecksums:
|
|
|
|
assert(!checksums.valid() &&
|
|
|
|
"Encountered multiple checksum subsections!");
|
|
|
|
exitOnErr(checksums.initialize(ss.getRecordData()));
|
|
|
|
break;
|
|
|
|
case DebugSubsectionKind::Lines: {
|
|
|
|
ArrayRef<uint8_t> bytes;
|
|
|
|
auto ref = ss.getRecordData();
|
|
|
|
exitOnErr(ref.readLongestContiguousChunk(0, bytes));
|
|
|
|
size_t offsetInDbgC = bytes.data() - dbgC->getContents().data();
|
|
|
|
|
|
|
|
// Check whether this line table refers to C.
|
|
|
|
auto i = secrels.find(offsetInDbgC);
|
|
|
|
if (i == secrels.end())
|
|
|
|
break;
|
|
|
|
|
|
|
|
// Check whether this line table covers Addr in C.
|
|
|
|
DebugLinesSubsectionRef linesTmp;
|
|
|
|
exitOnErr(linesTmp.initialize(BinaryStreamReader(ref)));
|
|
|
|
uint32_t offsetInC = i->second + linesTmp.header()->RelocOffset;
|
|
|
|
if (addr < offsetInC || addr >= offsetInC + linesTmp.header()->CodeSize)
|
|
|
|
break;
|
|
|
|
|
|
|
|
assert(!lines.header() &&
|
|
|
|
"Encountered multiple line tables for function!");
|
|
|
|
exitOnErr(lines.initialize(BinaryStreamReader(ref)));
|
|
|
|
offsetInLinetable = addr - offsetInC;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (cVStrTab.valid() && checksums.valid() && lines.header())
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Use CodeView line tables to resolve a file and line number for the given
|
|
|
|
// offset into the given chunk and return them, or {"", 0} if a line table was
|
|
|
|
// not found.
|
|
|
|
std::pair<StringRef, uint32_t> coff::getFileLine(const SectionChunk *c,
|
|
|
|
uint32_t addr) {
|
|
|
|
ExitOnError exitOnErr;
|
|
|
|
|
|
|
|
DebugStringTableSubsectionRef cVStrTab;
|
|
|
|
DebugChecksumsSubsectionRef checksums;
|
|
|
|
DebugLinesSubsectionRef lines;
|
|
|
|
uint32_t offsetInLinetable;
|
|
|
|
|
|
|
|
if (!findLineTable(c, addr, cVStrTab, checksums, lines, offsetInLinetable))
|
|
|
|
return {"", 0};
|
|
|
|
|
2019-01-05 05:49:22 +08:00
|
|
|
Optional<uint32_t> nameIndex;
|
|
|
|
Optional<uint32_t> lineNumber;
|
2018-04-18 07:32:33 +08:00
|
|
|
for (LineColumnEntry &entry : lines) {
|
|
|
|
for (const LineNumberEntry &ln : entry.LineNumbers) {
|
2019-01-05 05:49:22 +08:00
|
|
|
LineInfo li(ln.Flags);
|
2018-04-18 07:32:33 +08:00
|
|
|
if (ln.Offset > offsetInLinetable) {
|
2019-01-05 05:49:22 +08:00
|
|
|
if (!nameIndex) {
|
|
|
|
nameIndex = entry.NameIndex;
|
|
|
|
lineNumber = li.getStartLine();
|
|
|
|
}
|
2018-04-18 07:32:33 +08:00
|
|
|
StringRef filename =
|
2019-01-05 05:49:22 +08:00
|
|
|
exitOnErr(getFileName(cVStrTab, checksums, *nameIndex));
|
|
|
|
return {filename, *lineNumber};
|
2018-04-18 07:32:33 +08:00
|
|
|
}
|
|
|
|
nameIndex = entry.NameIndex;
|
|
|
|
lineNumber = li.getStartLine();
|
|
|
|
}
|
|
|
|
}
|
2019-01-05 05:49:22 +08:00
|
|
|
if (!nameIndex)
|
|
|
|
return {"", 0};
|
|
|
|
StringRef filename = exitOnErr(getFileName(cVStrTab, checksums, *nameIndex));
|
|
|
|
return {filename, *lineNumber};
|
2018-04-18 07:32:33 +08:00
|
|
|
}
|