vendor/lld/lld-trunk-r321017

1 files changed, 321 insertions, 0 deletions

diff --git a/wasm/Driver.cpp b/wasm/Driver.cpp
new file mode 100644
index 000000000000..97ec262be308
--- /dev/null
+++ b/wasm/Driver.cpp
@@ -0,0 +1,321 @@
+//===- Driver.cpp ---------------------------------------------------------===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "lld/Common/Driver.h"
+#include "Config.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/Threads.h"
+#include "lld/Common/Version.h"
+#include "llvm/ADT/Twine.h"
+#include "llvm/Object/Wasm.h"
+#include "llvm/Option/ArgList.h"
+#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/Path.h"
+#include "llvm/Support/Process.h"
+
+using namespace llvm;
+using namespace llvm::sys;
+using namespace llvm::wasm;
+
+using namespace lld;
+using namespace lld::wasm;
+
+namespace {
+
+// Parses command line options.
+class WasmOptTable : public llvm::opt::OptTable {
+public:
+  WasmOptTable();
+  llvm::opt::InputArgList parse(ArrayRef<const char *> Argv);
+};
+
+// 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
+};
+
+class LinkerDriver {
+public:
+  void link(ArrayRef<const char *> ArgsArr);
+
+private:
+  void createFiles(llvm::opt::InputArgList &Args);
+  void addFile(StringRef Path);
+  void addLibrary(StringRef Name);
+  std::vector<InputFile *> Files;
+};
+
+} // anonymous namespace
+
+Configuration *lld::wasm::Config;
+
+bool lld::wasm::link(ArrayRef<const char *> Args, bool CanExitEarly,
+                     raw_ostream &Error) {
+  errorHandler().LogName = Args[0];
+  errorHandler().ErrorOS = &Error;
+  errorHandler().ColorDiagnostics = Error.has_colors();
+  errorHandler().ErrorLimitExceededMsg =
+      "too many errors emitted, stopping now (use "
+      "-error-limit=0 to see all errors)";
+
+  Config = make<Configuration>();
+  Symtab = make<SymbolTable>();
+
+  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 OptTable
+
+// 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
+};
+
+// 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)
+    errorHandler().ColorDiagnostics = true;
+  else if (Arg->getOption().getID() == OPT_no_color_diagnostics)
+    errorHandler().ColorDiagnostics = false;
+  else {
+    StringRef S = Arg->getValue();
+    if (S == "always")
+      errorHandler().ColorDiagnostics = true;
+    if (S == "never")
+      errorHandler().ColorDiagnostics = false;
+    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;
+}
+
+// Inject a new undefined symbol into the link.  This will cause the link to
+// fail unless this symbol can be found.
+static void addSyntheticUndefinedFunction(StringRef Name,
+                                          const WasmSignature *Type) {
+  log("injecting undefined func: " + Name);
+  Symtab->addUndefinedFunction(Name, Type);
+}
+
+static void printHelp(const char *Argv0) {
+  WasmOptTable().PrintHelp(outs(), Argv0, "LLVM Linker", false);
+}
+
+WasmOptTable::WasmOptTable() : OptTable(OptInfo) {}
+
+opt::InputArgList WasmOptTable::parse(ArrayRef<const char *> Argv) {
+  SmallVector<const char *, 256> Vec(Argv.data(), Argv.data() + Argv.size());
+
+  unsigned MissingIndex;
+  unsigned MissingCount;
+  opt::InputArgList Args = this->ParseArgs(Vec, MissingIndex, MissingCount);
+
+  handleColorDiagnostics(Args);
+  for (auto *Arg : Args.filtered(OPT_UNKNOWN))
+    error("unknown argument: " + Arg->getSpelling());
+  return Args;
+}
+
+void LinkerDriver::addFile(StringRef Path) {
+  Optional<MemoryBufferRef> Buffer = readFile(Path);
+  if (!Buffer.hasValue())
+    return;
+  MemoryBufferRef MBRef = *Buffer;
+
+  if (identify_magic(MBRef.getBuffer()) == file_magic::archive)
+    Files.push_back(make<ArchiveFile>(MBRef));
+  else
+    Files.push_back(make<ObjFile>(MBRef));
+}
+
+// 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().getUnaliasedOption().getID()) {
+    case OPT_l:
+      addLibrary(Arg->getValue());
+      break;
+    case OPT_INPUT:
+      addFile(Arg->getValue());
+      break;
+    }
+  }
+
+  if (Files.empty())
+    error("no input files");
+}
+
+static StringRef getEntry(opt::InputArgList &Args, StringRef Default) {
+  auto *Arg = Args.getLastArg(OPT_entry, OPT_no_entry);
+  if (!Arg)
+    return Default;
+  if (Arg->getOption().getID() == OPT_no_entry)
+    return "";
+  return Arg->getValue();
+}
+
+void LinkerDriver::link(ArrayRef<const char *> ArgsArr) {
+  WasmOptTable Parser;
+  opt::InputArgList Args = Parser.parse(ArgsArr.slice(1));
+
+  // Handle --help
+  if (Args.hasArg(OPT_help)) {
+    printHelp(ArgsArr[0]);
+    return;
+  }
+
+  // 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);
+
+  if (Args.hasArg(OPT_version) || Args.hasArg(OPT_v)) {
+    outs() << getLLDVersion() << "\n";
+    return;
+  }
+
+  Config->AllowUndefined = Args.hasArg(OPT_allow_undefined);
+  Config->CheckSignatures =
+      Args.hasFlag(OPT_check_signatures, OPT_no_check_signatures, false);
+  Config->EmitRelocs = Args.hasArg(OPT_emit_relocs);
+  Config->Entry = getEntry(Args, Args.hasArg(OPT_relocatable) ? "" : "_start");
+  Config->ImportMemory = Args.hasArg(OPT_import_memory);
+  Config->OutputFile = Args.getLastArgValue(OPT_o);
+  Config->Relocatable = Args.hasArg(OPT_relocatable);
+  Config->SearchPaths = args::getStrings(Args, OPT_L);
+  Config->StripAll = Args.hasArg(OPT_strip_all);
+  Config->StripDebug = Args.hasArg(OPT_strip_debug);
+  errorHandler().Verbose = Args.hasArg(OPT_verbose);
+  ThreadsEnabled = Args.hasFlag(OPT_threads, OPT_no_threads, true);
+  if (Config->Relocatable)
+    Config->EmitRelocs = 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);
+
+  if (auto *Arg = Args.getLastArg(OPT_allow_undefined_file))
+    if (Optional<MemoryBufferRef> Buf = readFile(Arg->getValue()))
+      for (StringRef Sym : args::getLines(*Buf))
+        Config->AllowUndefinedSymbols.insert(Sym);
+
+  if (Config->OutputFile.empty())
+    error("no output file specified");
+
+  if (!Args.hasArg(OPT_INPUT))
+    error("no input files");
+
+  if (Config->Relocatable && !Config->Entry.empty())
+    error("entry point specified for relocatable output file");
+  if (Config->Relocatable && Args.hasArg(OPT_undefined))
+    error("undefined symbols specified for relocatable output file");
+
+  if (!Config->Relocatable) {
+    if (!Config->Entry.empty()) {
+      static WasmSignature Signature = {{}, WASM_TYPE_NORESULT};
+      addSyntheticUndefinedFunction(Config->Entry, &Signature);
+    }
+
+    // Handle the `--undefined <sym>` options.
+    for (StringRef S : args::getStrings(Args, OPT_undefined))
+      addSyntheticUndefinedFunction(S, nullptr);
+
+    Config->StackPointerSymbol = Symtab->addDefinedGlobal("__stack_pointer");
+  }
+
+  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);
+
+  // Make sure we have resolved all symbols.
+  if (!Config->Relocatable && !Config->AllowUndefined) {
+    Symtab->reportRemainingUndefines();
+  } else {
+    // When we allow undefined symbols we cannot include those defined in
+    // -u/--undefined since these undefined symbols have only names and no
+    // function signature, which means they cannot be written to the final
+    // output.
+    for (StringRef S : args::getStrings(Args, OPT_undefined)) {
+      Symbol *Sym = Symtab->find(S);
+      if (!Sym->isDefined())
+        error("function forced with --undefined not found: " + Sym->getName());
+    }
+  }
+  if (errorCount())
+    return;
+
+  if (!Config->Entry.empty() && !Symtab->find(Config->Entry)->isDefined())
+    error("entry point not found: " + Config->Entry);
+  if (errorCount())
+    return;
+
+  // Write the result to the file.
+  writeResult();
+}