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
link(ArrayRef<const char * > args,bool canExitEarly,raw_ostream & stdoutOS,raw_ostream & stderrOS)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".
getOldNewOptions(opt::InputArgList & args,unsigned id)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".
getOutputPath(StringRef path)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$/.
isCrtend(StringRef s)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.
createFutureForFile(std::string path)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.
mangle(StringRef sym)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
findUnderscoreMangle(StringRef sym)166 static bool findUnderscoreMangle(StringRef sym) {
167 Symbol *s = symtab->findMangle(mangle(sym));
168 return s && !isa<Undefined>(s);
169 }
170
takeBuffer(std::unique_ptr<MemoryBuffer> mb)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
addBuffer(std::unique_ptr<MemoryBuffer> mb,bool wholeArchive,bool lazy)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
enqueuePath(StringRef path,bool wholeArchive,bool lazy)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
addArchiveBuffer(MemoryBufferRef mb,StringRef symName,StringRef parentName,uint64_t offsetInArchive)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
enqueueArchiveMember(const Archive::Child & c,const Archive::Symbol & sym,StringRef parentName)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
isDecorated(StringRef sym)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.
parseDirectives(InputFile * file)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.
doFindFile(StringRef filename)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
getUniqueID(StringRef path)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).
findFile(StringRef filename)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.
doFindLibMinGW(StringRef filename)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.
doFindLib(StringRef filename)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).
findLib(StringRef filename)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.
addLibSearchPaths()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
addUndefined(StringRef name)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
mangleMaybe(Symbol * s)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.
findDefaultEntry()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
inferSubsystem()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
getDefaultImageBase()599 static uint64_t getDefaultImageBase() {
600 if (config->is64())
601 return config->dll ? 0x180000000 : 0x140000000;
602 return config->dll ? 0x10000000 : 0x400000;
603 }
604
createResponseFile(const opt::InputArgList & args,ArrayRef<StringRef> filePaths,ArrayRef<StringRef> searchPaths)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
parseDebugKind(const opt::InputArgList & args)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
parseDebugTypes(const opt::InputArgList & args)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
getMapFile(const opt::InputArgList & args)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
getImplibPath()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 //
getImportName(bool asLib)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
createImportLibrary(bool asLib)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
parseModuleDefs(StringRef path)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
enqueueTask(std::function<void ()> task)864 void LinkerDriver::enqueueTask(std::function<void()> task) {
865 taskQueue.push_back(std::move(task));
866 }
867
run()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.
parseOrderFile(StringRef arg)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
markAddrsig(Symbol * s)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
findKeepUniqueSections()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.
parsePDBAltPath(StringRef altPath)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.
convertResources()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.
maybeExportMinGWSymbols(const opt::InputArgList & args)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.
getReproduceFile(const opt::InputArgList & args)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
link(ArrayRef<const char * > argsArr)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
2007