forked from OSchip/llvm-project
790 lines
26 KiB
C++
790 lines
26 KiB
C++
//===- Driver.cpp ---------------------------------------------------------===//
|
|
//
|
|
// 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
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "lld/Common/Driver.h"
|
|
#include "Config.h"
|
|
#include "InputChunks.h"
|
|
#include "InputGlobal.h"
|
|
#include "MarkLive.h"
|
|
#include "SymbolTable.h"
|
|
#include "Writer.h"
|
|
#include "lld/Common/Args.h"
|
|
#include "lld/Common/ErrorHandler.h"
|
|
#include "lld/Common/Memory.h"
|
|
#include "lld/Common/Reproduce.h"
|
|
#include "lld/Common/Strings.h"
|
|
#include "lld/Common/Threads.h"
|
|
#include "lld/Common/Version.h"
|
|
#include "llvm/ADT/Twine.h"
|
|
#include "llvm/Object/Wasm.h"
|
|
#include "llvm/Option/Arg.h"
|
|
#include "llvm/Option/ArgList.h"
|
|
#include "llvm/Support/CommandLine.h"
|
|
#include "llvm/Support/Path.h"
|
|
#include "llvm/Support/Process.h"
|
|
#include "llvm/Support/TarWriter.h"
|
|
#include "llvm/Support/TargetSelect.h"
|
|
|
|
#define DEBUG_TYPE "lld"
|
|
|
|
using namespace llvm;
|
|
using namespace llvm::object;
|
|
using namespace llvm::sys;
|
|
using namespace llvm::wasm;
|
|
|
|
using namespace lld;
|
|
using namespace lld::wasm;
|
|
|
|
Configuration *lld::wasm::config;
|
|
|
|
namespace {
|
|
|
|
// Create enum with OPT_xxx values for each option in Options.td
|
|
enum {
|
|
OPT_INVALID = 0,
|
|
#define OPTION(_1, _2, ID, _4, _5, _6, _7, _8, _9, _10, _11, _12) OPT_##ID,
|
|
#include "Options.inc"
|
|
#undef OPTION
|
|
};
|
|
|
|
// This function is called on startup. We need this for LTO since
|
|
// LTO calls LLVM functions to compile bitcode files to native code.
|
|
// Technically this can be delayed until we read bitcode files, but
|
|
// we don't bother to do lazily because the initialization is fast.
|
|
static void initLLVM() {
|
|
InitializeAllTargets();
|
|
InitializeAllTargetMCs();
|
|
InitializeAllAsmPrinters();
|
|
InitializeAllAsmParsers();
|
|
}
|
|
|
|
class LinkerDriver {
|
|
public:
|
|
void link(ArrayRef<const char *> argsArr);
|
|
|
|
private:
|
|
void createFiles(opt::InputArgList &args);
|
|
void addFile(StringRef path);
|
|
void addLibrary(StringRef name);
|
|
|
|
// True if we are in --whole-archive and --no-whole-archive.
|
|
bool inWholeArchive = false;
|
|
|
|
std::vector<InputFile *> files;
|
|
};
|
|
} // anonymous namespace
|
|
|
|
bool lld::wasm::link(ArrayRef<const char *> args, bool canExitEarly,
|
|
raw_ostream &error) {
|
|
errorHandler().logName = args::getFilenameWithoutExe(args[0]);
|
|
errorHandler().errorOS = &error;
|
|
errorHandler().errorLimitExceededMsg =
|
|
"too many errors emitted, stopping now (use "
|
|
"-error-limit=0 to see all errors)";
|
|
enableColors(error.has_colors());
|
|
|
|
config = make<Configuration>();
|
|
symtab = make<SymbolTable>();
|
|
|
|
initLLVM();
|
|
LinkerDriver().link(args);
|
|
|
|
// Exit immediately if we don't need to return to the caller.
|
|
// This saves time because the overhead of calling destructors
|
|
// for all globally-allocated objects is not negligible.
|
|
if (canExitEarly)
|
|
exitLld(errorCount() ? 1 : 0);
|
|
|
|
freeArena();
|
|
return !errorCount();
|
|
}
|
|
|
|
// Create prefix string literals used in Options.td
|
|
#define PREFIX(NAME, VALUE) const char *const NAME[] = VALUE;
|
|
#include "Options.inc"
|
|
#undef PREFIX
|
|
|
|
// Create table mapping all options defined in Options.td
|
|
static const opt::OptTable::Info optInfo[] = {
|
|
#define OPTION(X1, X2, ID, KIND, GROUP, ALIAS, X7, X8, X9, X10, X11, X12) \
|
|
{X1, X2, X10, X11, OPT_##ID, opt::Option::KIND##Class, \
|
|
X9, X8, OPT_##GROUP, OPT_##ALIAS, X7, X12},
|
|
#include "Options.inc"
|
|
#undef OPTION
|
|
};
|
|
|
|
namespace {
|
|
class WasmOptTable : public llvm::opt::OptTable {
|
|
public:
|
|
WasmOptTable() : OptTable(optInfo) {}
|
|
opt::InputArgList parse(ArrayRef<const char *> argv);
|
|
};
|
|
} // namespace
|
|
|
|
// Set color diagnostics according to -color-diagnostics={auto,always,never}
|
|
// or -no-color-diagnostics flags.
|
|
static void handleColorDiagnostics(opt::InputArgList &args) {
|
|
auto *arg = args.getLastArg(OPT_color_diagnostics, OPT_color_diagnostics_eq,
|
|
OPT_no_color_diagnostics);
|
|
if (!arg)
|
|
return;
|
|
if (arg->getOption().getID() == OPT_color_diagnostics) {
|
|
enableColors(true);
|
|
} else if (arg->getOption().getID() == OPT_no_color_diagnostics) {
|
|
enableColors(false);
|
|
} else {
|
|
StringRef s = arg->getValue();
|
|
if (s == "always")
|
|
enableColors(true);
|
|
else if (s == "never")
|
|
enableColors(false);
|
|
else if (s != "auto")
|
|
error("unknown option: --color-diagnostics=" + s);
|
|
}
|
|
}
|
|
|
|
// Find a file by concatenating given paths.
|
|
static Optional<std::string> findFile(StringRef path1, const Twine &path2) {
|
|
SmallString<128> s;
|
|
path::append(s, path1, path2);
|
|
if (fs::exists(s))
|
|
return s.str().str();
|
|
return None;
|
|
}
|
|
|
|
opt::InputArgList WasmOptTable::parse(ArrayRef<const char *> argv) {
|
|
SmallVector<const char *, 256> vec(argv.data(), argv.data() + argv.size());
|
|
|
|
unsigned missingIndex;
|
|
unsigned missingCount;
|
|
|
|
// Expand response files (arguments in the form of @<filename>)
|
|
cl::ExpandResponseFiles(saver, cl::TokenizeGNUCommandLine, vec);
|
|
|
|
opt::InputArgList args = this->ParseArgs(vec, missingIndex, missingCount);
|
|
|
|
handleColorDiagnostics(args);
|
|
for (auto *arg : args.filtered(OPT_UNKNOWN))
|
|
error("unknown argument: " + arg->getAsString(args));
|
|
return args;
|
|
}
|
|
|
|
// Currently we allow a ".imports" to live alongside a library. This can
|
|
// be used to specify a list of symbols which can be undefined at link
|
|
// time (imported from the environment. For example libc.a include an
|
|
// import file that lists the syscall functions it relies on at runtime.
|
|
// In the long run this information would be better stored as a symbol
|
|
// attribute/flag in the object file itself.
|
|
// See: https://github.com/WebAssembly/tool-conventions/issues/35
|
|
static void readImportFile(StringRef filename) {
|
|
if (Optional<MemoryBufferRef> buf = readFile(filename))
|
|
for (StringRef sym : args::getLines(*buf))
|
|
config->allowUndefinedSymbols.insert(sym);
|
|
}
|
|
|
|
// Returns slices of MB by parsing MB as an archive file.
|
|
// Each slice consists of a member file in the archive.
|
|
std::vector<MemoryBufferRef> static getArchiveMembers(MemoryBufferRef mb) {
|
|
std::unique_ptr<Archive> file =
|
|
CHECK(Archive::create(mb),
|
|
mb.getBufferIdentifier() + ": failed to parse archive");
|
|
|
|
std::vector<MemoryBufferRef> v;
|
|
Error err = Error::success();
|
|
for (const ErrorOr<Archive::Child> &cOrErr : file->children(err)) {
|
|
Archive::Child c =
|
|
CHECK(cOrErr, mb.getBufferIdentifier() +
|
|
": could not get the child of the archive");
|
|
MemoryBufferRef mbref =
|
|
CHECK(c.getMemoryBufferRef(),
|
|
mb.getBufferIdentifier() +
|
|
": could not get the buffer for a child of the archive");
|
|
v.push_back(mbref);
|
|
}
|
|
if (err)
|
|
fatal(mb.getBufferIdentifier() +
|
|
": Archive::children failed: " + toString(std::move(err)));
|
|
|
|
// Take ownership of memory buffers created for members of thin archives.
|
|
for (std::unique_ptr<MemoryBuffer> &mb : file->takeThinBuffers())
|
|
make<std::unique_ptr<MemoryBuffer>>(std::move(mb));
|
|
|
|
return v;
|
|
}
|
|
|
|
void LinkerDriver::addFile(StringRef path) {
|
|
Optional<MemoryBufferRef> buffer = readFile(path);
|
|
if (!buffer.hasValue())
|
|
return;
|
|
MemoryBufferRef mbref = *buffer;
|
|
|
|
switch (identify_magic(mbref.getBuffer())) {
|
|
case file_magic::archive: {
|
|
SmallString<128> importFile = path;
|
|
path::replace_extension(importFile, ".imports");
|
|
if (fs::exists(importFile))
|
|
readImportFile(importFile.str());
|
|
|
|
// Handle -whole-archive.
|
|
if (inWholeArchive) {
|
|
for (MemoryBufferRef &m : getArchiveMembers(mbref))
|
|
files.push_back(createObjectFile(m, path));
|
|
return;
|
|
}
|
|
|
|
std::unique_ptr<Archive> file =
|
|
CHECK(Archive::create(mbref), path + ": failed to parse archive");
|
|
|
|
if (!file->isEmpty() && !file->hasSymbolTable()) {
|
|
error(mbref.getBufferIdentifier() +
|
|
": archive has no index; run ranlib to add one");
|
|
}
|
|
|
|
files.push_back(make<ArchiveFile>(mbref));
|
|
return;
|
|
}
|
|
case file_magic::bitcode:
|
|
case file_magic::wasm_object:
|
|
files.push_back(createObjectFile(mbref));
|
|
break;
|
|
default:
|
|
error("unknown file type: " + mbref.getBufferIdentifier());
|
|
}
|
|
}
|
|
|
|
// Add a given library by searching it from input search paths.
|
|
void LinkerDriver::addLibrary(StringRef name) {
|
|
for (StringRef dir : config->searchPaths) {
|
|
if (Optional<std::string> s = findFile(dir, "lib" + name + ".a")) {
|
|
addFile(*s);
|
|
return;
|
|
}
|
|
}
|
|
|
|
error("unable to find library -l" + name);
|
|
}
|
|
|
|
void LinkerDriver::createFiles(opt::InputArgList &args) {
|
|
for (auto *arg : args) {
|
|
switch (arg->getOption().getID()) {
|
|
case OPT_l:
|
|
addLibrary(arg->getValue());
|
|
break;
|
|
case OPT_INPUT:
|
|
addFile(arg->getValue());
|
|
break;
|
|
case OPT_whole_archive:
|
|
inWholeArchive = true;
|
|
break;
|
|
case OPT_no_whole_archive:
|
|
inWholeArchive = false;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
static StringRef getEntry(opt::InputArgList &args) {
|
|
auto *arg = args.getLastArg(OPT_entry, OPT_no_entry);
|
|
if (!arg) {
|
|
if (args.hasArg(OPT_relocatable))
|
|
return "";
|
|
if (args.hasArg(OPT_shared))
|
|
return "__wasm_call_ctors";
|
|
return "_start";
|
|
}
|
|
if (arg->getOption().getID() == OPT_no_entry)
|
|
return "";
|
|
return arg->getValue();
|
|
}
|
|
|
|
// Initializes Config members by the command line options.
|
|
static void readConfigs(opt::InputArgList &args) {
|
|
config->allowUndefined = args.hasArg(OPT_allow_undefined);
|
|
config->checkFeatures =
|
|
args.hasFlag(OPT_check_features, OPT_no_check_features, true);
|
|
config->compressRelocations = args.hasArg(OPT_compress_relocations);
|
|
config->demangle = args.hasFlag(OPT_demangle, OPT_no_demangle, true);
|
|
config->disableVerify = args.hasArg(OPT_disable_verify);
|
|
config->emitRelocs = args.hasArg(OPT_emit_relocs);
|
|
config->entry = getEntry(args);
|
|
config->exportAll = args.hasArg(OPT_export_all);
|
|
config->exportTable = args.hasArg(OPT_export_table);
|
|
config->growableTable = args.hasArg(OPT_growable_table);
|
|
errorHandler().fatalWarnings =
|
|
args.hasFlag(OPT_fatal_warnings, OPT_no_fatal_warnings, false);
|
|
config->importMemory = args.hasArg(OPT_import_memory);
|
|
config->sharedMemory = args.hasArg(OPT_shared_memory);
|
|
config->importTable = args.hasArg(OPT_import_table);
|
|
config->ltoo = args::getInteger(args, OPT_lto_O, 2);
|
|
config->ltoPartitions = args::getInteger(args, OPT_lto_partitions, 1);
|
|
config->optimize = args::getInteger(args, OPT_O, 0);
|
|
config->outputFile = args.getLastArgValue(OPT_o);
|
|
config->relocatable = args.hasArg(OPT_relocatable);
|
|
config->gcSections =
|
|
args.hasFlag(OPT_gc_sections, OPT_no_gc_sections, !config->relocatable);
|
|
config->mergeDataSegments =
|
|
args.hasFlag(OPT_merge_data_segments, OPT_no_merge_data_segments,
|
|
!config->relocatable);
|
|
config->pie = args.hasFlag(OPT_pie, OPT_no_pie, false);
|
|
config->printGcSections =
|
|
args.hasFlag(OPT_print_gc_sections, OPT_no_print_gc_sections, false);
|
|
config->saveTemps = args.hasArg(OPT_save_temps);
|
|
config->searchPaths = args::getStrings(args, OPT_L);
|
|
config->shared = args.hasArg(OPT_shared);
|
|
config->stripAll = args.hasArg(OPT_strip_all);
|
|
config->stripDebug = args.hasArg(OPT_strip_debug);
|
|
config->stackFirst = args.hasArg(OPT_stack_first);
|
|
config->trace = args.hasArg(OPT_trace);
|
|
config->thinLTOCacheDir = args.getLastArgValue(OPT_thinlto_cache_dir);
|
|
config->thinLTOCachePolicy = CHECK(
|
|
parseCachePruningPolicy(args.getLastArgValue(OPT_thinlto_cache_policy)),
|
|
"--thinlto-cache-policy: invalid cache policy");
|
|
config->thinLTOJobs = args::getInteger(args, OPT_thinlto_jobs, -1u);
|
|
errorHandler().verbose = args.hasArg(OPT_verbose);
|
|
LLVM_DEBUG(errorHandler().verbose = true);
|
|
threadsEnabled = args.hasFlag(OPT_threads, OPT_no_threads, true);
|
|
|
|
config->initialMemory = args::getInteger(args, OPT_initial_memory, 0);
|
|
config->globalBase = args::getInteger(args, OPT_global_base, 1024);
|
|
config->maxMemory = args::getInteger(args, OPT_max_memory, 0);
|
|
config->zStackSize =
|
|
args::getZOptionValue(args, OPT_z, "stack-size", WasmPageSize);
|
|
|
|
// Default value of exportDynamic depends on `-shared`
|
|
config->exportDynamic =
|
|
args.hasFlag(OPT_export_dynamic, OPT_no_export_dynamic, config->shared);
|
|
|
|
if (auto *arg = args.getLastArg(OPT_features)) {
|
|
config->features =
|
|
llvm::Optional<std::vector<std::string>>(std::vector<std::string>());
|
|
for (StringRef s : arg->getValues())
|
|
config->features->push_back(s);
|
|
}
|
|
}
|
|
|
|
// Some Config members do not directly correspond to any particular
|
|
// command line options, but computed based on other Config values.
|
|
// This function initialize such members. See Config.h for the details
|
|
// of these values.
|
|
static void setConfigs() {
|
|
config->isPic = config->pie || config->shared;
|
|
|
|
if (config->isPic) {
|
|
if (config->exportTable)
|
|
error("-shared/-pie is incompatible with --export-table");
|
|
config->importTable = true;
|
|
}
|
|
|
|
if (config->shared) {
|
|
config->importMemory = true;
|
|
config->allowUndefined = true;
|
|
}
|
|
}
|
|
|
|
// Some command line options or some combinations of them are not allowed.
|
|
// This function checks for such errors.
|
|
static void checkOptions(opt::InputArgList &args) {
|
|
if (!config->stripDebug && !config->stripAll && config->compressRelocations)
|
|
error("--compress-relocations is incompatible with output debug"
|
|
" information. Please pass --strip-debug or --strip-all");
|
|
|
|
if (config->ltoo > 3)
|
|
error("invalid optimization level for LTO: " + Twine(config->ltoo));
|
|
if (config->ltoPartitions == 0)
|
|
error("--lto-partitions: number of threads must be > 0");
|
|
if (config->thinLTOJobs == 0)
|
|
error("--thinlto-jobs: number of threads must be > 0");
|
|
|
|
if (config->pie && config->shared)
|
|
error("-shared and -pie may not be used together");
|
|
|
|
if (config->outputFile.empty())
|
|
error("no output file specified");
|
|
|
|
if (config->importTable && config->exportTable)
|
|
error("--import-table and --export-table may not be used together");
|
|
|
|
if (config->relocatable) {
|
|
if (!config->entry.empty())
|
|
error("entry point specified for relocatable output file");
|
|
if (config->gcSections)
|
|
error("-r and --gc-sections may not be used together");
|
|
if (config->compressRelocations)
|
|
error("-r -and --compress-relocations may not be used together");
|
|
if (args.hasArg(OPT_undefined))
|
|
error("-r -and --undefined may not be used together");
|
|
if (config->pie)
|
|
error("-r and -pie may not be used together");
|
|
}
|
|
}
|
|
|
|
// Force Sym to be entered in the output. Used for -u or equivalent.
|
|
static Symbol *handleUndefined(StringRef name) {
|
|
Symbol *sym = symtab->find(name);
|
|
if (!sym)
|
|
return nullptr;
|
|
|
|
// Since symbol S may not be used inside the program, LTO may
|
|
// eliminate it. Mark the symbol as "used" to prevent it.
|
|
sym->isUsedInRegularObj = true;
|
|
|
|
if (auto *lazySym = dyn_cast<LazySymbol>(sym))
|
|
lazySym->fetch();
|
|
|
|
return sym;
|
|
}
|
|
|
|
static UndefinedGlobal *
|
|
createUndefinedGlobal(StringRef name, llvm::wasm::WasmGlobalType *type) {
|
|
auto *sym = cast<UndefinedGlobal>(symtab->addUndefinedGlobal(
|
|
name, name, defaultModule, WASM_SYMBOL_UNDEFINED, nullptr, type));
|
|
config->allowUndefinedSymbols.insert(sym->getName());
|
|
sym->isUsedInRegularObj = true;
|
|
return sym;
|
|
}
|
|
|
|
static GlobalSymbol *createGlobalVariable(StringRef name, bool isMutable,
|
|
int value) {
|
|
llvm::wasm::WasmGlobal wasmGlobal;
|
|
wasmGlobal.Type = {WASM_TYPE_I32, isMutable};
|
|
wasmGlobal.InitExpr.Value.Int32 = value;
|
|
wasmGlobal.InitExpr.Opcode = WASM_OPCODE_I32_CONST;
|
|
wasmGlobal.SymbolName = name;
|
|
return symtab->addSyntheticGlobal(name, WASM_SYMBOL_VISIBILITY_HIDDEN,
|
|
make<InputGlobal>(wasmGlobal, nullptr));
|
|
}
|
|
|
|
// Create ABI-defined synthetic symbols
|
|
static void createSyntheticSymbols() {
|
|
if (config->relocatable)
|
|
return;
|
|
|
|
static WasmSignature nullSignature = {{}, {}};
|
|
static WasmSignature i32ArgSignature = {{}, {ValType::I32}};
|
|
static llvm::wasm::WasmGlobalType globalTypeI32 = {WASM_TYPE_I32, false};
|
|
static llvm::wasm::WasmGlobalType mutableGlobalTypeI32 = {WASM_TYPE_I32,
|
|
true};
|
|
WasmSym::callCtors = symtab->addSyntheticFunction(
|
|
"__wasm_call_ctors", WASM_SYMBOL_VISIBILITY_HIDDEN,
|
|
make<SyntheticFunction>(nullSignature, "__wasm_call_ctors"));
|
|
|
|
if (config->isPic) {
|
|
// For PIC code we create a synthetic function __wasm_apply_relocs which
|
|
// is called from __wasm_call_ctors before the user-level constructors.
|
|
WasmSym::applyRelocs = symtab->addSyntheticFunction(
|
|
"__wasm_apply_relocs", WASM_SYMBOL_VISIBILITY_HIDDEN,
|
|
make<SyntheticFunction>(nullSignature, "__wasm_apply_relocs"));
|
|
}
|
|
|
|
|
|
if (config->isPic) {
|
|
WasmSym::stackPointer =
|
|
createUndefinedGlobal("__stack_pointer", &mutableGlobalTypeI32);
|
|
// For PIC code, we import two global variables (__memory_base and
|
|
// __table_base) from the environment and use these as the offset at
|
|
// which to load our static data and function table.
|
|
// See:
|
|
// https://github.com/WebAssembly/tool-conventions/blob/master/DynamicLinking.md
|
|
WasmSym::memoryBase =
|
|
createUndefinedGlobal("__memory_base", &globalTypeI32);
|
|
WasmSym::tableBase = createUndefinedGlobal("__table_base", &globalTypeI32);
|
|
WasmSym::memoryBase->markLive();
|
|
WasmSym::tableBase->markLive();
|
|
} else {
|
|
// For non-PIC code
|
|
WasmSym::stackPointer = createGlobalVariable("__stack_pointer", true, 0);
|
|
WasmSym::stackPointer->markLive();
|
|
}
|
|
|
|
if (config->sharedMemory && !config->shared) {
|
|
// Passive segments are used to avoid memory being reinitialized on each
|
|
// thread's instantiation. These passive segments are initialized and
|
|
// dropped in __wasm_init_memory, which is registered as the start function
|
|
WasmSym::initMemory = symtab->addSyntheticFunction(
|
|
"__wasm_init_memory", WASM_SYMBOL_VISIBILITY_HIDDEN,
|
|
make<SyntheticFunction>(nullSignature, "__wasm_init_memory"));
|
|
WasmSym::initMemoryFlag = symtab->addSyntheticDataSymbol(
|
|
"__wasm_init_memory_flag", WASM_SYMBOL_VISIBILITY_HIDDEN);
|
|
assert(WasmSym::initMemoryFlag);
|
|
WasmSym::tlsBase = createGlobalVariable("__tls_base", true, 0);
|
|
WasmSym::tlsSize = createGlobalVariable("__tls_size", false, 0);
|
|
WasmSym::tlsAlign = createGlobalVariable("__tls_align", false, 1);
|
|
WasmSym::initTLS = symtab->addSyntheticFunction(
|
|
"__wasm_init_tls", WASM_SYMBOL_VISIBILITY_HIDDEN,
|
|
make<SyntheticFunction>(i32ArgSignature, "__wasm_init_tls"));
|
|
}
|
|
}
|
|
|
|
static void createOptionalSymbols() {
|
|
if (config->relocatable)
|
|
return;
|
|
|
|
WasmSym::dsoHandle = symtab->addOptionalDataSymbol("__dso_handle");
|
|
|
|
if (!config->shared)
|
|
WasmSym::dataEnd = symtab->addOptionalDataSymbol("__data_end");
|
|
|
|
if (!config->isPic) {
|
|
WasmSym::globalBase = symtab->addOptionalDataSymbol("__global_base");
|
|
WasmSym::heapBase = symtab->addOptionalDataSymbol("__heap_base");
|
|
WasmSym::definedMemoryBase = symtab->addOptionalDataSymbol("__memory_base");
|
|
WasmSym::definedTableBase = symtab->addOptionalDataSymbol("__table_base");
|
|
}
|
|
}
|
|
|
|
// Reconstructs command line arguments so that so that you can re-run
|
|
// the same command with the same inputs. This is for --reproduce.
|
|
static std::string createResponseFile(const opt::InputArgList &args) {
|
|
SmallString<0> data;
|
|
raw_svector_ostream os(data);
|
|
|
|
// Copy the command line to the output while rewriting paths.
|
|
for (auto *arg : args) {
|
|
switch (arg->getOption().getID()) {
|
|
case OPT_reproduce:
|
|
break;
|
|
case OPT_INPUT:
|
|
os << quote(relativeToRoot(arg->getValue())) << "\n";
|
|
break;
|
|
case OPT_o:
|
|
// If -o path contains directories, "lld @response.txt" will likely
|
|
// fail because the archive we are creating doesn't contain empty
|
|
// directories for the output path (-o doesn't create directories).
|
|
// Strip directories to prevent the issue.
|
|
os << "-o " << quote(sys::path::filename(arg->getValue())) << "\n";
|
|
break;
|
|
default:
|
|
os << toString(*arg) << "\n";
|
|
}
|
|
}
|
|
return data.str();
|
|
}
|
|
|
|
// The --wrap option is a feature to rename symbols so that you can write
|
|
// wrappers for existing functions. If you pass `-wrap=foo`, all
|
|
// occurrences of symbol `foo` are resolved to `wrap_foo` (so, you are
|
|
// expected to write `wrap_foo` function as a wrapper). The original
|
|
// symbol becomes accessible as `real_foo`, so you can call that from your
|
|
// wrapper.
|
|
//
|
|
// This data structure is instantiated for each -wrap option.
|
|
struct WrappedSymbol {
|
|
Symbol *sym;
|
|
Symbol *real;
|
|
Symbol *wrap;
|
|
};
|
|
|
|
static Symbol *addUndefined(StringRef name) {
|
|
return symtab->addUndefinedFunction(name, "", "", WASM_SYMBOL_UNDEFINED,
|
|
nullptr, nullptr, false);
|
|
}
|
|
|
|
// Handles -wrap option.
|
|
//
|
|
// This function instantiates wrapper symbols. At this point, they seem
|
|
// like they are not being used at all, so we explicitly set some flags so
|
|
// that LTO won't eliminate them.
|
|
static std::vector<WrappedSymbol> addWrappedSymbols(opt::InputArgList &args) {
|
|
std::vector<WrappedSymbol> v;
|
|
DenseSet<StringRef> seen;
|
|
|
|
for (auto *arg : args.filtered(OPT_wrap)) {
|
|
StringRef name = arg->getValue();
|
|
if (!seen.insert(name).second)
|
|
continue;
|
|
|
|
Symbol *sym = symtab->find(name);
|
|
if (!sym)
|
|
continue;
|
|
|
|
Symbol *real = addUndefined(saver.save("__real_" + name));
|
|
Symbol *wrap = addUndefined(saver.save("__wrap_" + name));
|
|
v.push_back({sym, real, wrap});
|
|
|
|
// We want to tell LTO not to inline symbols to be overwritten
|
|
// because LTO doesn't know the final symbol contents after renaming.
|
|
real->canInline = false;
|
|
sym->canInline = false;
|
|
|
|
// Tell LTO not to eliminate these symbols.
|
|
sym->isUsedInRegularObj = true;
|
|
wrap->isUsedInRegularObj = true;
|
|
real->isUsedInRegularObj = false;
|
|
}
|
|
return v;
|
|
}
|
|
|
|
// Do renaming for -wrap by updating pointers to symbols.
|
|
//
|
|
// When this function is executed, only InputFiles and symbol table
|
|
// contain pointers to symbol objects. We visit them to replace pointers,
|
|
// so that wrapped symbols are swapped as instructed by the command line.
|
|
static void wrapSymbols(ArrayRef<WrappedSymbol> wrapped) {
|
|
DenseMap<Symbol *, Symbol *> map;
|
|
for (const WrappedSymbol &w : wrapped) {
|
|
map[w.sym] = w.wrap;
|
|
map[w.real] = w.sym;
|
|
}
|
|
|
|
// Update pointers in input files.
|
|
parallelForEach(symtab->objectFiles, [&](InputFile *file) {
|
|
MutableArrayRef<Symbol *> syms = file->getMutableSymbols();
|
|
for (size_t i = 0, e = syms.size(); i != e; ++i)
|
|
if (Symbol *s = map.lookup(syms[i]))
|
|
syms[i] = s;
|
|
});
|
|
|
|
// Update pointers in the symbol table.
|
|
for (const WrappedSymbol &w : wrapped)
|
|
symtab->wrap(w.sym, w.real, w.wrap);
|
|
}
|
|
|
|
void LinkerDriver::link(ArrayRef<const char *> argsArr) {
|
|
WasmOptTable parser;
|
|
opt::InputArgList args = parser.parse(argsArr.slice(1));
|
|
|
|
// Handle --help
|
|
if (args.hasArg(OPT_help)) {
|
|
parser.PrintHelp(outs(),
|
|
(std::string(argsArr[0]) + " [options] file...").c_str(),
|
|
"LLVM Linker", false);
|
|
return;
|
|
}
|
|
|
|
// Handle --version
|
|
if (args.hasArg(OPT_version) || args.hasArg(OPT_v)) {
|
|
outs() << getLLDVersion() << "\n";
|
|
return;
|
|
}
|
|
|
|
// Handle --reproduce
|
|
if (auto *arg = args.getLastArg(OPT_reproduce)) {
|
|
StringRef path = arg->getValue();
|
|
Expected<std::unique_ptr<TarWriter>> errOrWriter =
|
|
TarWriter::create(path, path::stem(path));
|
|
if (errOrWriter) {
|
|
tar = std::move(*errOrWriter);
|
|
tar->append("response.txt", createResponseFile(args));
|
|
tar->append("version.txt", getLLDVersion() + "\n");
|
|
} else {
|
|
error("--reproduce: " + toString(errOrWriter.takeError()));
|
|
}
|
|
}
|
|
|
|
// Parse and evaluate -mllvm options.
|
|
std::vector<const char *> v;
|
|
v.push_back("wasm-ld (LLVM option parsing)");
|
|
for (auto *arg : args.filtered(OPT_mllvm))
|
|
v.push_back(arg->getValue());
|
|
cl::ParseCommandLineOptions(v.size(), v.data());
|
|
|
|
errorHandler().errorLimit = args::getInteger(args, OPT_error_limit, 20);
|
|
|
|
readConfigs(args);
|
|
setConfigs();
|
|
checkOptions(args);
|
|
|
|
if (auto *arg = args.getLastArg(OPT_allow_undefined_file))
|
|
readImportFile(arg->getValue());
|
|
|
|
if (!args.hasArg(OPT_INPUT)) {
|
|
error("no input files");
|
|
return;
|
|
}
|
|
|
|
// Handle --trace-symbol.
|
|
for (auto *arg : args.filtered(OPT_trace_symbol))
|
|
symtab->trace(arg->getValue());
|
|
|
|
for (auto *arg : args.filtered(OPT_export))
|
|
config->exportedSymbols.insert(arg->getValue());
|
|
|
|
createSyntheticSymbols();
|
|
|
|
createFiles(args);
|
|
if (errorCount())
|
|
return;
|
|
|
|
// Add all files to the symbol table. This will add almost all
|
|
// symbols that we need to the symbol table.
|
|
for (InputFile *f : files)
|
|
symtab->addFile(f);
|
|
if (errorCount())
|
|
return;
|
|
|
|
// Handle the `--undefined <sym>` options.
|
|
for (auto *arg : args.filtered(OPT_undefined))
|
|
handleUndefined(arg->getValue());
|
|
|
|
// Handle the `--export <sym>` options
|
|
// This works like --undefined but also exports the symbol if its found
|
|
for (auto *arg : args.filtered(OPT_export))
|
|
handleUndefined(arg->getValue());
|
|
|
|
Symbol *entrySym = nullptr;
|
|
if (!config->relocatable && !config->entry.empty()) {
|
|
entrySym = handleUndefined(config->entry);
|
|
if (entrySym && entrySym->isDefined())
|
|
entrySym->forceExport = true;
|
|
else
|
|
error("entry symbol not defined (pass --no-entry to supress): " +
|
|
config->entry);
|
|
}
|
|
|
|
createOptionalSymbols();
|
|
|
|
if (errorCount())
|
|
return;
|
|
|
|
// Create wrapped symbols for -wrap option.
|
|
std::vector<WrappedSymbol> wrapped = addWrappedSymbols(args);
|
|
|
|
// Do link-time optimization if given files are LLVM bitcode files.
|
|
// This compiles bitcode files into real object files.
|
|
symtab->addCombinedLTOObject();
|
|
if (errorCount())
|
|
return;
|
|
|
|
// Resolve any variant symbols that were created due to signature
|
|
// mismatchs.
|
|
symtab->handleSymbolVariants();
|
|
if (errorCount())
|
|
return;
|
|
|
|
// Apply symbol renames for -wrap.
|
|
if (!wrapped.empty())
|
|
wrapSymbols(wrapped);
|
|
|
|
for (auto *arg : args.filtered(OPT_export)) {
|
|
Symbol *sym = symtab->find(arg->getValue());
|
|
if (sym && sym->isDefined())
|
|
sym->forceExport = true;
|
|
else if (!config->allowUndefined)
|
|
error(Twine("symbol exported via --export not found: ") +
|
|
arg->getValue());
|
|
}
|
|
|
|
if (!config->relocatable) {
|
|
// Add synthetic dummies for weak undefined functions. Must happen
|
|
// after LTO otherwise functions may not yet have signatures.
|
|
symtab->handleWeakUndefines();
|
|
}
|
|
|
|
if (entrySym)
|
|
entrySym->setHidden(false);
|
|
|
|
if (errorCount())
|
|
return;
|
|
|
|
// Do size optimizations: garbage collection
|
|
markLive();
|
|
|
|
// Write the result to the file.
|
|
writeResult();
|
|
}
|