contrib/llvm-project/lld/COFF/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 "Driver.h"
  10 #include "Config.h"
  11 #include "DebugTypes.h"
  12 #include "ICF.h"
  13 #include "InputFiles.h"
  14 #include "MarkLive.h"
  15 #include "MinGW.h"
  16 #include "SymbolTable.h"
  17 #include "Symbols.h"
  18 #include "Writer.h"
  19 #include "lld/Common/Args.h"
  20 #include "lld/Common/Driver.h"
  21 #include "lld/Common/ErrorHandler.h"
  22 #include "lld/Common/Filesystem.h"
  23 #include "lld/Common/Memory.h"
  24 #include "lld/Common/Threads.h"
  25 #include "lld/Common/Timer.h"
  26 #include "lld/Common/Version.h"
  27 #include "llvm/ADT/Optional.h"
  28 #include "llvm/ADT/StringSwitch.h"
  29 #include "llvm/BinaryFormat/Magic.h"
  30 #include "llvm/LTO/LTO.h"
  31 #include "llvm/Object/ArchiveWriter.h"
  32 #include "llvm/Object/COFFImportFile.h"
  33 #include "llvm/Object/COFFModuleDefinition.h"
  34 #include "llvm/Object/WindowsMachineFlag.h"
  35 #include "llvm/Option/Arg.h"
  36 #include "llvm/Option/ArgList.h"
  37 #include "llvm/Option/Option.h"
  38 #include "llvm/Support/CommandLine.h"
  39 #include "llvm/Support/Debug.h"
  40 #include "llvm/Support/LEB128.h"
  41 #include "llvm/Support/MathExtras.h"
  42 #include "llvm/Support/Path.h"
  43 #include "llvm/Support/Process.h"
  44 #include "llvm/Support/TarWriter.h"
  45 #include "llvm/Support/TargetSelect.h"
  46 #include "llvm/Support/raw_ostream.h"
  47 #include "llvm/ToolDrivers/llvm-lib/LibDriver.h"
  48 #include <algorithm>
  49 #include <future>
  50 #include <memory>
  51
  52 using namespace llvm;
  53 using namespace llvm::object;
  54 using namespace llvm::COFF;
  55 using llvm::sys::Process;
  56
  57 namespace lld {
  58 namespace coff {
  59
  60 static Timer inputFileTimer("Input File Reading", Timer::root());
  61
  62 Configuration *config;
  63 LinkerDriver *driver;
  64
  65 bool link(ArrayRef<const char *> args, bool canExitEarly, raw_ostream &stdoutOS,
  66           raw_ostream &stderrOS) {
  67   lld::stdoutOS = &stdoutOS;
  68   lld::stderrOS = &stderrOS;
  69
  70   errorHandler().logName = args::getFilenameWithoutExe(args[0]);
  71   errorHandler().errorLimitExceededMsg =
  72       "too many errors emitted, stopping now"
  73       " (use /errorlimit:0 to see all errors)";
  74   errorHandler().exitEarly = canExitEarly;
  75   stderrOS.enable_colors(stderrOS.has_colors());
  76
  77   config = make<Configuration>();
  78   symtab = make<SymbolTable>();
  79   driver = make<LinkerDriver>();
  80
  81   driver->link(args);
  82
  83   // Call exit() if we can to avoid calling destructors.
  84   if (canExitEarly)
  85     exitLld(errorCount() ? 1 : 0);
  86
  87   freeArena();
  88   ObjFile::instances.clear();
  89   ImportFile::instances.clear();
  90   BitcodeFile::instances.clear();
  91   memset(MergeChunk::instances, 0, sizeof(MergeChunk::instances));
  92   return !errorCount();
  93 }
  94
  95 // Parse options of the form "old;new".
  96 static std::pair<StringRef, StringRef> getOldNewOptions(opt::InputArgList &args,
  97                                                         unsigned id) {
  98   auto *arg = args.getLastArg(id);
  99   if (!arg)
 100     return {"", ""};
 101
 102   StringRef s = arg->getValue();
 103   std::pair<StringRef, StringRef> ret = s.split(';');
 104   if (ret.second.empty())
 105     error(arg->getSpelling() + " expects 'old;new' format, but got " + s);
 106   return ret;
 107 }
 108
 109 // Drop directory components and replace extension with
 110 // ".exe", ".dll" or ".sys".
 111 static std::string getOutputPath(StringRef path) {
 112   StringRef ext = ".exe";
 113   if (config->dll)
 114     ext = ".dll";
 115   else if (config->driver)
 116     ext = ".sys";
 117
 118   return (sys::path::stem(path) + ext).str();
 119 }
 120
 121 // Returns true if S matches /crtend.?\.o$/.
 122 static bool isCrtend(StringRef s) {
 123   if (!s.endswith(".o"))
 124     return false;
 125   s = s.drop_back(2);
 126   if (s.endswith("crtend"))
 127     return true;
 128   return !s.empty() && s.drop_back().endswith("crtend");
 129 }
 130
 131 // ErrorOr is not default constructible, so it cannot be used as the type
 132 // parameter of a future.
 133 // FIXME: We could open the file in createFutureForFile and avoid needing to
 134 // return an error here, but for the moment that would cost us a file descriptor
 135 // (a limited resource on Windows) for the duration that the future is pending.
 136 using MBErrPair = std::pair<std::unique_ptr<MemoryBuffer>, std::error_code>;
 137
 138 // Create a std::future that opens and maps a file using the best strategy for
 139 // the host platform.
 140 static std::future<MBErrPair> createFutureForFile(std::string path) {
 141 #if _WIN32
 142   // On Windows, file I/O is relatively slow so it is best to do this
 143   // asynchronously.
 144   auto strategy = std::launch::async;
 145 #else
 146   auto strategy = std::launch::deferred;
 147 #endif
 148   return std::async(strategy, [=]() {
 149     auto mbOrErr = MemoryBuffer::getFile(path,
 150                                          /*FileSize*/ -1,
 151                                          /*RequiresNullTerminator*/ false);
 152     if (!mbOrErr)
 153       return MBErrPair{nullptr, mbOrErr.getError()};
 154     return MBErrPair{std::move(*mbOrErr), std::error_code()};
 155   });
 156 }
 157
 158 // Symbol names are mangled by prepending "_" on x86.
 159 static StringRef mangle(StringRef sym) {
 160   assert(config->machine != IMAGE_FILE_MACHINE_UNKNOWN);
 161   if (config->machine == I386)
 162     return saver.save("_" + sym);
 163   return sym;
 164 }
 165
 166 static bool findUnderscoreMangle(StringRef sym) {
 167   Symbol *s = symtab->findMangle(mangle(sym));
 168   return s && !isa<Undefined>(s);
 169 }
 170
 171 MemoryBufferRef LinkerDriver::takeBuffer(std::unique_ptr<MemoryBuffer> mb) {
 172   MemoryBufferRef mbref = *mb;
 173   make<std::unique_ptr<MemoryBuffer>>(std::move(mb)); // take ownership
 174
 175   if (driver->tar)
 176     driver->tar->append(relativeToRoot(mbref.getBufferIdentifier()),
 177                         mbref.getBuffer());
 178   return mbref;
 179 }
 180
 181 void LinkerDriver::addBuffer(std::unique_ptr<MemoryBuffer> mb,
 182                              bool wholeArchive, bool lazy) {
 183   StringRef filename = mb->getBufferIdentifier();
 184
 185   MemoryBufferRef mbref = takeBuffer(std::move(mb));
 186   filePaths.push_back(filename);
 187
 188   // File type is detected by contents, not by file extension.
 189   switch (identify_magic(mbref.getBuffer())) {
 190   case file_magic::windows_resource:
 191     resources.push_back(mbref);
 192     break;
 193   case file_magic::archive:
 194     if (wholeArchive) {
 195       std::unique_ptr<Archive> file =
 196           CHECK(Archive::create(mbref), filename + ": failed to parse archive");
 197       Archive *archive = file.get();
 198       make<std::unique_ptr<Archive>>(std::move(file)); // take ownership
 199
 200       int memberIndex = 0;
 201       for (MemoryBufferRef m : getArchiveMembers(archive))
 202         addArchiveBuffer(m, "<whole-archive>", filename, memberIndex++);
 203       return;
 204     }
 205     symtab->addFile(make<ArchiveFile>(mbref));
 206     break;
 207   case file_magic::bitcode:
 208     if (lazy)
 209       symtab->addFile(make<LazyObjFile>(mbref));
 210     else
 211       symtab->addFile(make<BitcodeFile>(mbref, "", 0));
 212     break;
 213   case file_magic::coff_object:
 214   case file_magic::coff_import_library:
 215     if (lazy)
 216       symtab->addFile(make<LazyObjFile>(mbref));
 217     else
 218       symtab->addFile(make<ObjFile>(mbref));
 219     break;
 220   case file_magic::pdb:
 221     loadTypeServerSource(mbref);
 222     break;
 223   case file_magic::coff_cl_gl_object:
 224     error(filename + ": is not a native COFF file. Recompile without /GL");
 225     break;
 226   case file_magic::pecoff_executable:
 227     if (filename.endswith_lower(".dll")) {
 228       error(filename + ": bad file type. Did you specify a DLL instead of an "
 229                        "import library?");
 230       break;
 231     }
 232     LLVM_FALLTHROUGH;
 233   default:
 234     error(mbref.getBufferIdentifier() + ": unknown file type");
 235     break;
 236   }
 237 }
 238
 239 void LinkerDriver::enqueuePath(StringRef path, bool wholeArchive, bool lazy) {
 240   auto future =
 241       std::make_shared<std::future<MBErrPair>>(createFutureForFile(path));
 242   std::string pathStr = path;
 243   enqueueTask([=]() {
 244     auto mbOrErr = future->get();
 245     if (mbOrErr.second) {
 246       std::string msg =
 247           "could not open '" + pathStr + "': " + mbOrErr.second.message();
 248       // Check if the filename is a typo for an option flag. OptTable thinks
 249       // that all args that are not known options and that start with / are
 250       // filenames, but e.g. `/nodefaultlibs` is more likely a typo for
 251       // the option `/nodefaultlib` than a reference to a file in the root
 252       // directory.
 253       std::string nearest;
 254       if (COFFOptTable().findNearest(pathStr, nearest) > 1)
 255         error(msg);
 256       else
 257         error(msg + "; did you mean '" + nearest + "'");
 258     } else
 259       driver->addBuffer(std::move(mbOrErr.first), wholeArchive, lazy);
 260   });
 261 }
 262
 263 void LinkerDriver::addArchiveBuffer(MemoryBufferRef mb, StringRef symName,
 264                                     StringRef parentName,
 265                                     uint64_t offsetInArchive) {
 266   file_magic magic = identify_magic(mb.getBuffer());
 267   if (magic == file_magic::coff_import_library) {
 268     InputFile *imp = make<ImportFile>(mb);
 269     imp->parentName = parentName;
 270     symtab->addFile(imp);
 271     return;
 272   }
 273
 274   InputFile *obj;
 275   if (magic == file_magic::coff_object) {
 276     obj = make<ObjFile>(mb);
 277   } else if (magic == file_magic::bitcode) {
 278     obj = make<BitcodeFile>(mb, parentName, offsetInArchive);
 279   } else {
 280     error("unknown file type: " + mb.getBufferIdentifier());
 281     return;
 282   }
 283
 284   obj->parentName = parentName;
 285   symtab->addFile(obj);
 286   log("Loaded " + toString(obj) + " for " + symName);
 287 }
 288
 289 void LinkerDriver::enqueueArchiveMember(const Archive::Child &c,
 290                                         const Archive::Symbol &sym,
 291                                         StringRef parentName) {
 292
 293   auto reportBufferError = [=](Error &&e, StringRef childName) {
 294     fatal("could not get the buffer for the member defining symbol " +
 295           toCOFFString(sym) + ": " + parentName + "(" + childName + "): " +
 296           toString(std::move(e)));
 297   };
 298
 299   if (!c.getParent()->isThin()) {
 300     uint64_t offsetInArchive = c.getChildOffset();
 301     Expected<MemoryBufferRef> mbOrErr = c.getMemoryBufferRef();
 302     if (!mbOrErr)
 303       reportBufferError(mbOrErr.takeError(), check(c.getFullName()));
 304     MemoryBufferRef mb = mbOrErr.get();
 305     enqueueTask([=]() {
 306       driver->addArchiveBuffer(mb, toCOFFString(sym), parentName,
 307                                offsetInArchive);
 308     });
 309     return;
 310   }
 311
 312   std::string childName = CHECK(
 313       c.getFullName(),
 314       "could not get the filename for the member defining symbol " +
 315       toCOFFString(sym));
 316   auto future = std::make_shared<std::future<MBErrPair>>(
 317       createFutureForFile(childName));
 318   enqueueTask([=]() {
 319     auto mbOrErr = future->get();
 320     if (mbOrErr.second)
 321       reportBufferError(errorCodeToError(mbOrErr.second), childName);
 322     // Pass empty string as archive name so that the original filename is
 323     // used as the buffer identifier.
 324     driver->addArchiveBuffer(takeBuffer(std::move(mbOrErr.first)),
 325                              toCOFFString(sym), "", /*OffsetInArchive=*/0);
 326   });
 327 }
 328
 329 static bool isDecorated(StringRef sym) {
 330   return sym.startswith("@") || sym.contains("@@") || sym.startswith("?") ||
 331          (!config->mingw && sym.contains('@'));
 332 }
 333
 334 // Parses .drectve section contents and returns a list of files
 335 // specified by /defaultlib.
 336 void LinkerDriver::parseDirectives(InputFile *file) {
 337   StringRef s = file->getDirectives();
 338   if (s.empty())
 339     return;
 340
 341   log("Directives: " + toString(file) + ": " + s);
 342
 343   ArgParser parser;
 344   // .drectve is always tokenized using Windows shell rules.
 345   // /EXPORT: option can appear too many times, processing in fastpath.
 346   opt::InputArgList args;
 347   std::vector<StringRef> exports;
 348   std::tie(args, exports) = parser.parseDirectives(s);
 349
 350   for (StringRef e : exports) {
 351     // If a common header file contains dllexported function
 352     // declarations, many object files may end up with having the
 353     // same /EXPORT options. In order to save cost of parsing them,
 354     // we dedup them first.
 355     if (!directivesExports.insert(e).second)
 356       continue;
 357
 358     Export exp = parseExport(e);
 359     if (config->machine == I386 && config->mingw) {
 360       if (!isDecorated(exp.name))
 361         exp.name = saver.save("_" + exp.name);
 362       if (!exp.extName.empty() && !isDecorated(exp.extName))
 363         exp.extName = saver.save("_" + exp.extName);
 364     }
 365     exp.directives = true;
 366     config->exports.push_back(exp);
 367   }
 368
 369   for (auto *arg : args) {
 370     switch (arg->getOption().getID()) {
 371     case OPT_aligncomm:
 372       parseAligncomm(arg->getValue());
 373       break;
 374     case OPT_alternatename:
 375       parseAlternateName(arg->getValue());
 376       break;
 377     case OPT_defaultlib:
 378       if (Optional<StringRef> path = findLib(arg->getValue()))
 379         enqueuePath(*path, false, false);
 380       break;
 381     case OPT_entry:
 382       config->entry = addUndefined(mangle(arg->getValue()));
 383       break;
 384     case OPT_failifmismatch:
 385       checkFailIfMismatch(arg->getValue(), file);
 386       break;
 387     case OPT_incl:
 388       addUndefined(arg->getValue());
 389       break;
 390     case OPT_merge:
 391       parseMerge(arg->getValue());
 392       break;
 393     case OPT_nodefaultlib:
 394       config->noDefaultLibs.insert(doFindLib(arg->getValue()).lower());
 395       break;
 396     case OPT_section:
 397       parseSection(arg->getValue());
 398       break;
 399     case OPT_subsystem:
 400       parseSubsystem(arg->getValue(), &config->subsystem,
 401                      &config->majorOSVersion, &config->minorOSVersion);
 402       break;
 403     // Only add flags here that link.exe accepts in
 404     // `#pragma comment(linker, "/flag")`-generated sections.
 405     case OPT_editandcontinue:
 406     case OPT_guardsym:
 407     case OPT_throwingnew:
 408       break;
 409     default:
 410       error(arg->getSpelling() + " is not allowed in .drectve");
 411     }
 412   }
 413 }
 414
 415 // Find file from search paths. You can omit ".obj", this function takes
 416 // care of that. Note that the returned path is not guaranteed to exist.
 417 StringRef LinkerDriver::doFindFile(StringRef filename) {
 418   bool hasPathSep = (filename.find_first_of("/\\") != StringRef::npos);
 419   if (hasPathSep)
 420     return filename;
 421   bool hasExt = filename.contains('.');
 422   for (StringRef dir : searchPaths) {
 423     SmallString<128> path = dir;
 424     sys::path::append(path, filename);
 425     if (sys::fs::exists(path.str()))
 426       return saver.save(path.str());
 427     if (!hasExt) {
 428       path.append(".obj");
 429       if (sys::fs::exists(path.str()))
 430         return saver.save(path.str());
 431     }
 432   }
 433   return filename;
 434 }
 435
 436 static Optional<sys::fs::UniqueID> getUniqueID(StringRef path) {
 437   sys::fs::UniqueID ret;
 438   if (sys::fs::getUniqueID(path, ret))
 439     return None;
 440   return ret;
 441 }
 442
 443 // Resolves a file path. This never returns the same path
 444 // (in that case, it returns None).
 445 Optional<StringRef> LinkerDriver::findFile(StringRef filename) {
 446   StringRef path = doFindFile(filename);
 447
 448   if (Optional<sys::fs::UniqueID> id = getUniqueID(path)) {
 449     bool seen = !visitedFiles.insert(*id).second;
 450     if (seen)
 451       return None;
 452   }
 453
 454   if (path.endswith_lower(".lib"))
 455     visitedLibs.insert(sys::path::filename(path));
 456   return path;
 457 }
 458
 459 // MinGW specific. If an embedded directive specified to link to
 460 // foo.lib, but it isn't found, try libfoo.a instead.
 461 StringRef LinkerDriver::doFindLibMinGW(StringRef filename) {
 462   if (filename.contains('/') || filename.contains('\\'))
 463     return filename;
 464
 465   SmallString<128> s = filename;
 466   sys::path::replace_extension(s, ".a");
 467   StringRef libName = saver.save("lib" + s.str());
 468   return doFindFile(libName);
 469 }
 470
 471 // Find library file from search path.
 472 StringRef LinkerDriver::doFindLib(StringRef filename) {
 473   // Add ".lib" to Filename if that has no file extension.
 474   bool hasExt = filename.contains('.');
 475   if (!hasExt)
 476     filename = saver.save(filename + ".lib");
 477   StringRef ret = doFindFile(filename);
 478   // For MinGW, if the find above didn't turn up anything, try
 479   // looking for a MinGW formatted library name.
 480   if (config->mingw && ret == filename)
 481     return doFindLibMinGW(filename);
 482   return ret;
 483 }
 484
 485 // Resolves a library path. /nodefaultlib options are taken into
 486 // consideration. This never returns the same path (in that case,
 487 // it returns None).
 488 Optional<StringRef> LinkerDriver::findLib(StringRef filename) {
 489   if (config->noDefaultLibAll)
 490     return None;
 491   if (!visitedLibs.insert(filename.lower()).second)
 492     return None;
 493
 494   StringRef path = doFindLib(filename);
 495   if (config->noDefaultLibs.count(path.lower()))
 496     return None;
 497
 498   if (Optional<sys::fs::UniqueID> id = getUniqueID(path))
 499     if (!visitedFiles.insert(*id).second)
 500       return None;
 501   return path;
 502 }
 503
 504 // Parses LIB environment which contains a list of search paths.
 505 void LinkerDriver::addLibSearchPaths() {
 506   Optional<std::string> envOpt = Process::GetEnv("LIB");
 507   if (!envOpt.hasValue())
 508     return;
 509   StringRef env = saver.save(*envOpt);
 510   while (!env.empty()) {
 511     StringRef path;
 512     std::tie(path, env) = env.split(';');
 513     searchPaths.push_back(path);
 514   }
 515 }
 516
 517 Symbol *LinkerDriver::addUndefined(StringRef name) {
 518   Symbol *b = symtab->addUndefined(name);
 519   if (!b->isGCRoot) {
 520     b->isGCRoot = true;
 521     config->gcroot.push_back(b);
 522   }
 523   return b;
 524 }
 525
 526 StringRef LinkerDriver::mangleMaybe(Symbol *s) {
 527   // If the plain symbol name has already been resolved, do nothing.
 528   Undefined *unmangled = dyn_cast<Undefined>(s);
 529   if (!unmangled)
 530     return "";
 531
 532   // Otherwise, see if a similar, mangled symbol exists in the symbol table.
 533   Symbol *mangled = symtab->findMangle(unmangled->getName());
 534   if (!mangled)
 535     return "";
 536
 537   // If we find a similar mangled symbol, make this an alias to it and return
 538   // its name.
 539   log(unmangled->getName() + " aliased to " + mangled->getName());
 540   unmangled->weakAlias = symtab->addUndefined(mangled->getName());
 541   return mangled->getName();
 542 }
 543
 544 // Windows specific -- find default entry point name.
 545 //
 546 // There are four different entry point functions for Windows executables,
 547 // each of which corresponds to a user-defined "main" function. This function
 548 // infers an entry point from a user-defined "main" function.
 549 StringRef LinkerDriver::findDefaultEntry() {
 550   assert(config->subsystem != IMAGE_SUBSYSTEM_UNKNOWN &&
 551          "must handle /subsystem before calling this");
 552
 553   if (config->mingw)
 554     return mangle(config->subsystem == IMAGE_SUBSYSTEM_WINDOWS_GUI
 555                       ? "WinMainCRTStartup"
 556                       : "mainCRTStartup");
 557
 558   if (config->subsystem == IMAGE_SUBSYSTEM_WINDOWS_GUI) {
 559     if (findUnderscoreMangle("wWinMain")) {
 560       if (!findUnderscoreMangle("WinMain"))
 561         return mangle("wWinMainCRTStartup");
 562       warn("found both wWinMain and WinMain; using latter");
 563     }
 564     return mangle("WinMainCRTStartup");
 565   }
 566   if (findUnderscoreMangle("wmain")) {
 567     if (!findUnderscoreMangle("main"))
 568       return mangle("wmainCRTStartup");
 569     warn("found both wmain and main; using latter");
 570   }
 571   return mangle("mainCRTStartup");
 572 }
 573
 574 WindowsSubsystem LinkerDriver::inferSubsystem() {
 575   if (config->dll)
 576     return IMAGE_SUBSYSTEM_WINDOWS_GUI;
 577   if (config->mingw)
 578     return IMAGE_SUBSYSTEM_WINDOWS_CUI;
 579   // Note that link.exe infers the subsystem from the presence of these
 580   // functions even if /entry: or /nodefaultlib are passed which causes them
 581   // to not be called.
 582   bool haveMain = findUnderscoreMangle("main");
 583   bool haveWMain = findUnderscoreMangle("wmain");
 584   bool haveWinMain = findUnderscoreMangle("WinMain");
 585   bool haveWWinMain = findUnderscoreMangle("wWinMain");
 586   if (haveMain || haveWMain) {
 587     if (haveWinMain || haveWWinMain) {
 588       warn(std::string("found ") + (haveMain ? "main" : "wmain") + " and " +
 589            (haveWinMain ? "WinMain" : "wWinMain") +
 590            "; defaulting to /subsystem:console");
 591     }
 592     return IMAGE_SUBSYSTEM_WINDOWS_CUI;
 593   }
 594   if (haveWinMain || haveWWinMain)
 595     return IMAGE_SUBSYSTEM_WINDOWS_GUI;
 596   return IMAGE_SUBSYSTEM_UNKNOWN;
 597 }
 598
 599 static uint64_t getDefaultImageBase() {
 600   if (config->is64())
 601     return config->dll ? 0x180000000 : 0x140000000;
 602   return config->dll ? 0x10000000 : 0x400000;
 603 }
 604
 605 static std::string createResponseFile(const opt::InputArgList &args,
 606                                       ArrayRef<StringRef> filePaths,
 607                                       ArrayRef<StringRef> searchPaths) {
 608   SmallString<0> data;
 609   raw_svector_ostream os(data);
 610
 611   for (auto *arg : args) {
 612     switch (arg->getOption().getID()) {
 613     case OPT_linkrepro:
 614     case OPT_reproduce:
 615     case OPT_INPUT:
 616     case OPT_defaultlib:
 617     case OPT_libpath:
 618     case OPT_manifest:
 619     case OPT_manifest_colon:
 620     case OPT_manifestdependency:
 621     case OPT_manifestfile:
 622     case OPT_manifestinput:
 623     case OPT_manifestuac:
 624       break;
 625     case OPT_implib:
 626     case OPT_pdb:
 627     case OPT_out:
 628       os << arg->getSpelling() << sys::path::filename(arg->getValue()) << "\n";
 629       break;
 630     default:
 631       os << toString(*arg) << "\n";
 632     }
 633   }
 634
 635   for (StringRef path : searchPaths) {
 636     std::string relPath = relativeToRoot(path);
 637     os << "/libpath:" << quote(relPath) << "\n";
 638   }
 639
 640   for (StringRef path : filePaths)
 641     os << quote(relativeToRoot(path)) << "\n";
 642
 643   return data.str();
 644 }
 645
 646 enum class DebugKind { Unknown, None, Full, FastLink, GHash, Dwarf, Symtab };
 647
 648 static DebugKind parseDebugKind(const opt::InputArgList &args) {
 649   auto *a = args.getLastArg(OPT_debug, OPT_debug_opt);
 650   if (!a)
 651     return DebugKind::None;
 652   if (a->getNumValues() == 0)
 653     return DebugKind::Full;
 654
 655   DebugKind debug = StringSwitch<DebugKind>(a->getValue())
 656                      .CaseLower("none", DebugKind::None)
 657                      .CaseLower("full", DebugKind::Full)
 658                      .CaseLower("fastlink", DebugKind::FastLink)
 659                      // LLD extensions
 660                      .CaseLower("ghash", DebugKind::GHash)
 661                      .CaseLower("dwarf", DebugKind::Dwarf)
 662                      .CaseLower("symtab", DebugKind::Symtab)
 663                      .Default(DebugKind::Unknown);
 664
 665   if (debug == DebugKind::FastLink) {
 666     warn("/debug:fastlink unsupported; using /debug:full");
 667     return DebugKind::Full;
 668   }
 669   if (debug == DebugKind::Unknown) {
 670     error("/debug: unknown option: " + Twine(a->getValue()));
 671     return DebugKind::None;
 672   }
 673   return debug;
 674 }
 675
 676 static unsigned parseDebugTypes(const opt::InputArgList &args) {
 677   unsigned debugTypes = static_cast<unsigned>(DebugType::None);
 678
 679   if (auto *a = args.getLastArg(OPT_debugtype)) {
 680     SmallVector<StringRef, 3> types;
 681     StringRef(a->getValue())
 682         .split(types, ',', /*MaxSplit=*/-1, /*KeepEmpty=*/false);
 683
 684     for (StringRef type : types) {
 685       unsigned v = StringSwitch<unsigned>(type.lower())
 686                        .Case("cv", static_cast<unsigned>(DebugType::CV))
 687                        .Case("pdata", static_cast<unsigned>(DebugType::PData))
 688                        .Case("fixup", static_cast<unsigned>(DebugType::Fixup))
 689                        .Default(0);
 690       if (v == 0) {
 691         warn("/debugtype: unknown option '" + type + "'");
 692         continue;
 693       }
 694       debugTypes |= v;
 695     }
 696     return debugTypes;
 697   }
 698
 699   // Default debug types
 700   debugTypes = static_cast<unsigned>(DebugType::CV);
 701   if (args.hasArg(OPT_driver))
 702     debugTypes |= static_cast<unsigned>(DebugType::PData);
 703   if (args.hasArg(OPT_profile))
 704     debugTypes |= static_cast<unsigned>(DebugType::Fixup);
 705
 706   return debugTypes;
 707 }
 708
 709 static std::string getMapFile(const opt::InputArgList &args) {
 710   auto *arg = args.getLastArg(OPT_lldmap, OPT_lldmap_file);
 711   if (!arg)
 712     return "";
 713   if (arg->getOption().getID() == OPT_lldmap_file)
 714     return arg->getValue();
 715
 716   assert(arg->getOption().getID() == OPT_lldmap);
 717   StringRef outFile = config->outputFile;
 718   return (outFile.substr(0, outFile.rfind('.')) + ".map").str();
 719 }
 720
 721 static std::string getImplibPath() {
 722   if (!config->implib.empty())
 723     return config->implib;
 724   SmallString<128> out = StringRef(config->outputFile);
 725   sys::path::replace_extension(out, ".lib");
 726   return out.str();
 727 }
 728
 729 // The import name is calculated as follows:
 730 //
 731 //        | LIBRARY w/ ext |   LIBRARY w/o ext   | no LIBRARY
 732 //   -----+----------------+---------------------+------------------
 733 //   LINK | {value}        | {value}.{.dll/.exe} | {output name}
 734 //    LIB | {value}        | {value}.dll         | {output name}.dll
 735 //
 736 static std::string getImportName(bool asLib) {
 737   SmallString<128> out;
 738
 739   if (config->importName.empty()) {
 740     out.assign(sys::path::filename(config->outputFile));
 741     if (asLib)
 742       sys::path::replace_extension(out, ".dll");
 743   } else {
 744     out.assign(config->importName);
 745     if (!sys::path::has_extension(out))
 746       sys::path::replace_extension(out,
 747                                    (config->dll || asLib) ? ".dll" : ".exe");
 748   }
 749
 750   return out.str();
 751 }
 752
 753 static void createImportLibrary(bool asLib) {
 754   std::vector<COFFShortExport> exports;
 755   for (Export &e1 : config->exports) {
 756     COFFShortExport e2;
 757     e2.Name = e1.name;
 758     e2.SymbolName = e1.symbolName;
 759     e2.ExtName = e1.extName;
 760     e2.Ordinal = e1.ordinal;
 761     e2.Noname = e1.noname;
 762     e2.Data = e1.data;
 763     e2.Private = e1.isPrivate;
 764     e2.Constant = e1.constant;
 765     exports.push_back(e2);
 766   }
 767
 768   auto handleError = [](Error &&e) {
 769     handleAllErrors(std::move(e),
 770                     [](ErrorInfoBase &eib) { error(eib.message()); });
 771   };
 772   std::string libName = getImportName(asLib);
 773   std::string path = getImplibPath();
 774
 775   if (!config->incremental) {
 776     handleError(writeImportLibrary(libName, path, exports, config->machine,
 777                                    config->mingw));
 778     return;
 779   }
 780
 781   // If the import library already exists, replace it only if the contents
 782   // have changed.
 783   ErrorOr<std::unique_ptr<MemoryBuffer>> oldBuf = MemoryBuffer::getFile(
 784       path, /*FileSize*/ -1, /*RequiresNullTerminator*/ false);
 785   if (!oldBuf) {
 786     handleError(writeImportLibrary(libName, path, exports, config->machine,
 787                                    config->mingw));
 788     return;
 789   }
 790
 791   SmallString<128> tmpName;
 792   if (std::error_code ec =
 793           sys::fs::createUniqueFile(path + ".tmp-%%%%%%%%.lib", tmpName))
 794     fatal("cannot create temporary file for import library " + path + ": " +
 795           ec.message());
 796
 797   if (Error e = writeImportLibrary(libName, tmpName, exports, config->machine,
 798                                    config->mingw)) {
 799     handleError(std::move(e));
 800     return;
 801   }
 802
 803   std::unique_ptr<MemoryBuffer> newBuf = check(MemoryBuffer::getFile(
 804       tmpName, /*FileSize*/ -1, /*RequiresNullTerminator*/ false));
 805   if ((*oldBuf)->getBuffer() != newBuf->getBuffer()) {
 806     oldBuf->reset();
 807     handleError(errorCodeToError(sys::fs::rename(tmpName, path)));
 808   } else {
 809     sys::fs::remove(tmpName);
 810   }
 811 }
 812
 813 static void parseModuleDefs(StringRef path) {
 814   std::unique_ptr<MemoryBuffer> mb = CHECK(
 815       MemoryBuffer::getFile(path, -1, false, true), "could not open " + path);
 816   COFFModuleDefinition m = check(parseCOFFModuleDefinition(
 817       mb->getMemBufferRef(), config->machine, config->mingw));
 818
 819   if (config->outputFile.empty())
 820     config->outputFile = saver.save(m.OutputFile);
 821   config->importName = saver.save(m.ImportName);
 822   if (m.ImageBase)
 823     config->imageBase = m.ImageBase;
 824   if (m.StackReserve)
 825     config->stackReserve = m.StackReserve;
 826   if (m.StackCommit)
 827     config->stackCommit = m.StackCommit;
 828   if (m.HeapReserve)
 829     config->heapReserve = m.HeapReserve;
 830   if (m.HeapCommit)
 831     config->heapCommit = m.HeapCommit;
 832   if (m.MajorImageVersion)
 833     config->majorImageVersion = m.MajorImageVersion;
 834   if (m.MinorImageVersion)
 835     config->minorImageVersion = m.MinorImageVersion;
 836   if (m.MajorOSVersion)
 837     config->majorOSVersion = m.MajorOSVersion;
 838   if (m.MinorOSVersion)
 839     config->minorOSVersion = m.MinorOSVersion;
 840
 841   for (COFFShortExport e1 : m.Exports) {
 842     Export e2;
 843     // In simple cases, only Name is set. Renamed exports are parsed
 844     // and set as "ExtName = Name". If Name has the form "OtherDll.Func",
 845     // it shouldn't be a normal exported function but a forward to another
 846     // DLL instead. This is supported by both MS and GNU linkers.
 847     if (e1.ExtName != e1.Name && StringRef(e1.Name).contains('.')) {
 848       e2.name = saver.save(e1.ExtName);
 849       e2.forwardTo = saver.save(e1.Name);
 850       config->exports.push_back(e2);
 851       continue;
 852     }
 853     e2.name = saver.save(e1.Name);
 854     e2.extName = saver.save(e1.ExtName);
 855     e2.ordinal = e1.Ordinal;
 856     e2.noname = e1.Noname;
 857     e2.data = e1.Data;
 858     e2.isPrivate = e1.Private;
 859     e2.constant = e1.Constant;
 860     config->exports.push_back(e2);
 861   }
 862 }
 863
 864 void LinkerDriver::enqueueTask(std::function<void()> task) {
 865   taskQueue.push_back(std::move(task));
 866 }
 867
 868 bool LinkerDriver::run() {
 869   ScopedTimer t(inputFileTimer);
 870
 871   bool didWork = !taskQueue.empty();
 872   while (!taskQueue.empty()) {
 873     taskQueue.front()();
 874     taskQueue.pop_front();
 875   }
 876   return didWork;
 877 }
 878
 879 // Parse an /order file. If an option is given, the linker places
 880 // COMDAT sections in the same order as their names appear in the
 881 // given file.
 882 static void parseOrderFile(StringRef arg) {
 883   // For some reason, the MSVC linker requires a filename to be
 884   // preceded by "@".
 885   if (!arg.startswith("@")) {
 886     error("malformed /order option: '@' missing");
 887     return;
 888   }
 889
 890   // Get a list of all comdat sections for error checking.
 891   DenseSet<StringRef> set;
 892   for (Chunk *c : symtab->getChunks())
 893     if (auto *sec = dyn_cast<SectionChunk>(c))
 894       if (sec->sym)
 895         set.insert(sec->sym->getName());
 896
 897   // Open a file.
 898   StringRef path = arg.substr(1);
 899   std::unique_ptr<MemoryBuffer> mb = CHECK(
 900       MemoryBuffer::getFile(path, -1, false, true), "could not open " + path);
 901
 902   // Parse a file. An order file contains one symbol per line.
 903   // All symbols that were not present in a given order file are
 904   // considered to have the lowest priority 0 and are placed at
 905   // end of an output section.
 906   for (std::string s : args::getLines(mb->getMemBufferRef())) {
 907     if (config->machine == I386 && !isDecorated(s))
 908       s = "_" + s;
 909
 910     if (set.count(s) == 0) {
 911       if (config->warnMissingOrderSymbol)
 912         warn("/order:" + arg + ": missing symbol: " + s + " [LNK4037]");
 913     }
 914     else
 915       config->order[s] = INT_MIN + config->order.size();
 916   }
 917 }
 918
 919 static void markAddrsig(Symbol *s) {
 920   if (auto *d = dyn_cast_or_null<Defined>(s))
 921     if (SectionChunk *c = dyn_cast_or_null<SectionChunk>(d->getChunk()))
 922       c->keepUnique = true;
 923 }
 924
 925 static void findKeepUniqueSections() {
 926   // Exported symbols could be address-significant in other executables or DSOs,
 927   // so we conservatively mark them as address-significant.
 928   for (Export &r : config->exports)
 929     markAddrsig(r.sym);
 930
 931   // Visit the address-significance table in each object file and mark each
 932   // referenced symbol as address-significant.
 933   for (ObjFile *obj : ObjFile::instances) {
 934     ArrayRef<Symbol *> syms = obj->getSymbols();
 935     if (obj->addrsigSec) {
 936       ArrayRef<uint8_t> contents;
 937       cantFail(
 938           obj->getCOFFObj()->getSectionContents(obj->addrsigSec, contents));
 939       const uint8_t *cur = contents.begin();
 940       while (cur != contents.end()) {
 941         unsigned size;
 942         const char *err;
 943         uint64_t symIndex = decodeULEB128(cur, &size, contents.end(), &err);
 944         if (err)
 945           fatal(toString(obj) + ": could not decode addrsig section: " + err);
 946         if (symIndex >= syms.size())
 947           fatal(toString(obj) + ": invalid symbol index in addrsig section");
 948         markAddrsig(syms[symIndex]);
 949         cur += size;
 950       }
 951     } else {
 952       // If an object file does not have an address-significance table,
 953       // conservatively mark all of its symbols as address-significant.
 954       for (Symbol *s : syms)
 955         markAddrsig(s);
 956     }
 957   }
 958 }
 959
 960 // link.exe replaces each %foo% in altPath with the contents of environment
 961 // variable foo, and adds the two magic env vars _PDB (expands to the basename
 962 // of pdb's output path) and _EXT (expands to the extension of the output
 963 // binary).
 964 // lld only supports %_PDB% and %_EXT% and warns on references to all other env
 965 // vars.
 966 static void parsePDBAltPath(StringRef altPath) {
 967   SmallString<128> buf;
 968   StringRef pdbBasename =
 969       sys::path::filename(config->pdbPath, sys::path::Style::windows);
 970   StringRef binaryExtension =
 971       sys::path::extension(config->outputFile, sys::path::Style::windows);
 972   if (!binaryExtension.empty())
 973     binaryExtension = binaryExtension.substr(1); // %_EXT% does not include '.'.
 974
 975   // Invariant:
 976   //   +--------- cursor ('a...' might be the empty string).
 977   //   |   +----- firstMark
 978   //   |   |   +- secondMark
 979   //   v   v   v
 980   //   a...%...%...
 981   size_t cursor = 0;
 982   while (cursor < altPath.size()) {
 983     size_t firstMark, secondMark;
 984     if ((firstMark = altPath.find('%', cursor)) == StringRef::npos ||
 985         (secondMark = altPath.find('%', firstMark + 1)) == StringRef::npos) {
 986       // Didn't find another full fragment, treat rest of string as literal.
 987       buf.append(altPath.substr(cursor));
 988       break;
 989     }
 990
 991     // Found a full fragment. Append text in front of first %, and interpret
 992     // text between first and second % as variable name.
 993     buf.append(altPath.substr(cursor, firstMark - cursor));
 994     StringRef var = altPath.substr(firstMark, secondMark - firstMark + 1);
 995     if (var.equals_lower("%_pdb%"))
 996       buf.append(pdbBasename);
 997     else if (var.equals_lower("%_ext%"))
 998       buf.append(binaryExtension);
 999     else {
1000       warn("only %_PDB% and %_EXT% supported in /pdbaltpath:, keeping " +
1001            var + " as literal");
1002       buf.append(var);
1003     }
1004
1005     cursor = secondMark + 1;
1006   }
1007
1008   config->pdbAltPath = buf;
1009 }
1010
1011 /// Convert resource files and potentially merge input resource object
1012 /// trees into one resource tree.
1013 /// Call after ObjFile::Instances is complete.
1014 void LinkerDriver::convertResources() {
1015   std::vector<ObjFile *> resourceObjFiles;
1016
1017   for (ObjFile *f : ObjFile::instances) {
1018     if (f->isResourceObjFile())
1019       resourceObjFiles.push_back(f);
1020   }
1021
1022   if (!config->mingw &&
1023       (resourceObjFiles.size() > 1 ||
1024        (resourceObjFiles.size() == 1 && !resources.empty()))) {
1025     error((!resources.empty() ? "internal .obj file created from .res files"
1026                               : toString(resourceObjFiles[1])) +
1027           ": more than one resource obj file not allowed, already got " +
1028           toString(resourceObjFiles.front()));
1029     return;
1030   }
1031
1032   if (resources.empty() && resourceObjFiles.size() <= 1) {
1033     // No resources to convert, and max one resource object file in
1034     // the input. Keep that preconverted resource section as is.
1035     for (ObjFile *f : resourceObjFiles)
1036       f->includeResourceChunks();
1037     return;
1038   }
1039   ObjFile *f = make<ObjFile>(convertResToCOFF(resources, resourceObjFiles));
1040   symtab->addFile(f);
1041   f->includeResourceChunks();
1042 }
1043
1044 // In MinGW, if no symbols are chosen to be exported, then all symbols are
1045 // automatically exported by default. This behavior can be forced by the
1046 // -export-all-symbols option, so that it happens even when exports are
1047 // explicitly specified. The automatic behavior can be disabled using the
1048 // -exclude-all-symbols option, so that lld-link behaves like link.exe rather
1049 // than MinGW in the case that nothing is explicitly exported.
1050 void LinkerDriver::maybeExportMinGWSymbols(const opt::InputArgList &args) {
1051   if (!config->dll)
1052     return;
1053
1054   if (!args.hasArg(OPT_export_all_symbols)) {
1055     if (!config->exports.empty())
1056       return;
1057     if (args.hasArg(OPT_exclude_all_symbols))
1058       return;
1059   }
1060
1061   AutoExporter exporter;
1062
1063   for (auto *arg : args.filtered(OPT_wholearchive_file))
1064     if (Optional<StringRef> path = doFindFile(arg->getValue()))
1065       exporter.addWholeArchive(*path);
1066
1067   symtab->forEachSymbol([&](Symbol *s) {
1068     auto *def = dyn_cast<Defined>(s);
1069     if (!exporter.shouldExport(def))
1070       return;
1071
1072     Export e;
1073     e.name = def->getName();
1074     e.sym = def;
1075     if (Chunk *c = def->getChunk())
1076       if (!(c->getOutputCharacteristics() & IMAGE_SCN_MEM_EXECUTE))
1077         e.data = true;
1078     config->exports.push_back(e);
1079   });
1080 }
1081
1082 // lld has a feature to create a tar file containing all input files as well as
1083 // all command line options, so that other people can run lld again with exactly
1084 // the same inputs. This feature is accessible via /linkrepro and /reproduce.
1085 //
1086 // /linkrepro and /reproduce are very similar, but /linkrepro takes a directory
1087 // name while /reproduce takes a full path. We have /linkrepro for compatibility
1088 // with Microsoft link.exe.
1089 Optional<std::string> getReproduceFile(const opt::InputArgList &args) {
1090   if (auto *arg = args.getLastArg(OPT_reproduce))
1091     return std::string(arg->getValue());
1092
1093   if (auto *arg = args.getLastArg(OPT_linkrepro)) {
1094     SmallString<64> path = StringRef(arg->getValue());
1095     sys::path::append(path, "repro.tar");
1096     return path.str().str();
1097   }
1098
1099   return None;
1100 }
1101
1102 void LinkerDriver::link(ArrayRef<const char *> argsArr) {
1103   // Needed for LTO.
1104   InitializeAllTargetInfos();
1105   InitializeAllTargets();
1106   InitializeAllTargetMCs();
1107   InitializeAllAsmParsers();
1108   InitializeAllAsmPrinters();
1109
1110   // If the first command line argument is "/lib", link.exe acts like lib.exe.
1111   // We call our own implementation of lib.exe that understands bitcode files.
1112   if (argsArr.size() > 1 && StringRef(argsArr[1]).equals_lower("/lib")) {
1113     if (llvm::libDriverMain(argsArr.slice(1)) != 0)
1114       fatal("lib failed");
1115     return;
1116   }
1117
1118   // Parse command line options.
1119   ArgParser parser;
1120   opt::InputArgList args = parser.parse(argsArr);
1121
1122   // Parse and evaluate -mllvm options.
1123   std::vector<const char *> v;
1124   v.push_back("lld-link (LLVM option parsing)");
1125   for (auto *arg : args.filtered(OPT_mllvm))
1126     v.push_back(arg->getValue());
1127   cl::ParseCommandLineOptions(v.size(), v.data());
1128
1129   // Handle /errorlimit early, because error() depends on it.
1130   if (auto *arg = args.getLastArg(OPT_errorlimit)) {
1131     int n = 20;
1132     StringRef s = arg->getValue();
1133     if (s.getAsInteger(10, n))
1134       error(arg->getSpelling() + " number expected, but got " + s);
1135     errorHandler().errorLimit = n;
1136   }
1137
1138   // Handle /help
1139   if (args.hasArg(OPT_help)) {
1140     printHelp(argsArr[0]);
1141     return;
1142   }
1143
1144   lld::threadsEnabled = args.hasFlag(OPT_threads, OPT_threads_no, true);
1145
1146   if (args.hasArg(OPT_show_timing))
1147     config->showTiming = true;
1148
1149   config->showSummary = args.hasArg(OPT_summary);
1150
1151   ScopedTimer t(Timer::root());
1152   // Handle --version, which is an lld extension. This option is a bit odd
1153   // because it doesn't start with "/", but we deliberately chose "--" to
1154   // avoid conflict with /version and for compatibility with clang-cl.
1155   if (args.hasArg(OPT_dash_dash_version)) {
1156     lld::outs() << getLLDVersion() << "\n";
1157     return;
1158   }
1159
1160   // Handle /lldmingw early, since it can potentially affect how other
1161   // options are handled.
1162   config->mingw = args.hasArg(OPT_lldmingw);
1163
1164   // Handle /linkrepro and /reproduce.
1165   if (Optional<std::string> path = getReproduceFile(args)) {
1166     Expected<std::unique_ptr<TarWriter>> errOrWriter =
1167         TarWriter::create(*path, sys::path::stem(*path));
1168
1169     if (errOrWriter) {
1170       tar = std::move(*errOrWriter);
1171     } else {
1172       error("/linkrepro: failed to open " + *path + ": " +
1173             toString(errOrWriter.takeError()));
1174     }
1175   }
1176
1177   if (!args.hasArg(OPT_INPUT, OPT_wholearchive_file)) {
1178     if (args.hasArg(OPT_deffile))
1179       config->noEntry = true;
1180     else
1181       fatal("no input files");
1182   }
1183
1184   // Construct search path list.
1185   searchPaths.push_back("");
1186   for (auto *arg : args.filtered(OPT_libpath))
1187     searchPaths.push_back(arg->getValue());
1188   if (!args.hasArg(OPT_lldignoreenv))
1189     addLibSearchPaths();
1190
1191   // Handle /ignore
1192   for (auto *arg : args.filtered(OPT_ignore)) {
1193     SmallVector<StringRef, 8> vec;
1194     StringRef(arg->getValue()).split(vec, ',');
1195     for (StringRef s : vec) {
1196       if (s == "4037")
1197         config->warnMissingOrderSymbol = false;
1198       else if (s == "4099")
1199         config->warnDebugInfoUnusable = false;
1200       else if (s == "4217")
1201         config->warnLocallyDefinedImported = false;
1202       else if (s == "longsections")
1203         config->warnLongSectionNames = false;
1204       // Other warning numbers are ignored.
1205     }
1206   }
1207
1208   // Handle /out
1209   if (auto *arg = args.getLastArg(OPT_out))
1210     config->outputFile = arg->getValue();
1211
1212   // Handle /verbose
1213   if (args.hasArg(OPT_verbose))
1214     config->verbose = true;
1215   errorHandler().verbose = config->verbose;
1216
1217   // Handle /force or /force:unresolved
1218   if (args.hasArg(OPT_force, OPT_force_unresolved))
1219     config->forceUnresolved = true;
1220
1221   // Handle /force or /force:multiple
1222   if (args.hasArg(OPT_force, OPT_force_multiple))
1223     config->forceMultiple = true;
1224
1225   // Handle /force or /force:multipleres
1226   if (args.hasArg(OPT_force, OPT_force_multipleres))
1227     config->forceMultipleRes = true;
1228
1229   // Handle /debug
1230   DebugKind debug = parseDebugKind(args);
1231   if (debug == DebugKind::Full || debug == DebugKind::Dwarf ||
1232       debug == DebugKind::GHash) {
1233     config->debug = true;
1234     config->incremental = true;
1235   }
1236
1237   // Handle /demangle
1238   config->demangle = args.hasFlag(OPT_demangle, OPT_demangle_no);
1239
1240   // Handle /debugtype
1241   config->debugTypes = parseDebugTypes(args);
1242
1243   // Handle /driver[:uponly|:wdm].
1244   config->driverUponly = args.hasArg(OPT_driver_uponly) ||
1245                          args.hasArg(OPT_driver_uponly_wdm) ||
1246                          args.hasArg(OPT_driver_wdm_uponly);
1247   config->driverWdm = args.hasArg(OPT_driver_wdm) ||
1248                       args.hasArg(OPT_driver_uponly_wdm) ||
1249                       args.hasArg(OPT_driver_wdm_uponly);
1250   config->driver =
1251       config->driverUponly || config->driverWdm || args.hasArg(OPT_driver);
1252
1253   // Handle /pdb
1254   bool shouldCreatePDB =
1255       (debug == DebugKind::Full || debug == DebugKind::GHash);
1256   if (shouldCreatePDB) {
1257     if (auto *arg = args.getLastArg(OPT_pdb))
1258       config->pdbPath = arg->getValue();
1259     if (auto *arg = args.getLastArg(OPT_pdbaltpath))
1260       config->pdbAltPath = arg->getValue();
1261     if (args.hasArg(OPT_natvis))
1262       config->natvisFiles = args.getAllArgValues(OPT_natvis);
1263
1264     if (auto *arg = args.getLastArg(OPT_pdb_source_path))
1265       config->pdbSourcePath = arg->getValue();
1266   }
1267
1268   // Handle /noentry
1269   if (args.hasArg(OPT_noentry)) {
1270     if (args.hasArg(OPT_dll))
1271       config->noEntry = true;
1272     else
1273       error("/noentry must be specified with /dll");
1274   }
1275
1276   // Handle /dll
1277   if (args.hasArg(OPT_dll)) {
1278     config->dll = true;
1279     config->manifestID = 2;
1280   }
1281
1282   // Handle /dynamicbase and /fixed. We can't use hasFlag for /dynamicbase
1283   // because we need to explicitly check whether that option or its inverse was
1284   // present in the argument list in order to handle /fixed.
1285   auto *dynamicBaseArg = args.getLastArg(OPT_dynamicbase, OPT_dynamicbase_no);
1286   if (dynamicBaseArg &&
1287       dynamicBaseArg->getOption().getID() == OPT_dynamicbase_no)
1288     config->dynamicBase = false;
1289
1290   // MSDN claims "/FIXED:NO is the default setting for a DLL, and /FIXED is the
1291   // default setting for any other project type.", but link.exe defaults to
1292   // /FIXED:NO for exe outputs as well. Match behavior, not docs.
1293   bool fixed = args.hasFlag(OPT_fixed, OPT_fixed_no, false);
1294   if (fixed) {
1295     if (dynamicBaseArg &&
1296         dynamicBaseArg->getOption().getID() == OPT_dynamicbase) {
1297       error("/fixed must not be specified with /dynamicbase");
1298     } else {
1299       config->relocatable = false;
1300       config->dynamicBase = false;
1301     }
1302   }
1303
1304   // Handle /appcontainer
1305   config->appContainer =
1306       args.hasFlag(OPT_appcontainer, OPT_appcontainer_no, false);
1307
1308   // Handle /machine
1309   if (auto *arg = args.getLastArg(OPT_machine)) {
1310     config->machine = getMachineType(arg->getValue());
1311     if (config->machine == IMAGE_FILE_MACHINE_UNKNOWN)
1312       fatal(Twine("unknown /machine argument: ") + arg->getValue());
1313   }
1314
1315   // Handle /nodefaultlib:<filename>
1316   for (auto *arg : args.filtered(OPT_nodefaultlib))
1317     config->noDefaultLibs.insert(doFindLib(arg->getValue()).lower());
1318
1319   // Handle /nodefaultlib
1320   if (args.hasArg(OPT_nodefaultlib_all))
1321     config->noDefaultLibAll = true;
1322
1323   // Handle /base
1324   if (auto *arg = args.getLastArg(OPT_base))
1325     parseNumbers(arg->getValue(), &config->imageBase);
1326
1327   // Handle /filealign
1328   if (auto *arg = args.getLastArg(OPT_filealign)) {
1329     parseNumbers(arg->getValue(), &config->fileAlign);
1330     if (!isPowerOf2_64(config->fileAlign))
1331       error("/filealign: not a power of two: " + Twine(config->fileAlign));
1332   }
1333
1334   // Handle /stack
1335   if (auto *arg = args.getLastArg(OPT_stack))
1336     parseNumbers(arg->getValue(), &config->stackReserve, &config->stackCommit);
1337
1338   // Handle /guard:cf
1339   if (auto *arg = args.getLastArg(OPT_guard))
1340     parseGuard(arg->getValue());
1341
1342   // Handle /heap
1343   if (auto *arg = args.getLastArg(OPT_heap))
1344     parseNumbers(arg->getValue(), &config->heapReserve, &config->heapCommit);
1345
1346   // Handle /version
1347   if (auto *arg = args.getLastArg(OPT_version))
1348     parseVersion(arg->getValue(), &config->majorImageVersion,
1349                  &config->minorImageVersion);
1350
1351   // Handle /subsystem
1352   if (auto *arg = args.getLastArg(OPT_subsystem))
1353     parseSubsystem(arg->getValue(), &config->subsystem, &config->majorOSVersion,
1354                    &config->minorOSVersion);
1355
1356   // Handle /timestamp
1357   if (llvm::opt::Arg *arg = args.getLastArg(OPT_timestamp, OPT_repro)) {
1358     if (arg->getOption().getID() == OPT_repro) {
1359       config->timestamp = 0;
1360       config->repro = true;
1361     } else {
1362       config->repro = false;
1363       StringRef value(arg->getValue());
1364       if (value.getAsInteger(0, config->timestamp))
1365         fatal(Twine("invalid timestamp: ") + value +
1366               ".  Expected 32-bit integer");
1367     }
1368   } else {
1369     config->repro = false;
1370     config->timestamp = time(nullptr);
1371   }
1372
1373   // Handle /alternatename
1374   for (auto *arg : args.filtered(OPT_alternatename))
1375     parseAlternateName(arg->getValue());
1376
1377   // Handle /include
1378   for (auto *arg : args.filtered(OPT_incl))
1379     addUndefined(arg->getValue());
1380
1381   // Handle /implib
1382   if (auto *arg = args.getLastArg(OPT_implib))
1383     config->implib = arg->getValue();
1384
1385   // Handle /opt.
1386   bool doGC = debug == DebugKind::None || args.hasArg(OPT_profile);
1387   unsigned icfLevel =
1388       args.hasArg(OPT_profile) ? 0 : 1; // 0: off, 1: limited, 2: on
1389   unsigned tailMerge = 1;
1390   for (auto *arg : args.filtered(OPT_opt)) {
1391     std::string str = StringRef(arg->getValue()).lower();
1392     SmallVector<StringRef, 1> vec;
1393     StringRef(str).split(vec, ',');
1394     for (StringRef s : vec) {
1395       if (s == "ref") {
1396         doGC = true;
1397       } else if (s == "noref") {
1398         doGC = false;
1399       } else if (s == "icf" || s.startswith("icf=")) {
1400         icfLevel = 2;
1401       } else if (s == "noicf") {
1402         icfLevel = 0;
1403       } else if (s == "lldtailmerge") {
1404         tailMerge = 2;
1405       } else if (s == "nolldtailmerge") {
1406         tailMerge = 0;
1407       } else if (s.startswith("lldlto=")) {
1408         StringRef optLevel = s.substr(7);
1409         if (optLevel.getAsInteger(10, config->ltoo) || config->ltoo > 3)
1410           error("/opt:lldlto: invalid optimization level: " + optLevel);
1411       } else if (s.startswith("lldltojobs=")) {
1412         StringRef jobs = s.substr(11);
1413         if (jobs.getAsInteger(10, config->thinLTOJobs) ||
1414             config->thinLTOJobs == 0)
1415           error("/opt:lldltojobs: invalid job count: " + jobs);
1416       } else if (s.startswith("lldltopartitions=")) {
1417         StringRef n = s.substr(17);
1418         if (n.getAsInteger(10, config->ltoPartitions) ||
1419             config->ltoPartitions == 0)
1420           error("/opt:lldltopartitions: invalid partition count: " + n);
1421       } else if (s != "lbr" && s != "nolbr")
1422         error("/opt: unknown option: " + s);
1423     }
1424   }
1425
1426   // Limited ICF is enabled if GC is enabled and ICF was never mentioned
1427   // explicitly.
1428   // FIXME: LLD only implements "limited" ICF, i.e. it only merges identical
1429   // code. If the user passes /OPT:ICF explicitly, LLD should merge identical
1430   // comdat readonly data.
1431   if (icfLevel == 1 && !doGC)
1432     icfLevel = 0;
1433   config->doGC = doGC;
1434   config->doICF = icfLevel > 0;
1435   config->tailMerge = (tailMerge == 1 && config->doICF) || tailMerge == 2;
1436
1437   // Handle /lldsavetemps
1438   if (args.hasArg(OPT_lldsavetemps))
1439     config->saveTemps = true;
1440
1441   // Handle /kill-at
1442   if (args.hasArg(OPT_kill_at))
1443     config->killAt = true;
1444
1445   // Handle /lldltocache
1446   if (auto *arg = args.getLastArg(OPT_lldltocache))
1447     config->ltoCache = arg->getValue();
1448
1449   // Handle /lldsavecachepolicy
1450   if (auto *arg = args.getLastArg(OPT_lldltocachepolicy))
1451     config->ltoCachePolicy = CHECK(
1452         parseCachePruningPolicy(arg->getValue()),
1453         Twine("/lldltocachepolicy: invalid cache policy: ") + arg->getValue());
1454
1455   // Handle /failifmismatch
1456   for (auto *arg : args.filtered(OPT_failifmismatch))
1457     checkFailIfMismatch(arg->getValue(), nullptr);
1458
1459   // Handle /merge
1460   for (auto *arg : args.filtered(OPT_merge))
1461     parseMerge(arg->getValue());
1462
1463   // Add default section merging rules after user rules. User rules take
1464   // precedence, but we will emit a warning if there is a conflict.
1465   parseMerge(".idata=.rdata");
1466   parseMerge(".didat=.rdata");
1467   parseMerge(".edata=.rdata");
1468   parseMerge(".xdata=.rdata");
1469   parseMerge(".bss=.data");
1470
1471   if (config->mingw) {
1472     parseMerge(".ctors=.rdata");
1473     parseMerge(".dtors=.rdata");
1474     parseMerge(".CRT=.rdata");
1475   }
1476
1477   // Handle /section
1478   for (auto *arg : args.filtered(OPT_section))
1479     parseSection(arg->getValue());
1480
1481   // Handle /align
1482   if (auto *arg = args.getLastArg(OPT_align)) {
1483     parseNumbers(arg->getValue(), &config->align);
1484     if (!isPowerOf2_64(config->align))
1485       error("/align: not a power of two: " + StringRef(arg->getValue()));
1486     if (!args.hasArg(OPT_driver))
1487       warn("/align specified without /driver; image may not run");
1488   }
1489
1490   // Handle /aligncomm
1491   for (auto *arg : args.filtered(OPT_aligncomm))
1492     parseAligncomm(arg->getValue());
1493
1494   // Handle /manifestdependency. This enables /manifest unless /manifest:no is
1495   // also passed.
1496   if (auto *arg = args.getLastArg(OPT_manifestdependency)) {
1497     config->manifestDependency = arg->getValue();
1498     config->manifest = Configuration::SideBySide;
1499   }
1500
1501   // Handle /manifest and /manifest:
1502   if (auto *arg = args.getLastArg(OPT_manifest, OPT_manifest_colon)) {
1503     if (arg->getOption().getID() == OPT_manifest)
1504       config->manifest = Configuration::SideBySide;
1505     else
1506       parseManifest(arg->getValue());
1507   }
1508
1509   // Handle /manifestuac
1510   if (auto *arg = args.getLastArg(OPT_manifestuac))
1511     parseManifestUAC(arg->getValue());
1512
1513   // Handle /manifestfile
1514   if (auto *arg = args.getLastArg(OPT_manifestfile))
1515     config->manifestFile = arg->getValue();
1516
1517   // Handle /manifestinput
1518   for (auto *arg : args.filtered(OPT_manifestinput))
1519     config->manifestInput.push_back(arg->getValue());
1520
1521   if (!config->manifestInput.empty() &&
1522       config->manifest != Configuration::Embed) {
1523     fatal("/manifestinput: requires /manifest:embed");
1524   }
1525
1526   config->thinLTOEmitImportsFiles = args.hasArg(OPT_thinlto_emit_imports_files);
1527   config->thinLTOIndexOnly = args.hasArg(OPT_thinlto_index_only) ||
1528                              args.hasArg(OPT_thinlto_index_only_arg);
1529   config->thinLTOIndexOnlyArg =
1530       args.getLastArgValue(OPT_thinlto_index_only_arg);
1531   config->thinLTOPrefixReplace =
1532       getOldNewOptions(args, OPT_thinlto_prefix_replace);
1533   config->thinLTOObjectSuffixReplace =
1534       getOldNewOptions(args, OPT_thinlto_object_suffix_replace);
1535   config->ltoObjPath = args.getLastArgValue(OPT_lto_obj_path);
1536   // Handle miscellaneous boolean flags.
1537   config->allowBind = args.hasFlag(OPT_allowbind, OPT_allowbind_no, true);
1538   config->allowIsolation =
1539       args.hasFlag(OPT_allowisolation, OPT_allowisolation_no, true);
1540   config->incremental =
1541       args.hasFlag(OPT_incremental, OPT_incremental_no,
1542                    !config->doGC && !config->doICF && !args.hasArg(OPT_order) &&
1543                        !args.hasArg(OPT_profile));
1544   config->integrityCheck =
1545       args.hasFlag(OPT_integritycheck, OPT_integritycheck_no, false);
1546   config->nxCompat = args.hasFlag(OPT_nxcompat, OPT_nxcompat_no, true);
1547   for (auto *arg : args.filtered(OPT_swaprun))
1548     parseSwaprun(arg->getValue());
1549   config->terminalServerAware =
1550       !config->dll && args.hasFlag(OPT_tsaware, OPT_tsaware_no, true);
1551   config->debugDwarf = debug == DebugKind::Dwarf;
1552   config->debugGHashes = debug == DebugKind::GHash;
1553   config->debugSymtab = debug == DebugKind::Symtab;
1554
1555   // Don't warn about long section names, such as .debug_info, for mingw or when
1556   // -debug:dwarf is requested.
1557   if (config->mingw || config->debugDwarf)
1558     config->warnLongSectionNames = false;
1559
1560   config->mapFile = getMapFile(args);
1561
1562   if (config->incremental && args.hasArg(OPT_profile)) {
1563     warn("ignoring '/incremental' due to '/profile' specification");
1564     config->incremental = false;
1565   }
1566
1567   if (config->incremental && args.hasArg(OPT_order)) {
1568     warn("ignoring '/incremental' due to '/order' specification");
1569     config->incremental = false;
1570   }
1571
1572   if (config->incremental && config->doGC) {
1573     warn("ignoring '/incremental' because REF is enabled; use '/opt:noref' to "
1574          "disable");
1575     config->incremental = false;
1576   }
1577
1578   if (config->incremental && config->doICF) {
1579     warn("ignoring '/incremental' because ICF is enabled; use '/opt:noicf' to "
1580          "disable");
1581     config->incremental = false;
1582   }
1583
1584   if (errorCount())
1585     return;
1586
1587   std::set<sys::fs::UniqueID> wholeArchives;
1588   for (auto *arg : args.filtered(OPT_wholearchive_file))
1589     if (Optional<StringRef> path = doFindFile(arg->getValue()))
1590       if (Optional<sys::fs::UniqueID> id = getUniqueID(*path))
1591         wholeArchives.insert(*id);
1592
1593   // A predicate returning true if a given path is an argument for
1594   // /wholearchive:, or /wholearchive is enabled globally.
1595   // This function is a bit tricky because "foo.obj /wholearchive:././foo.obj"
1596   // needs to be handled as "/wholearchive:foo.obj foo.obj".
1597   auto isWholeArchive = [&](StringRef path) -> bool {
1598     if (args.hasArg(OPT_wholearchive_flag))
1599       return true;
1600     if (Optional<sys::fs::UniqueID> id = getUniqueID(path))
1601       return wholeArchives.count(*id);
1602     return false;
1603   };
1604
1605   // Create a list of input files. These can be given as OPT_INPUT options
1606   // and OPT_wholearchive_file options, and we also need to track OPT_start_lib
1607   // and OPT_end_lib.
1608   bool inLib = false;
1609   for (auto *arg : args) {
1610     switch (arg->getOption().getID()) {
1611     case OPT_end_lib:
1612       if (!inLib)
1613         error("stray " + arg->getSpelling());
1614       inLib = false;
1615       break;
1616     case OPT_start_lib:
1617       if (inLib)
1618         error("nested " + arg->getSpelling());
1619       inLib = true;
1620       break;
1621     case OPT_wholearchive_file:
1622       if (Optional<StringRef> path = findFile(arg->getValue()))
1623         enqueuePath(*path, true, inLib);
1624       break;
1625     case OPT_INPUT:
1626       if (Optional<StringRef> path = findFile(arg->getValue()))
1627         enqueuePath(*path, isWholeArchive(*path), inLib);
1628       break;
1629     default:
1630       // Ignore other options.
1631       break;
1632     }
1633   }
1634
1635   // Process files specified as /defaultlib. These should be enequeued after
1636   // other files, which is why they are in a separate loop.
1637   for (auto *arg : args.filtered(OPT_defaultlib))
1638     if (Optional<StringRef> path = findLib(arg->getValue()))
1639       enqueuePath(*path, false, false);
1640
1641   // Windows specific -- Create a resource file containing a manifest file.
1642   if (config->manifest == Configuration::Embed)
1643     addBuffer(createManifestRes(), false, false);
1644
1645   // Read all input files given via the command line.
1646   run();
1647
1648   if (errorCount())
1649     return;
1650
1651   // We should have inferred a machine type by now from the input files, but if
1652   // not we assume x64.
1653   if (config->machine == IMAGE_FILE_MACHINE_UNKNOWN) {
1654     warn("/machine is not specified. x64 is assumed");
1655     config->machine = AMD64;
1656   }
1657   config->wordsize = config->is64() ? 8 : 4;
1658
1659   // Handle /safeseh, x86 only, on by default, except for mingw.
1660   if (config->machine == I386 &&
1661       args.hasFlag(OPT_safeseh, OPT_safeseh_no, !config->mingw))
1662     config->safeSEH = true;
1663
1664   // Handle /functionpadmin
1665   for (auto *arg : args.filtered(OPT_functionpadmin, OPT_functionpadmin_opt))
1666     parseFunctionPadMin(arg, config->machine);
1667
1668   if (tar)
1669     tar->append("response.txt",
1670                 createResponseFile(args, filePaths,
1671                                    ArrayRef<StringRef>(searchPaths).slice(1)));
1672
1673   // Handle /largeaddressaware
1674   config->largeAddressAware = args.hasFlag(
1675       OPT_largeaddressaware, OPT_largeaddressaware_no, config->is64());
1676
1677   // Handle /highentropyva
1678   config->highEntropyVA =
1679       config->is64() &&
1680       args.hasFlag(OPT_highentropyva, OPT_highentropyva_no, true);
1681
1682   if (!config->dynamicBase &&
1683       (config->machine == ARMNT || config->machine == ARM64))
1684     error("/dynamicbase:no is not compatible with " +
1685           machineToStr(config->machine));
1686
1687   // Handle /export
1688   for (auto *arg : args.filtered(OPT_export)) {
1689     Export e = parseExport(arg->getValue());
1690     if (config->machine == I386) {
1691       if (!isDecorated(e.name))
1692         e.name = saver.save("_" + e.name);
1693       if (!e.extName.empty() && !isDecorated(e.extName))
1694         e.extName = saver.save("_" + e.extName);
1695     }
1696     config->exports.push_back(e);
1697   }
1698
1699   // Handle /def
1700   if (auto *arg = args.getLastArg(OPT_deffile)) {
1701     // parseModuleDefs mutates Config object.
1702     parseModuleDefs(arg->getValue());
1703   }
1704
1705   // Handle generation of import library from a def file.
1706   if (!args.hasArg(OPT_INPUT, OPT_wholearchive_file)) {
1707     fixupExports();
1708     createImportLibrary(/*asLib=*/true);
1709     return;
1710   }
1711
1712   // Windows specific -- if no /subsystem is given, we need to infer
1713   // that from entry point name.  Must happen before /entry handling,
1714   // and after the early return when just writing an import library.
1715   if (config->subsystem == IMAGE_SUBSYSTEM_UNKNOWN) {
1716     config->subsystem = inferSubsystem();
1717     if (config->subsystem == IMAGE_SUBSYSTEM_UNKNOWN)
1718       fatal("subsystem must be defined");
1719   }
1720
1721   // Handle /entry and /dll
1722   if (auto *arg = args.getLastArg(OPT_entry)) {
1723     config->entry = addUndefined(mangle(arg->getValue()));
1724   } else if (!config->entry && !config->noEntry) {
1725     if (args.hasArg(OPT_dll)) {
1726       StringRef s = (config->machine == I386) ? "__DllMainCRTStartup@12"
1727                                               : "_DllMainCRTStartup";
1728       config->entry = addUndefined(s);
1729     } else if (config->driverWdm) {
1730       // /driver:wdm implies /entry:_NtProcessStartup
1731       config->entry = addUndefined(mangle("_NtProcessStartup"));
1732     } else {
1733       // Windows specific -- If entry point name is not given, we need to
1734       // infer that from user-defined entry name.
1735       StringRef s = findDefaultEntry();
1736       if (s.empty())
1737         fatal("entry point must be defined");
1738       config->entry = addUndefined(s);
1739       log("Entry name inferred: " + s);
1740     }
1741   }
1742
1743   // Handle /delayload
1744   for (auto *arg : args.filtered(OPT_delayload)) {
1745     config->delayLoads.insert(StringRef(arg->getValue()).lower());
1746     if (config->machine == I386) {
1747       config->delayLoadHelper = addUndefined("___delayLoadHelper2@8");
1748     } else {
1749       config->delayLoadHelper = addUndefined("__delayLoadHelper2");
1750     }
1751   }
1752
1753   // Set default image name if neither /out or /def set it.
1754   if (config->outputFile.empty()) {
1755     config->outputFile = getOutputPath(
1756         (*args.filtered(OPT_INPUT, OPT_wholearchive_file).begin())->getValue());
1757   }
1758
1759   // Fail early if an output file is not writable.
1760   if (auto e = tryCreateFile(config->outputFile)) {
1761     error("cannot open output file " + config->outputFile + ": " + e.message());
1762     return;
1763   }
1764
1765   if (shouldCreatePDB) {
1766     // Put the PDB next to the image if no /pdb flag was passed.
1767     if (config->pdbPath.empty()) {
1768       config->pdbPath = config->outputFile;
1769       sys::path::replace_extension(config->pdbPath, ".pdb");
1770     }
1771
1772     // The embedded PDB path should be the absolute path to the PDB if no
1773     // /pdbaltpath flag was passed.
1774     if (config->pdbAltPath.empty()) {
1775       config->pdbAltPath = config->pdbPath;
1776
1777       // It's important to make the path absolute and remove dots.  This path
1778       // will eventually be written into the PE header, and certain Microsoft
1779       // tools won't work correctly if these assumptions are not held.
1780       sys::fs::make_absolute(config->pdbAltPath);
1781       sys::path::remove_dots(config->pdbAltPath);
1782     } else {
1783       // Don't do this earlier, so that Config->OutputFile is ready.
1784       parsePDBAltPath(config->pdbAltPath);
1785     }
1786   }
1787
1788   // Set default image base if /base is not given.
1789   if (config->imageBase == uint64_t(-1))
1790     config->imageBase = getDefaultImageBase();
1791
1792   symtab->addSynthetic(mangle("__ImageBase"), nullptr);
1793   if (config->machine == I386) {
1794     symtab->addAbsolute("___safe_se_handler_table", 0);
1795     symtab->addAbsolute("___safe_se_handler_count", 0);
1796   }
1797
1798   symtab->addAbsolute(mangle("__guard_fids_count"), 0);
1799   symtab->addAbsolute(mangle("__guard_fids_table"), 0);
1800   symtab->addAbsolute(mangle("__guard_flags"), 0);
1801   symtab->addAbsolute(mangle("__guard_iat_count"), 0);
1802   symtab->addAbsolute(mangle("__guard_iat_table"), 0);
1803   symtab->addAbsolute(mangle("__guard_longjmp_count"), 0);
1804   symtab->addAbsolute(mangle("__guard_longjmp_table"), 0);
1805   // Needed for MSVC 2017 15.5 CRT.
1806   symtab->addAbsolute(mangle("__enclave_config"), 0);
1807
1808   if (config->mingw) {
1809     symtab->addAbsolute(mangle("__RUNTIME_PSEUDO_RELOC_LIST__"), 0);
1810     symtab->addAbsolute(mangle("__RUNTIME_PSEUDO_RELOC_LIST_END__"), 0);
1811     symtab->addAbsolute(mangle("__CTOR_LIST__"), 0);
1812     symtab->addAbsolute(mangle("__DTOR_LIST__"), 0);
1813   }
1814
1815   // This code may add new undefined symbols to the link, which may enqueue more
1816   // symbol resolution tasks, so we need to continue executing tasks until we
1817   // converge.
1818   do {
1819     // Windows specific -- if entry point is not found,
1820     // search for its mangled names.
1821     if (config->entry)
1822       mangleMaybe(config->entry);
1823
1824     // Windows specific -- Make sure we resolve all dllexported symbols.
1825     for (Export &e : config->exports) {
1826       if (!e.forwardTo.empty())
1827         continue;
1828       e.sym = addUndefined(e.name);
1829       if (!e.directives)
1830         e.symbolName = mangleMaybe(e.sym);
1831     }
1832
1833     // Add weak aliases. Weak aliases is a mechanism to give remaining
1834     // undefined symbols final chance to be resolved successfully.
1835     for (auto pair : config->alternateNames) {
1836       StringRef from = pair.first;
1837       StringRef to = pair.second;
1838       Symbol *sym = symtab->find(from);
1839       if (!sym)
1840         continue;
1841       if (auto *u = dyn_cast<Undefined>(sym))
1842         if (!u->weakAlias)
1843           u->weakAlias = symtab->addUndefined(to);
1844     }
1845
1846     // If any inputs are bitcode files, the LTO code generator may create
1847     // references to library functions that are not explicit in the bitcode
1848     // file's symbol table. If any of those library functions are defined in a
1849     // bitcode file in an archive member, we need to arrange to use LTO to
1850     // compile those archive members by adding them to the link beforehand.
1851     if (!BitcodeFile::instances.empty())
1852       for (auto *s : lto::LTO::getRuntimeLibcallSymbols())
1853         symtab->addLibcall(s);
1854
1855     // Windows specific -- if __load_config_used can be resolved, resolve it.
1856     if (symtab->findUnderscore("_load_config_used"))
1857       addUndefined(mangle("_load_config_used"));
1858   } while (run());
1859
1860   if (args.hasArg(OPT_include_optional)) {
1861     // Handle /includeoptional
1862     for (auto *arg : args.filtered(OPT_include_optional))
1863       if (dyn_cast_or_null<LazyArchive>(symtab->find(arg->getValue())))
1864         addUndefined(arg->getValue());
1865     while (run());
1866   }
1867
1868   if (config->mingw) {
1869     // Load any further object files that might be needed for doing automatic
1870     // imports.
1871     //
1872     // For cases with no automatically imported symbols, this iterates once
1873     // over the symbol table and doesn't do anything.
1874     //
1875     // For the normal case with a few automatically imported symbols, this
1876     // should only need to be run once, since each new object file imported
1877     // is an import library and wouldn't add any new undefined references,
1878     // but there's nothing stopping the __imp_ symbols from coming from a
1879     // normal object file as well (although that won't be used for the
1880     // actual autoimport later on). If this pass adds new undefined references,
1881     // we won't iterate further to resolve them.
1882     symtab->loadMinGWAutomaticImports();
1883     run();
1884   }
1885
1886   // At this point, we should not have any symbols that cannot be resolved.
1887   // If we are going to do codegen for link-time optimization, check for
1888   // unresolvable symbols first, so we don't spend time generating code that
1889   // will fail to link anyway.
1890   if (!BitcodeFile::instances.empty() && !config->forceUnresolved)
1891     symtab->reportUnresolvable();
1892   if (errorCount())
1893     return;
1894
1895   // Do LTO by compiling bitcode input files to a set of native COFF files then
1896   // link those files (unless -thinlto-index-only was given, in which case we
1897   // resolve symbols and write indices, but don't generate native code or link).
1898   symtab->addCombinedLTOObjects();
1899
1900   // If -thinlto-index-only is given, we should create only "index
1901   // files" and not object files. Index file creation is already done
1902   // in addCombinedLTOObject, so we are done if that's the case.
1903   if (config->thinLTOIndexOnly)
1904     return;
1905
1906   // If we generated native object files from bitcode files, this resolves
1907   // references to the symbols we use from them.
1908   run();
1909
1910   // Resolve remaining undefined symbols and warn about imported locals.
1911   symtab->resolveRemainingUndefines();
1912   if (errorCount())
1913     return;
1914
1915   config->hadExplicitExports = !config->exports.empty();
1916   if (config->mingw) {
1917     // In MinGW, all symbols are automatically exported if no symbols
1918     // are chosen to be exported.
1919     maybeExportMinGWSymbols(args);
1920
1921     // Make sure the crtend.o object is the last object file. This object
1922     // file can contain terminating section chunks that need to be placed
1923     // last. GNU ld processes files and static libraries explicitly in the
1924     // order provided on the command line, while lld will pull in needed
1925     // files from static libraries only after the last object file on the
1926     // command line.
1927     for (auto i = ObjFile::instances.begin(), e = ObjFile::instances.end();
1928          i != e; i++) {
1929       ObjFile *file = *i;
1930       if (isCrtend(file->getName())) {
1931         ObjFile::instances.erase(i);
1932         ObjFile::instances.push_back(file);
1933         break;
1934       }
1935     }
1936   }
1937
1938   // Windows specific -- when we are creating a .dll file, we also
1939   // need to create a .lib file. In MinGW mode, we only do that when the
1940   // -implib option is given explicitly, for compatibility with GNU ld.
1941   if (!config->exports.empty() || config->dll) {
1942     fixupExports();
1943     if (!config->mingw || !config->implib.empty())
1944       createImportLibrary(/*asLib=*/false);
1945     assignExportOrdinals();
1946   }
1947
1948   // Handle /output-def (MinGW specific).
1949   if (auto *arg = args.getLastArg(OPT_output_def))
1950     writeDefFile(arg->getValue());
1951
1952   // Set extra alignment for .comm symbols
1953   for (auto pair : config->alignComm) {
1954     StringRef name = pair.first;
1955     uint32_t alignment = pair.second;
1956
1957     Symbol *sym = symtab->find(name);
1958     if (!sym) {
1959       warn("/aligncomm symbol " + name + " not found");
1960       continue;
1961     }
1962
1963     // If the symbol isn't common, it must have been replaced with a regular
1964     // symbol, which will carry its own alignment.
1965     auto *dc = dyn_cast<DefinedCommon>(sym);
1966     if (!dc)
1967       continue;
1968
1969     CommonChunk *c = dc->getChunk();
1970     c->setAlignment(std::max(c->getAlignment(), alignment));
1971   }
1972
1973   // Windows specific -- Create a side-by-side manifest file.
1974   if (config->manifest == Configuration::SideBySide)
1975     createSideBySideManifest();
1976
1977   // Handle /order. We want to do this at this moment because we
1978   // need a complete list of comdat sections to warn on nonexistent
1979   // functions.
1980   if (auto *arg = args.getLastArg(OPT_order))
1981     parseOrderFile(arg->getValue());
1982
1983   // Identify unreferenced COMDAT sections.
1984   if (config->doGC)
1985     markLive(symtab->getChunks());
1986
1987   // Needs to happen after the last call to addFile().
1988   convertResources();
1989
1990   // Identify identical COMDAT sections to merge them.
1991   if (config->doICF) {
1992     findKeepUniqueSections();
1993     doICF(symtab->getChunks());
1994   }
1995
1996   // Write the result.
1997   writeResult();
1998
1999   // Stop early so we can print the results.
2000   Timer::root().stop();
2001   if (config->showTiming)
2002     Timer::root().print();
2003 }
2004
2005 } // namespace coff
2006 } // namespace lld