lld/wasm/Driver.cpp

   1 //===- Driver.cpp ---------------------------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "lld/Common/Driver.h"
  10 #include "Config.h"
  11 #include "InputChunks.h"
  12 #include "InputElement.h"
  13 #include "MarkLive.h"
  14 #include "SymbolTable.h"
  15 #include "Writer.h"
  16 #include "lld/Common/Args.h"
  17 #include "lld/Common/ErrorHandler.h"
  18 #include "lld/Common/Filesystem.h"
  19 #include "lld/Common/Memory.h"
  20 #include "lld/Common/Reproduce.h"
  21 #include "lld/Common/Strings.h"
  22 #include "lld/Common/Version.h"
  23 #include "llvm/ADT/Twine.h"
  24 #include "llvm/Config/llvm-config.h"
  25 #include "llvm/Object/Wasm.h"
  26 #include "llvm/Option/Arg.h"
  27 #include "llvm/Option/ArgList.h"
  28 #include "llvm/Support/CommandLine.h"
  29 #include "llvm/Support/Host.h"
  30 #include "llvm/Support/Parallel.h"
  31 #include "llvm/Support/Path.h"
  32 #include "llvm/Support/Process.h"
  33 #include "llvm/Support/TarWriter.h"
  34 #include "llvm/Support/TargetSelect.h"
  35
  36 #define DEBUG_TYPE "lld"
  37
  38 using namespace llvm;
  39 using namespace llvm::object;
  40 using namespace llvm::sys;
  41 using namespace llvm::wasm;
  42
  43 namespace lld {
  44 namespace wasm {
  45 Configuration *config;
  46
  47 namespace {
  48
  49 // Create enum with OPT_xxx values for each option in Options.td
  50 enum {
  51   OPT_INVALID = 0,
  52 #define OPTION(_1, _2, ID, _4, _5, _6, _7, _8, _9, _10, _11, _12) OPT_##ID,
  53 #include "Options.inc"
  54 #undef OPTION
  55 };
  56
  57 // This function is called on startup. We need this for LTO since
  58 // LTO calls LLVM functions to compile bitcode files to native code.
  59 // Technically this can be delayed until we read bitcode files, but
  60 // we don't bother to do lazily because the initialization is fast.
  61 static void initLLVM() {
  62   InitializeAllTargets();
  63   InitializeAllTargetMCs();
  64   InitializeAllAsmPrinters();
  65   InitializeAllAsmParsers();
  66 }
  67
  68 class LinkerDriver {
  69 public:
  70   void linkerMain(ArrayRef<const char *> argsArr);
  71
  72 private:
  73   void createFiles(opt::InputArgList &args);
  74   void addFile(StringRef path);
  75   void addLibrary(StringRef name);
  76
  77   // True if we are in --whole-archive and --no-whole-archive.
  78   bool inWholeArchive = false;
  79
  80   std::vector<InputFile *> files;
  81 };
  82 } // anonymous namespace
  83
  84 bool link(ArrayRef<const char *> args, bool canExitEarly, raw_ostream &stdoutOS,
  85           raw_ostream &stderrOS) {
  86   lld::stdoutOS = &stdoutOS;
  87   lld::stderrOS = &stderrOS;
  88
  89   errorHandler().cleanupCallback = []() { freeArena(); };
  90
  91   errorHandler().logName = args::getFilenameWithoutExe(args[0]);
  92   errorHandler().errorLimitExceededMsg =
  93       "too many errors emitted, stopping now (use "
  94       "-error-limit=0 to see all errors)";
  95   stderrOS.enable_colors(stderrOS.has_colors());
  96
  97   config = make<Configuration>();
  98   symtab = make<SymbolTable>();
  99
 100   initLLVM();
 101   LinkerDriver().linkerMain(args);
 102
 103   // Exit immediately if we don't need to return to the caller.
 104   // This saves time because the overhead of calling destructors
 105   // for all globally-allocated objects is not negligible.
 106   if (canExitEarly)
 107     exitLld(errorCount() ? 1 : 0);
 108
 109   return !errorCount();
 110 }
 111
 112 // Create prefix string literals used in Options.td
 113 #define PREFIX(NAME, VALUE) const char *const NAME[] = VALUE;
 114 #include "Options.inc"
 115 #undef PREFIX
 116
 117 // Create table mapping all options defined in Options.td
 118 static const opt::OptTable::Info optInfo[] = {
 119 #define OPTION(X1, X2, ID, KIND, GROUP, ALIAS, X7, X8, X9, X10, X11, X12)      \
 120   {X1, X2, X10,         X11,         OPT_##ID, opt::Option::KIND##Class,       \
 121    X9, X8, OPT_##GROUP, OPT_##ALIAS, X7,       X12},
 122 #include "Options.inc"
 123 #undef OPTION
 124 };
 125
 126 namespace {
 127 class WasmOptTable : public llvm::opt::OptTable {
 128 public:
 129   WasmOptTable() : OptTable(optInfo) {}
 130   opt::InputArgList parse(ArrayRef<const char *> argv);
 131 };
 132 } // namespace
 133
 134 // Set color diagnostics according to -color-diagnostics={auto,always,never}
 135 // or -no-color-diagnostics flags.
 136 static void handleColorDiagnostics(opt::InputArgList &args) {
 137   auto *arg = args.getLastArg(OPT_color_diagnostics, OPT_color_diagnostics_eq,
 138                               OPT_no_color_diagnostics);
 139   if (!arg)
 140     return;
 141   if (arg->getOption().getID() == OPT_color_diagnostics) {
 142     lld::errs().enable_colors(true);
 143   } else if (arg->getOption().getID() == OPT_no_color_diagnostics) {
 144     lld::errs().enable_colors(false);
 145   } else {
 146     StringRef s = arg->getValue();
 147     if (s == "always")
 148       lld::errs().enable_colors(true);
 149     else if (s == "never")
 150       lld::errs().enable_colors(false);
 151     else if (s != "auto")
 152       error("unknown option: --color-diagnostics=" + s);
 153   }
 154 }
 155
 156 static cl::TokenizerCallback getQuotingStyle(opt::InputArgList &args) {
 157   if (auto *arg = args.getLastArg(OPT_rsp_quoting)) {
 158     StringRef s = arg->getValue();
 159     if (s != "windows" && s != "posix")
 160       error("invalid response file quoting: " + s);
 161     if (s == "windows")
 162       return cl::TokenizeWindowsCommandLine;
 163     return cl::TokenizeGNUCommandLine;
 164   }
 165   if (Triple(sys::getProcessTriple()).isOSWindows())
 166     return cl::TokenizeWindowsCommandLine;
 167   return cl::TokenizeGNUCommandLine;
 168 }
 169
 170 // Find a file by concatenating given paths.
 171 static Optional<std::string> findFile(StringRef path1, const Twine &path2) {
 172   SmallString<128> s;
 173   path::append(s, path1, path2);
 174   if (fs::exists(s))
 175     return std::string(s);
 176   return None;
 177 }
 178
 179 opt::InputArgList WasmOptTable::parse(ArrayRef<const char *> argv) {
 180   SmallVector<const char *, 256> vec(argv.data(), argv.data() + argv.size());
 181
 182   unsigned missingIndex;
 183   unsigned missingCount;
 184
 185   // We need to get the quoting style for response files before parsing all
 186   // options so we parse here before and ignore all the options but
 187   // --rsp-quoting.
 188   opt::InputArgList args = this->ParseArgs(vec, missingIndex, missingCount);
 189
 190   // Expand response files (arguments in the form of @<filename>)
 191   // and then parse the argument again.
 192   cl::ExpandResponseFiles(saver, getQuotingStyle(args), vec);
 193   args = this->ParseArgs(vec, missingIndex, missingCount);
 194
 195   handleColorDiagnostics(args);
 196   for (auto *arg : args.filtered(OPT_UNKNOWN))
 197     error("unknown argument: " + arg->getAsString(args));
 198   return args;
 199 }
 200
 201 // Currently we allow a ".imports" to live alongside a library. This can
 202 // be used to specify a list of symbols which can be undefined at link
 203 // time (imported from the environment.  For example libc.a include an
 204 // import file that lists the syscall functions it relies on at runtime.
 205 // In the long run this information would be better stored as a symbol
 206 // attribute/flag in the object file itself.
 207 // See: https://github.com/WebAssembly/tool-conventions/issues/35
 208 static void readImportFile(StringRef filename) {
 209   if (Optional<MemoryBufferRef> buf = readFile(filename))
 210     for (StringRef sym : args::getLines(*buf))
 211       config->allowUndefinedSymbols.insert(sym);
 212 }
 213
 214 // Returns slices of MB by parsing MB as an archive file.
 215 // Each slice consists of a member file in the archive.
 216 std::vector<MemoryBufferRef> static getArchiveMembers(MemoryBufferRef mb) {
 217   std::unique_ptr<Archive> file =
 218       CHECK(Archive::create(mb),
 219             mb.getBufferIdentifier() + ": failed to parse archive");
 220
 221   std::vector<MemoryBufferRef> v;
 222   Error err = Error::success();
 223   for (const Archive::Child &c : file->children(err)) {
 224     MemoryBufferRef mbref =
 225         CHECK(c.getMemoryBufferRef(),
 226               mb.getBufferIdentifier() +
 227                   ": could not get the buffer for a child of the archive");
 228     v.push_back(mbref);
 229   }
 230   if (err)
 231     fatal(mb.getBufferIdentifier() +
 232           ": Archive::children failed: " + toString(std::move(err)));
 233
 234   // Take ownership of memory buffers created for members of thin archives.
 235   for (std::unique_ptr<MemoryBuffer> &mb : file->takeThinBuffers())
 236     make<std::unique_ptr<MemoryBuffer>>(std::move(mb));
 237
 238   return v;
 239 }
 240
 241 void LinkerDriver::addFile(StringRef path) {
 242   Optional<MemoryBufferRef> buffer = readFile(path);
 243   if (!buffer.hasValue())
 244     return;
 245   MemoryBufferRef mbref = *buffer;
 246
 247   switch (identify_magic(mbref.getBuffer())) {
 248   case file_magic::archive: {
 249     SmallString<128> importFile = path;
 250     path::replace_extension(importFile, ".imports");
 251     if (fs::exists(importFile))
 252       readImportFile(importFile.str());
 253
 254     // Handle -whole-archive.
 255     if (inWholeArchive) {
 256       for (MemoryBufferRef &m : getArchiveMembers(mbref)) {
 257         auto *object = createObjectFile(m, path);
 258         // Mark object as live; object members are normally not
 259         // live by default but -whole-archive is designed to treat
 260         // them as such.
 261         object->markLive();
 262         files.push_back(object);
 263       }
 264
 265       return;
 266     }
 267
 268     std::unique_ptr<Archive> file =
 269         CHECK(Archive::create(mbref), path + ": failed to parse archive");
 270
 271     if (!file->isEmpty() && !file->hasSymbolTable()) {
 272       error(mbref.getBufferIdentifier() +
 273             ": archive has no index; run ranlib to add one");
 274     }
 275
 276     files.push_back(make<ArchiveFile>(mbref));
 277     return;
 278   }
 279   case file_magic::bitcode:
 280   case file_magic::wasm_object:
 281     files.push_back(createObjectFile(mbref));
 282     break;
 283   default:
 284     error("unknown file type: " + mbref.getBufferIdentifier());
 285   }
 286 }
 287
 288 // Add a given library by searching it from input search paths.
 289 void LinkerDriver::addLibrary(StringRef name) {
 290   for (StringRef dir : config->searchPaths) {
 291     if (Optional<std::string> s = findFile(dir, "lib" + name + ".a")) {
 292       addFile(*s);
 293       return;
 294     }
 295   }
 296
 297   error("unable to find library -l" + name);
 298 }
 299
 300 void LinkerDriver::createFiles(opt::InputArgList &args) {
 301   for (auto *arg : args) {
 302     switch (arg->getOption().getID()) {
 303     case OPT_l:
 304       addLibrary(arg->getValue());
 305       break;
 306     case OPT_INPUT:
 307       addFile(arg->getValue());
 308       break;
 309     case OPT_whole_archive:
 310       inWholeArchive = true;
 311       break;
 312     case OPT_no_whole_archive:
 313       inWholeArchive = false;
 314       break;
 315     }
 316   }
 317   if (files.empty() && errorCount() == 0)
 318     error("no input files");
 319 }
 320
 321 static StringRef getEntry(opt::InputArgList &args) {
 322   auto *arg = args.getLastArg(OPT_entry, OPT_no_entry);
 323   if (!arg) {
 324     if (args.hasArg(OPT_relocatable))
 325       return "";
 326     if (args.hasArg(OPT_shared))
 327       return "__wasm_call_ctors";
 328     return "_start";
 329   }
 330   if (arg->getOption().getID() == OPT_no_entry)
 331     return "";
 332   return arg->getValue();
 333 }
 334
 335 // Determines what we should do if there are remaining unresolved
 336 // symbols after the name resolution.
 337 static UnresolvedPolicy getUnresolvedSymbolPolicy(opt::InputArgList &args) {
 338   UnresolvedPolicy errorOrWarn = args.hasFlag(OPT_error_unresolved_symbols,
 339                                               OPT_warn_unresolved_symbols, true)
 340                                      ? UnresolvedPolicy::ReportError
 341                                      : UnresolvedPolicy::Warn;
 342
 343   if (auto *arg = args.getLastArg(OPT_unresolved_symbols)) {
 344     StringRef s = arg->getValue();
 345     if (s == "ignore-all")
 346       return UnresolvedPolicy::Ignore;
 347     if (s == "report-all")
 348       return errorOrWarn;
 349     error("unknown --unresolved-symbols value: " + s);
 350   }
 351
 352   return errorOrWarn;
 353 }
 354
 355 // Initializes Config members by the command line options.
 356 static void readConfigs(opt::InputArgList &args) {
 357   config->bsymbolic = args.hasArg(OPT_Bsymbolic);
 358   config->checkFeatures =
 359       args.hasFlag(OPT_check_features, OPT_no_check_features, true);
 360   config->compressRelocations = args.hasArg(OPT_compress_relocations);
 361   config->demangle = args.hasFlag(OPT_demangle, OPT_no_demangle, true);
 362   config->disableVerify = args.hasArg(OPT_disable_verify);
 363   config->emitRelocs = args.hasArg(OPT_emit_relocs);
 364   config->experimentalPic = args.hasArg(OPT_experimental_pic);
 365   config->entry = getEntry(args);
 366   config->exportAll = args.hasArg(OPT_export_all);
 367   config->exportTable = args.hasArg(OPT_export_table);
 368   config->growableTable = args.hasArg(OPT_growable_table);
 369   errorHandler().fatalWarnings =
 370       args.hasFlag(OPT_fatal_warnings, OPT_no_fatal_warnings, false);
 371   config->importMemory = args.hasArg(OPT_import_memory);
 372   config->sharedMemory = args.hasArg(OPT_shared_memory);
 373   config->importTable = args.hasArg(OPT_import_table);
 374   config->importUndefined = args.hasArg(OPT_import_undefined);
 375   config->ltoo = args::getInteger(args, OPT_lto_O, 2);
 376   config->ltoPartitions = args::getInteger(args, OPT_lto_partitions, 1);
 377   config->ltoNewPassManager =
 378       args.hasFlag(OPT_no_lto_legacy_pass_manager, OPT_lto_legacy_pass_manager,
 379                    LLVM_ENABLE_NEW_PASS_MANAGER);
 380   config->ltoDebugPassManager = args.hasArg(OPT_lto_debug_pass_manager);
 381   config->mapFile = args.getLastArgValue(OPT_Map);
 382   config->optimize = args::getInteger(args, OPT_O, 1);
 383   config->outputFile = args.getLastArgValue(OPT_o);
 384   config->relocatable = args.hasArg(OPT_relocatable);
 385   config->gcSections =
 386       args.hasFlag(OPT_gc_sections, OPT_no_gc_sections, !config->relocatable);
 387   config->mergeDataSegments =
 388       args.hasFlag(OPT_merge_data_segments, OPT_no_merge_data_segments,
 389                    !config->relocatable);
 390   config->pie = args.hasFlag(OPT_pie, OPT_no_pie, false);
 391   config->printGcSections =
 392       args.hasFlag(OPT_print_gc_sections, OPT_no_print_gc_sections, false);
 393   config->saveTemps = args.hasArg(OPT_save_temps);
 394   config->searchPaths = args::getStrings(args, OPT_L);
 395   config->shared = args.hasArg(OPT_shared);
 396   config->stripAll = args.hasArg(OPT_strip_all);
 397   config->stripDebug = args.hasArg(OPT_strip_debug);
 398   config->stackFirst = args.hasArg(OPT_stack_first);
 399   config->trace = args.hasArg(OPT_trace);
 400   config->thinLTOCacheDir = args.getLastArgValue(OPT_thinlto_cache_dir);
 401   config->thinLTOCachePolicy = CHECK(
 402       parseCachePruningPolicy(args.getLastArgValue(OPT_thinlto_cache_policy)),
 403       "--thinlto-cache-policy: invalid cache policy");
 404   config->unresolvedSymbols = getUnresolvedSymbolPolicy(args);
 405   errorHandler().verbose = args.hasArg(OPT_verbose);
 406   LLVM_DEBUG(errorHandler().verbose = true);
 407
 408   config->initialMemory = args::getInteger(args, OPT_initial_memory, 0);
 409   config->globalBase = args::getInteger(args, OPT_global_base, 1024);
 410   config->maxMemory = args::getInteger(args, OPT_max_memory, 0);
 411   config->zStackSize =
 412       args::getZOptionValue(args, OPT_z, "stack-size", WasmPageSize);
 413
 414   // Default value of exportDynamic depends on `-shared`
 415   config->exportDynamic =
 416       args.hasFlag(OPT_export_dynamic, OPT_no_export_dynamic, config->shared);
 417
 418   // Parse wasm32/64.
 419   if (auto *arg = args.getLastArg(OPT_m)) {
 420     StringRef s = arg->getValue();
 421     if (s == "wasm32")
 422       config->is64 = false;
 423     else if (s == "wasm64")
 424       config->is64 = true;
 425     else
 426       error("invalid target architecture: " + s);
 427   }
 428
 429   // --threads= takes a positive integer and provides the default value for
 430   // --thinlto-jobs=.
 431   if (auto *arg = args.getLastArg(OPT_threads)) {
 432     StringRef v(arg->getValue());
 433     unsigned threads = 0;
 434     if (!llvm::to_integer(v, threads, 0) || threads == 0)
 435       error(arg->getSpelling() + ": expected a positive integer, but got '" +
 436             arg->getValue() + "'");
 437     parallel::strategy = hardware_concurrency(threads);
 438     config->thinLTOJobs = v;
 439   }
 440   if (auto *arg = args.getLastArg(OPT_thinlto_jobs))
 441     config->thinLTOJobs = arg->getValue();
 442
 443   if (auto *arg = args.getLastArg(OPT_features)) {
 444     config->features =
 445         llvm::Optional<std::vector<std::string>>(std::vector<std::string>());
 446     for (StringRef s : arg->getValues())
 447       config->features->push_back(std::string(s));
 448   }
 449
 450   // Legacy --allow-undefined flag which is equivalent to
 451   // --unresolve-symbols=ignore + --import-undefined
 452   if (args.hasArg(OPT_allow_undefined)) {
 453     config->importUndefined = true;
 454     config->unresolvedSymbols = UnresolvedPolicy::Ignore;
 455   }
 456
 457   if (args.hasArg(OPT_print_map))
 458     config->mapFile = "-";
 459 }
 460
 461 // Some Config members do not directly correspond to any particular
 462 // command line options, but computed based on other Config values.
 463 // This function initialize such members. See Config.h for the details
 464 // of these values.
 465 static void setConfigs() {
 466   config->isPic = config->pie || config->shared;
 467
 468   if (config->isPic) {
 469     if (config->exportTable)
 470       error("-shared/-pie is incompatible with --export-table");
 471     config->importTable = true;
 472   }
 473
 474   if (config->relocatable) {
 475     if (config->exportTable)
 476       error("--relocatable is incompatible with --export-table");
 477     if (config->growableTable)
 478       error("--relocatable is incompatible with --growable-table");
 479     // Ignore any --import-table, as it's redundant.
 480     config->importTable = true;
 481   }
 482
 483   if (config->shared) {
 484     config->importMemory = true;
 485     config->importUndefined = true;
 486     config->unresolvedSymbols = UnresolvedPolicy::Ignore;
 487   }
 488 }
 489
 490 // Some command line options or some combinations of them are not allowed.
 491 // This function checks for such errors.
 492 static void checkOptions(opt::InputArgList &args) {
 493   if (!config->stripDebug && !config->stripAll && config->compressRelocations)
 494     error("--compress-relocations is incompatible with output debug"
 495           " information. Please pass --strip-debug or --strip-all");
 496
 497   if (config->ltoo > 3)
 498     error("invalid optimization level for LTO: " + Twine(config->ltoo));
 499   if (config->ltoPartitions == 0)
 500     error("--lto-partitions: number of threads must be > 0");
 501   if (!get_threadpool_strategy(config->thinLTOJobs))
 502     error("--thinlto-jobs: invalid job count: " + config->thinLTOJobs);
 503
 504   if (config->pie && config->shared)
 505     error("-shared and -pie may not be used together");
 506
 507   if (config->outputFile.empty())
 508     error("no output file specified");
 509
 510   if (config->importTable && config->exportTable)
 511     error("--import-table and --export-table may not be used together");
 512
 513   if (config->relocatable) {
 514     if (!config->entry.empty())
 515       error("entry point specified for relocatable output file");
 516     if (config->gcSections)
 517       error("-r and --gc-sections may not be used together");
 518     if (config->compressRelocations)
 519       error("-r -and --compress-relocations may not be used together");
 520     if (args.hasArg(OPT_undefined))
 521       error("-r -and --undefined may not be used together");
 522     if (config->pie)
 523       error("-r and -pie may not be used together");
 524     if (config->sharedMemory)
 525       error("-r and --shared-memory may not be used together");
 526   }
 527
 528   // To begin to prepare for Module Linking-style shared libraries, start
 529   // warning about uses of `-shared` and related flags outside of Experimental
 530   // mode, to give anyone using them a heads-up that they will be changing.
 531   //
 532   // Also, warn about flags which request explicit exports.
 533   if (!config->experimentalPic) {
 534     // -shared will change meaning when Module Linking is implemented.
 535     if (config->shared) {
 536       warn("creating shared libraries, with -shared, is not yet stable");
 537     }
 538
 539     // -pie will change meaning when Module Linking is implemented.
 540     if (config->pie) {
 541       warn("creating PIEs, with -pie, is not yet stable");
 542     }
 543   }
 544
 545   if (config->bsymbolic && !config->shared) {
 546     warn("-Bsymbolic is only meaningful when combined with -shared");
 547   }
 548 }
 549
 550 // Force Sym to be entered in the output. Used for -u or equivalent.
 551 static Symbol *handleUndefined(StringRef name) {
 552   Symbol *sym = symtab->find(name);
 553   if (!sym)
 554     return nullptr;
 555
 556   // Since symbol S may not be used inside the program, LTO may
 557   // eliminate it. Mark the symbol as "used" to prevent it.
 558   sym->isUsedInRegularObj = true;
 559
 560   if (auto *lazySym = dyn_cast<LazySymbol>(sym))
 561     lazySym->fetch();
 562
 563   return sym;
 564 }
 565
 566 static void handleLibcall(StringRef name) {
 567   Symbol *sym = symtab->find(name);
 568   if (!sym)
 569     return;
 570
 571   if (auto *lazySym = dyn_cast<LazySymbol>(sym)) {
 572     MemoryBufferRef mb = lazySym->getMemberBuffer();
 573     if (isBitcode(mb))
 574       lazySym->fetch();
 575   }
 576 }
 577
 578 static UndefinedGlobal *
 579 createUndefinedGlobal(StringRef name, llvm::wasm::WasmGlobalType *type) {
 580   auto *sym = cast<UndefinedGlobal>(symtab->addUndefinedGlobal(
 581       name, None, None, WASM_SYMBOL_UNDEFINED, nullptr, type));
 582   config->allowUndefinedSymbols.insert(sym->getName());
 583   sym->isUsedInRegularObj = true;
 584   return sym;
 585 }
 586
 587 static InputGlobal *createGlobal(StringRef name, bool isMutable) {
 588   llvm::wasm::WasmGlobal wasmGlobal;
 589   bool is64 = config->is64.getValueOr(false);
 590   wasmGlobal.Type = {uint8_t(is64 ? WASM_TYPE_I64 : WASM_TYPE_I32), isMutable};
 591   wasmGlobal.InitExpr = intConst(0, is64);
 592   wasmGlobal.SymbolName = name;
 593   return make<InputGlobal>(wasmGlobal, nullptr);
 594 }
 595
 596 static GlobalSymbol *createGlobalVariable(StringRef name, bool isMutable) {
 597   InputGlobal *g = createGlobal(name, isMutable);
 598   return symtab->addSyntheticGlobal(name, WASM_SYMBOL_VISIBILITY_HIDDEN, g);
 599 }
 600
 601 static GlobalSymbol *createOptionalGlobal(StringRef name, bool isMutable) {
 602   InputGlobal *g = createGlobal(name, isMutable);
 603   return symtab->addOptionalGlobalSymbol(name, g);
 604 }
 605
 606 // Create ABI-defined synthetic symbols
 607 static void createSyntheticSymbols() {
 608   if (config->relocatable)
 609     return;
 610
 611   static WasmSignature nullSignature = {{}, {}};
 612   static WasmSignature i32ArgSignature = {{}, {ValType::I32}};
 613   static WasmSignature i64ArgSignature = {{}, {ValType::I64}};
 614   static llvm::wasm::WasmGlobalType globalTypeI32 = {WASM_TYPE_I32, false};
 615   static llvm::wasm::WasmGlobalType globalTypeI64 = {WASM_TYPE_I64, false};
 616   static llvm::wasm::WasmGlobalType mutableGlobalTypeI32 = {WASM_TYPE_I32,
 617                                                             true};
 618   static llvm::wasm::WasmGlobalType mutableGlobalTypeI64 = {WASM_TYPE_I64,
 619                                                             true};
 620   WasmSym::callCtors = symtab->addSyntheticFunction(
 621       "__wasm_call_ctors", WASM_SYMBOL_VISIBILITY_HIDDEN,
 622       make<SyntheticFunction>(nullSignature, "__wasm_call_ctors"));
 623
 624     bool is64 = config->is64.getValueOr(false);
 625
 626   if (config->isPic) {
 627     WasmSym::stackPointer =
 628         createUndefinedGlobal("__stack_pointer", config->is64.getValueOr(false)
 629                                                      ? &mutableGlobalTypeI64
 630                                                      : &mutableGlobalTypeI32);
 631     // For PIC code, we import two global variables (__memory_base and
 632     // __table_base) from the environment and use these as the offset at
 633     // which to load our static data and function table.
 634     // See:
 635     // https://github.com/WebAssembly/tool-conventions/blob/master/DynamicLinking.md
 636     auto *globalType = is64 ? &globalTypeI64 : &globalTypeI32;
 637     WasmSym::memoryBase = createUndefinedGlobal("__memory_base", globalType);
 638     WasmSym::tableBase = createUndefinedGlobal("__table_base", globalType);
 639     WasmSym::memoryBase->markLive();
 640     WasmSym::tableBase->markLive();
 641     if (is64) {
 642       WasmSym::tableBase32 =
 643           createUndefinedGlobal("__table_base32", &globalTypeI32);
 644       WasmSym::tableBase32->markLive();
 645     } else {
 646       WasmSym::tableBase32 = nullptr;
 647     }
 648   } else {
 649     // For non-PIC code
 650     WasmSym::stackPointer = createGlobalVariable("__stack_pointer", true);
 651     WasmSym::stackPointer->markLive();
 652   }
 653
 654   if (config->sharedMemory && !config->relocatable) {
 655     WasmSym::tlsBase = createGlobalVariable("__tls_base", true);
 656     WasmSym::tlsSize = createGlobalVariable("__tls_size", false);
 657     WasmSym::tlsAlign = createGlobalVariable("__tls_align", false);
 658     WasmSym::initTLS = symtab->addSyntheticFunction(
 659         "__wasm_init_tls", WASM_SYMBOL_VISIBILITY_HIDDEN,
 660         make<SyntheticFunction>(
 661             is64 ? i64ArgSignature : i32ArgSignature,
 662             "__wasm_init_tls"));
 663   }
 664 }
 665
 666 static void createOptionalSymbols() {
 667   if (config->relocatable)
 668     return;
 669
 670   WasmSym::dsoHandle = symtab->addOptionalDataSymbol("__dso_handle");
 671
 672   if (!config->shared)
 673     WasmSym::dataEnd = symtab->addOptionalDataSymbol("__data_end");
 674
 675   if (!config->isPic) {
 676     WasmSym::globalBase = symtab->addOptionalDataSymbol("__global_base");
 677     WasmSym::heapBase = symtab->addOptionalDataSymbol("__heap_base");
 678     WasmSym::definedMemoryBase = symtab->addOptionalDataSymbol("__memory_base");
 679     WasmSym::definedTableBase = symtab->addOptionalDataSymbol("__table_base");
 680     if (config->is64.getValueOr(false))
 681       WasmSym::definedTableBase32 =
 682           symtab->addOptionalDataSymbol("__table_base32");
 683   }
 684
 685   // For non-shared memory programs we still need to define __tls_base since we
 686   // allow object files built with TLS to be linked into single threaded
 687   // programs, and such object files can contains refernced to this symbol.
 688   //
 689   // However, in this case __tls_base is immutable and points directly to the
 690   // start of the `.tdata` static segment.
 691   //
 692   // __tls_size and __tls_align are not needed in this case since they are only
 693   // needed for __wasm_init_tls (which we do not create in this case).
 694   if (!config->sharedMemory)
 695     WasmSym::tlsBase = createOptionalGlobal("__tls_base", false);
 696 }
 697
 698 // Reconstructs command line arguments so that so that you can re-run
 699 // the same command with the same inputs. This is for --reproduce.
 700 static std::string createResponseFile(const opt::InputArgList &args) {
 701   SmallString<0> data;
 702   raw_svector_ostream os(data);
 703
 704   // Copy the command line to the output while rewriting paths.
 705   for (auto *arg : args) {
 706     switch (arg->getOption().getID()) {
 707     case OPT_reproduce:
 708       break;
 709     case OPT_INPUT:
 710       os << quote(relativeToRoot(arg->getValue())) << "\n";
 711       break;
 712     case OPT_o:
 713       // If -o path contains directories, "lld @response.txt" will likely
 714       // fail because the archive we are creating doesn't contain empty
 715       // directories for the output path (-o doesn't create directories).
 716       // Strip directories to prevent the issue.
 717       os << "-o " << quote(sys::path::filename(arg->getValue())) << "\n";
 718       break;
 719     default:
 720       os << toString(*arg) << "\n";
 721     }
 722   }
 723   return std::string(data.str());
 724 }
 725
 726 // The --wrap option is a feature to rename symbols so that you can write
 727 // wrappers for existing functions. If you pass `-wrap=foo`, all
 728 // occurrences of symbol `foo` are resolved to `wrap_foo` (so, you are
 729 // expected to write `wrap_foo` function as a wrapper). The original
 730 // symbol becomes accessible as `real_foo`, so you can call that from your
 731 // wrapper.
 732 //
 733 // This data structure is instantiated for each -wrap option.
 734 struct WrappedSymbol {
 735   Symbol *sym;
 736   Symbol *real;
 737   Symbol *wrap;
 738 };
 739
 740 static Symbol *addUndefined(StringRef name) {
 741   return symtab->addUndefinedFunction(name, None, None, WASM_SYMBOL_UNDEFINED,
 742                                       nullptr, nullptr, false);
 743 }
 744
 745 // Handles -wrap option.
 746 //
 747 // This function instantiates wrapper symbols. At this point, they seem
 748 // like they are not being used at all, so we explicitly set some flags so
 749 // that LTO won't eliminate them.
 750 static std::vector<WrappedSymbol> addWrappedSymbols(opt::InputArgList &args) {
 751   std::vector<WrappedSymbol> v;
 752   DenseSet<StringRef> seen;
 753
 754   for (auto *arg : args.filtered(OPT_wrap)) {
 755     StringRef name = arg->getValue();
 756     if (!seen.insert(name).second)
 757       continue;
 758
 759     Symbol *sym = symtab->find(name);
 760     if (!sym)
 761       continue;
 762
 763     Symbol *real = addUndefined(saver.save("__real_" + name));
 764     Symbol *wrap = addUndefined(saver.save("__wrap_" + name));
 765     v.push_back({sym, real, wrap});
 766
 767     // We want to tell LTO not to inline symbols to be overwritten
 768     // because LTO doesn't know the final symbol contents after renaming.
 769     real->canInline = false;
 770     sym->canInline = false;
 771
 772     // Tell LTO not to eliminate these symbols.
 773     sym->isUsedInRegularObj = true;
 774     wrap->isUsedInRegularObj = true;
 775     real->isUsedInRegularObj = false;
 776   }
 777   return v;
 778 }
 779
 780 // Do renaming for -wrap by updating pointers to symbols.
 781 //
 782 // When this function is executed, only InputFiles and symbol table
 783 // contain pointers to symbol objects. We visit them to replace pointers,
 784 // so that wrapped symbols are swapped as instructed by the command line.
 785 static void wrapSymbols(ArrayRef<WrappedSymbol> wrapped) {
 786   DenseMap<Symbol *, Symbol *> map;
 787   for (const WrappedSymbol &w : wrapped) {
 788     map[w.sym] = w.wrap;
 789     map[w.real] = w.sym;
 790   }
 791
 792   // Update pointers in input files.
 793   parallelForEach(symtab->objectFiles, [&](InputFile *file) {
 794     MutableArrayRef<Symbol *> syms = file->getMutableSymbols();
 795     for (size_t i = 0, e = syms.size(); i != e; ++i)
 796       if (Symbol *s = map.lookup(syms[i]))
 797         syms[i] = s;
 798   });
 799
 800   // Update pointers in the symbol table.
 801   for (const WrappedSymbol &w : wrapped)
 802     symtab->wrap(w.sym, w.real, w.wrap);
 803 }
 804
 805 static void splitSections() {
 806   // splitIntoPieces needs to be called on each MergeInputChunk
 807   // before calling finalizeContents().
 808   LLVM_DEBUG(llvm::dbgs() << "splitSections\n");
 809   parallelForEach(symtab->objectFiles, [](ObjFile *file) {
 810     for (InputChunk *seg : file->segments) {
 811       if (auto *s = dyn_cast<MergeInputChunk>(seg))
 812         s->splitIntoPieces();
 813     }
 814     for (InputChunk *sec : file->customSections) {
 815       if (auto *s = dyn_cast<MergeInputChunk>(sec))
 816         s->splitIntoPieces();
 817     }
 818   });
 819 }
 820
 821 void LinkerDriver::linkerMain(ArrayRef<const char *> argsArr) {
 822   WasmOptTable parser;
 823   opt::InputArgList args = parser.parse(argsArr.slice(1));
 824
 825   // Handle --help
 826   if (args.hasArg(OPT_help)) {
 827     parser.printHelp(lld::outs(),
 828                      (std::string(argsArr[0]) + " [options] file...").c_str(),
 829                      "LLVM Linker", false);
 830     return;
 831   }
 832
 833   // Handle --version
 834   if (args.hasArg(OPT_version) || args.hasArg(OPT_v)) {
 835     lld::outs() << getLLDVersion() << "\n";
 836     return;
 837   }
 838
 839   // Handle --reproduce
 840   if (auto *arg = args.getLastArg(OPT_reproduce)) {
 841     StringRef path = arg->getValue();
 842     Expected<std::unique_ptr<TarWriter>> errOrWriter =
 843         TarWriter::create(path, path::stem(path));
 844     if (errOrWriter) {
 845       tar = std::move(*errOrWriter);
 846       tar->append("response.txt", createResponseFile(args));
 847       tar->append("version.txt", getLLDVersion() + "\n");
 848     } else {
 849       error("--reproduce: " + toString(errOrWriter.takeError()));
 850     }
 851   }
 852
 853   // Parse and evaluate -mllvm options.
 854   std::vector<const char *> v;
 855   v.push_back("wasm-ld (LLVM option parsing)");
 856   for (auto *arg : args.filtered(OPT_mllvm))
 857     v.push_back(arg->getValue());
 858   cl::ResetAllOptionOccurrences();
 859   cl::ParseCommandLineOptions(v.size(), v.data());
 860
 861   errorHandler().errorLimit = args::getInteger(args, OPT_error_limit, 20);
 862
 863   readConfigs(args);
 864
 865   createFiles(args);
 866   if (errorCount())
 867     return;
 868
 869   setConfigs();
 870   checkOptions(args);
 871   if (errorCount())
 872     return;
 873
 874   if (auto *arg = args.getLastArg(OPT_allow_undefined_file))
 875     readImportFile(arg->getValue());
 876
 877   // Fail early if the output file or map file is not writable. If a user has a
 878   // long link, e.g. due to a large LTO link, they do not wish to run it and
 879   // find that it failed because there was a mistake in their command-line.
 880   if (auto e = tryCreateFile(config->outputFile))
 881     error("cannot open output file " + config->outputFile + ": " + e.message());
 882   if (auto e = tryCreateFile(config->mapFile))
 883     error("cannot open map file " + config->mapFile + ": " + e.message());
 884   if (errorCount())
 885     return;
 886
 887   // Handle --trace-symbol.
 888   for (auto *arg : args.filtered(OPT_trace_symbol))
 889     symtab->trace(arg->getValue());
 890
 891   for (auto *arg : args.filtered(OPT_export_if_defined))
 892     config->exportedSymbols.insert(arg->getValue());
 893
 894   for (auto *arg : args.filtered(OPT_export)) {
 895     config->exportedSymbols.insert(arg->getValue());
 896     config->requiredExports.push_back(arg->getValue());
 897   }
 898
 899   createSyntheticSymbols();
 900
 901   // Add all files to the symbol table. This will add almost all
 902   // symbols that we need to the symbol table.
 903   for (InputFile *f : files)
 904     symtab->addFile(f);
 905   if (errorCount())
 906     return;
 907
 908   // Handle the `--undefined <sym>` options.
 909   for (auto *arg : args.filtered(OPT_undefined))
 910     handleUndefined(arg->getValue());
 911
 912   // Handle the `--export <sym>` options
 913   // This works like --undefined but also exports the symbol if its found
 914   for (auto &iter : config->exportedSymbols)
 915     handleUndefined(iter.first());
 916
 917   Symbol *entrySym = nullptr;
 918   if (!config->relocatable && !config->entry.empty()) {
 919     entrySym = handleUndefined(config->entry);
 920     if (entrySym && entrySym->isDefined())
 921       entrySym->forceExport = true;
 922     else
 923       error("entry symbol not defined (pass --no-entry to suppress): " +
 924             config->entry);
 925   }
 926
 927   // If the user code defines a `__wasm_call_dtors` function, remember it so
 928   // that we can call it from the command export wrappers. Unlike
 929   // `__wasm_call_ctors` which we synthesize, `__wasm_call_dtors` is defined
 930   // by libc/etc., because destructors are registered dynamically with
 931   // `__cxa_atexit` and friends.
 932   if (!config->relocatable && !config->shared &&
 933       !WasmSym::callCtors->isUsedInRegularObj &&
 934       WasmSym::callCtors->getName() != config->entry &&
 935       !config->exportedSymbols.count(WasmSym::callCtors->getName())) {
 936     if (Symbol *callDtors = handleUndefined("__wasm_call_dtors")) {
 937       if (auto *callDtorsFunc = dyn_cast<DefinedFunction>(callDtors)) {
 938         if (callDtorsFunc->signature &&
 939             (!callDtorsFunc->signature->Params.empty() ||
 940              !callDtorsFunc->signature->Returns.empty())) {
 941           error("__wasm_call_dtors must have no argument or return values");
 942         }
 943         WasmSym::callDtors = callDtorsFunc;
 944       } else {
 945         error("__wasm_call_dtors must be a function");
 946       }
 947     }
 948   }
 949
 950   createOptionalSymbols();
 951
 952   if (errorCount())
 953     return;
 954
 955   // Create wrapped symbols for -wrap option.
 956   std::vector<WrappedSymbol> wrapped = addWrappedSymbols(args);
 957
 958   // If any of our inputs are bitcode files, the LTO code generator may create
 959   // references to certain library functions that might not be explicit in the
 960   // bitcode file's symbol table. If any of those library functions are defined
 961   // in a bitcode file in an archive member, we need to arrange to use LTO to
 962   // compile those archive members by adding them to the link beforehand.
 963   //
 964   // We only need to add libcall symbols to the link before LTO if the symbol's
 965   // definition is in bitcode. Any other required libcall symbols will be added
 966   // to the link after LTO when we add the LTO object file to the link.
 967   if (!symtab->bitcodeFiles.empty())
 968     for (auto *s : lto::LTO::getRuntimeLibcallSymbols())
 969       handleLibcall(s);
 970   if (errorCount())
 971     return;
 972
 973   // Do link-time optimization if given files are LLVM bitcode files.
 974   // This compiles bitcode files into real object files.
 975   symtab->addCombinedLTOObject();
 976   if (errorCount())
 977     return;
 978
 979   // Resolve any variant symbols that were created due to signature
 980   // mismatchs.
 981   symtab->handleSymbolVariants();
 982   if (errorCount())
 983     return;
 984
 985   // Apply symbol renames for -wrap.
 986   if (!wrapped.empty())
 987     wrapSymbols(wrapped);
 988
 989   for (auto &iter : config->exportedSymbols) {
 990     Symbol *sym = symtab->find(iter.first());
 991     if (sym && sym->isDefined())
 992       sym->forceExport = true;
 993   }
 994
 995   if (!config->relocatable && !config->isPic) {
 996     // Add synthetic dummies for weak undefined functions.  Must happen
 997     // after LTO otherwise functions may not yet have signatures.
 998     symtab->handleWeakUndefines();
 999   }
1000
1001   if (entrySym)
1002     entrySym->setHidden(false);
1003
1004   if (errorCount())
1005     return;
1006
1007   // Split WASM_SEG_FLAG_STRINGS sections into pieces in preparation for garbage
1008   // collection.
1009   splitSections();
1010
1011   // Do size optimizations: garbage collection
1012   markLive();
1013
1014   // Provide the indirect function table if needed.
1015   WasmSym::indirectFunctionTable =
1016       symtab->resolveIndirectFunctionTable(/*required =*/false);
1017
1018   if (errorCount())
1019     return;
1020
1021   // Write the result to the file.
1022   writeResult();
1023 }
1024
1025 } // namespace wasm
1026 } // namespace lld