Driver.cpp | Explore in Territory

//===- 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 "InputElement.h"
#include "MarkLive.h"
#include "SymbolTable.h"
#include "Writer.h"
#include "lld/Common/Args.h"
#include "lld/Common/CommonLinkerContext.h"
#include "lld/Common/ErrorHandler.h"
#include "lld/Common/Filesystem.h"
#include "lld/Common/Memory.h"
#include "lld/Common/Reproduce.h"
#include "lld/Common/Strings.h"
#include "lld/Common/Version.h"
#include "llvm/ADT/Twine.h"
#include "llvm/Config/llvm-config.h"
#include "llvm/Object/Wasm.h"
#include "llvm/Option/Arg.h"
#include "llvm/Option/ArgList.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/Parallel.h"
#include "llvm/Support/Path.h"
#include "llvm/Support/Process.h"
#include "llvm/Support/TarWriter.h"
#include "llvm/Support/TargetSelect.h"
#include "llvm/TargetParser/Host.h"
#include <optional>

#define DEBUG_TYPE …

usingnamespacellvm;
usingnamespacellvm::object;
usingnamespacellvm::opt;
usingnamespacellvm::sys;
usingnamespacellvm::wasm;

namespace lld::wasm {
Configuration *config;
Ctx ctx;

void Ctx::reset() { … }

namespace {

// Create enum with OPT_xxx values for each option in Options.td
enum { … };

// 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() { … }

class LinkerDriver { … };
} // anonymous namespace

bool link(ArrayRef<const char *> args, llvm::raw_ostream &stdoutOS,
          llvm::raw_ostream &stderrOS, bool exitEarly, bool disableOutput) { … }

// Create prefix string literals used in Options.td
#define PREFIX …
#include "Options.inc"
#undef PREFIX

// Create table mapping all options defined in Options.td
static constexpr opt::OptTable::Info optInfo[] = …;

namespace {
class WasmOptTable : public opt::GenericOptTable { … };
} // namespace

// Set color diagnostics according to -color-diagnostics={auto,always,never}
// or -no-color-diagnostics flags.
static void handleColorDiagnostics(opt::InputArgList &args) { … }

static cl::TokenizerCallback getQuotingStyle(opt::InputArgList &args) { … }

// Find a file by concatenating given paths.
static std::optional<std::string> findFile(StringRef path1,
                                           const Twine &path2) { … }

opt::InputArgList WasmOptTable::parse(ArrayRef<const char *> argv) { … }

// 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) { … }

// Returns slices of MB by parsing MB as an archive file.
// Each slice consists of a member file in the archive.
std::vector<std::pair<MemoryBufferRef, uint64_t>> static getArchiveMembers(
    MemoryBufferRef mb) { … }

void LinkerDriver::addFile(StringRef path) { … }

static std::optional<std::string> findFromSearchPaths(StringRef path) { … }

// This is for -l<basename>. We'll look for lib<basename>.a from
// search paths.
static std::optional<std::string> searchLibraryBaseName(StringRef name) { … }

// This is for -l<namespec>.
static std::optional<std::string> searchLibrary(StringRef name) { … }

// Add a given library by searching it from input search paths.
void LinkerDriver::addLibrary(StringRef name) { … }

void LinkerDriver::createFiles(opt::InputArgList &args) { … }

static StringRef getEntry(opt::InputArgList &args) { … }

// Determines what we should do if there are remaining unresolved
// symbols after the name resolution.
static UnresolvedPolicy getUnresolvedSymbolPolicy(opt::InputArgList &args) { … }

// Parse --build-id or --build-id=<style>. We handle "tree" as a
// synonym for "sha1" because all our hash functions including
// -build-id=sha1 are actually tree hashes for performance reasons.
static std::pair<BuildIdKind, SmallVector<uint8_t, 0>>
getBuildId(opt::InputArgList &args) { … }

// Initializes Config members by the command line options.
static void readConfigs(opt::InputArgList &args) { … }

// 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() { … }

// Some command line options or some combinations of them are not allowed.
// This function checks for such errors.
static void checkOptions(opt::InputArgList &args) { … }

static const char *getReproduceOption(opt::InputArgList &args) { … }

// Force Sym to be entered in the output. Used for -u or equivalent.
static Symbol *handleUndefined(StringRef name, const char *option) { … }

static void handleLibcall(StringRef name) { … }

static void writeWhyExtract() { … }

// Equivalent of demote demoteSharedAndLazySymbols() in the ELF linker
static void demoteLazySymbols() { … }

static UndefinedGlobal *
createUndefinedGlobal(StringRef name, llvm::wasm::WasmGlobalType *type) { … }

static InputGlobal *createGlobal(StringRef name, bool isMutable) { … }

static GlobalSymbol *createGlobalVariable(StringRef name, bool isMutable) { … }

static GlobalSymbol *createOptionalGlobal(StringRef name, bool isMutable) { … }

// Create ABI-defined synthetic symbols
static void createSyntheticSymbols() { … }

static void createOptionalSymbols() { … }

static void processStubLibrariesPreLTO() { … }

static bool addStubSymbolDeps(const StubFile *stub_file, Symbol *sym,
                              ArrayRef<StringRef> deps) { … }

static void processStubLibraries() { … }

// 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) { … }

// 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 { … };

static Symbol *addUndefined(StringRef name) { … }

// 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) { … }

// 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) { … }

static void splitSections() { … }

static bool isKnownZFlag(StringRef s) { … }

// Report a warning for an unknown -z option.
static void checkZOptions(opt::InputArgList &args) { … }

void LinkerDriver::linkerMain(ArrayRef<const char *> argsArr) { … }

} // namespace lld::wasm
llvm/lld/wasm/Driver.cpp
