1 //===- Driver.cpp ---------------------------------------------------------===//
2 //
3 //                             The LLVM Linker
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #include "Config.h"
11 #include "Driver.h"
12 #include "Error.h"
13 #include "InputFiles.h"
14 #include "SymbolTable.h"
15 #include "Symbols.h"
16 #include "Writer.h"
17 #include "lld/Driver/Driver.h"
18 #include "llvm/ADT/Optional.h"
19 #include "llvm/LibDriver/LibDriver.h"
20 #include "llvm/Option/Arg.h"
21 #include "llvm/Option/ArgList.h"
22 #include "llvm/Option/Option.h"
23 #include "llvm/Support/Debug.h"
24 #include "llvm/Support/Path.h"
25 #include "llvm/Support/Process.h"
26 #include "llvm/Support/TargetSelect.h"
27 #include "llvm/Support/raw_ostream.h"
28 #include <algorithm>
29 #include <memory>
30 
31 using namespace llvm;
32 using namespace llvm::COFF;
33 using llvm::sys::Process;
34 using llvm::sys::fs::OpenFlags;
35 using llvm::sys::fs::file_magic;
36 using llvm::sys::fs::identify_magic;
37 
38 namespace lld {
39 namespace coff {
40 
41 Configuration *Config;
42 LinkerDriver *Driver;
43 
44 bool link(llvm::ArrayRef<const char *> Args) {
45   Configuration C;
46   LinkerDriver D;
47   Config = &C;
48   Driver = &D;
49   Driver->link(Args);
50   return true;
51 }
52 
53 // Drop directory components and replace extension with ".exe" or ".dll".
54 static std::string getOutputPath(StringRef Path) {
55   auto P = Path.find_last_of("\\/");
56   StringRef S = (P == StringRef::npos) ? Path : Path.substr(P + 1);
57   const char* E = Config->DLL ? ".dll" : ".exe";
58   return (S.substr(0, S.rfind('.')) + E).str();
59 }
60 
61 // Opens a file. Path has to be resolved already.
62 // Newly created memory buffers are owned by this driver.
63 MemoryBufferRef LinkerDriver::openFile(StringRef Path) {
64   std::unique_ptr<MemoryBuffer> MB =
65       check(MemoryBuffer::getFile(Path), "could not open " + Path);
66   MemoryBufferRef MBRef = MB->getMemBufferRef();
67   OwningMBs.push_back(std::move(MB)); // take ownership
68   return MBRef;
69 }
70 
71 static std::unique_ptr<InputFile> createFile(MemoryBufferRef MB) {
72   // File type is detected by contents, not by file extension.
73   file_magic Magic = identify_magic(MB.getBuffer());
74   if (Magic == file_magic::archive)
75     return std::unique_ptr<InputFile>(new ArchiveFile(MB));
76   if (Magic == file_magic::bitcode)
77     return std::unique_ptr<InputFile>(new BitcodeFile(MB));
78   if (Config->OutputFile == "")
79     Config->OutputFile = getOutputPath(MB.getBufferIdentifier());
80   return std::unique_ptr<InputFile>(new ObjectFile(MB));
81 }
82 
83 static bool isDecorated(StringRef Sym) {
84   return Sym.startswith("_") || Sym.startswith("@") || Sym.startswith("?");
85 }
86 
87 // Parses .drectve section contents and returns a list of files
88 // specified by /defaultlib.
89 void LinkerDriver::parseDirectives(StringRef S) {
90   llvm::opt::InputArgList Args = Parser.parse(S);
91 
92   for (auto *Arg : Args) {
93     switch (Arg->getOption().getID()) {
94     case OPT_alternatename:
95       parseAlternateName(Arg->getValue());
96       break;
97     case OPT_defaultlib:
98       if (Optional<StringRef> Path = findLib(Arg->getValue())) {
99         MemoryBufferRef MB = openFile(*Path);
100         Symtab.addFile(createFile(MB));
101       }
102       break;
103     case OPT_export: {
104       Export E = parseExport(Arg->getValue());
105       E.Directives = true;
106       Config->Exports.push_back(E);
107       break;
108     }
109     case OPT_failifmismatch:
110       checkFailIfMismatch(Arg->getValue());
111       break;
112     case OPT_incl:
113       addUndefined(Arg->getValue());
114       break;
115     case OPT_merge:
116       parseMerge(Arg->getValue());
117       break;
118     case OPT_nodefaultlib:
119       Config->NoDefaultLibs.insert(doFindLib(Arg->getValue()));
120       break;
121     case OPT_section:
122       parseSection(Arg->getValue());
123       break;
124     case OPT_editandcontinue:
125     case OPT_fastfail:
126     case OPT_guardsym:
127     case OPT_throwingnew:
128       break;
129     default:
130       fatal(Arg->getSpelling() + " is not allowed in .drectve");
131     }
132   }
133 }
134 
135 // Find file from search paths. You can omit ".obj", this function takes
136 // care of that. Note that the returned path is not guaranteed to exist.
137 StringRef LinkerDriver::doFindFile(StringRef Filename) {
138   bool hasPathSep = (Filename.find_first_of("/\\") != StringRef::npos);
139   if (hasPathSep)
140     return Filename;
141   bool hasExt = (Filename.find('.') != StringRef::npos);
142   for (StringRef Dir : SearchPaths) {
143     SmallString<128> Path = Dir;
144     llvm::sys::path::append(Path, Filename);
145     if (llvm::sys::fs::exists(Path.str()))
146       return Alloc.save(Path.str());
147     if (!hasExt) {
148       Path.append(".obj");
149       if (llvm::sys::fs::exists(Path.str()))
150         return Alloc.save(Path.str());
151     }
152   }
153   return Filename;
154 }
155 
156 // Resolves a file path. This never returns the same path
157 // (in that case, it returns None).
158 Optional<StringRef> LinkerDriver::findFile(StringRef Filename) {
159   StringRef Path = doFindFile(Filename);
160   bool Seen = !VisitedFiles.insert(Path.lower()).second;
161   if (Seen)
162     return None;
163   return Path;
164 }
165 
166 // Find library file from search path.
167 StringRef LinkerDriver::doFindLib(StringRef Filename) {
168   // Add ".lib" to Filename if that has no file extension.
169   bool hasExt = (Filename.find('.') != StringRef::npos);
170   if (!hasExt)
171     Filename = Alloc.save(Filename + ".lib");
172   return doFindFile(Filename);
173 }
174 
175 // Resolves a library path. /nodefaultlib options are taken into
176 // consideration. This never returns the same path (in that case,
177 // it returns None).
178 Optional<StringRef> LinkerDriver::findLib(StringRef Filename) {
179   if (Config->NoDefaultLibAll)
180     return None;
181   StringRef Path = doFindLib(Filename);
182   if (Config->NoDefaultLibs.count(Path))
183     return None;
184   bool Seen = !VisitedFiles.insert(Path.lower()).second;
185   if (Seen)
186     return None;
187   return Path;
188 }
189 
190 // Parses LIB environment which contains a list of search paths.
191 void LinkerDriver::addLibSearchPaths() {
192   Optional<std::string> EnvOpt = Process::GetEnv("LIB");
193   if (!EnvOpt.hasValue())
194     return;
195   StringRef Env = Alloc.save(*EnvOpt);
196   while (!Env.empty()) {
197     StringRef Path;
198     std::tie(Path, Env) = Env.split(';');
199     SearchPaths.push_back(Path);
200   }
201 }
202 
203 Undefined *LinkerDriver::addUndefined(StringRef Name) {
204   Undefined *U = Symtab.addUndefined(Name);
205   Config->GCRoot.insert(U);
206   return U;
207 }
208 
209 // Symbol names are mangled by appending "_" prefix on x86.
210 StringRef LinkerDriver::mangle(StringRef Sym) {
211   assert(Config->Machine != IMAGE_FILE_MACHINE_UNKNOWN);
212   if (Config->Machine == I386)
213     return Alloc.save("_" + Sym);
214   return Sym;
215 }
216 
217 // Windows specific -- find default entry point name.
218 StringRef LinkerDriver::findDefaultEntry() {
219   // User-defined main functions and their corresponding entry points.
220   static const char *Entries[][2] = {
221       {"main", "mainCRTStartup"},
222       {"wmain", "wmainCRTStartup"},
223       {"WinMain", "WinMainCRTStartup"},
224       {"wWinMain", "wWinMainCRTStartup"},
225   };
226   for (auto E : Entries) {
227     StringRef Entry = Symtab.findMangle(mangle(E[0]));
228     if (!Entry.empty() && !isa<Undefined>(Symtab.find(Entry)->Body))
229       return mangle(E[1]);
230   }
231   return "";
232 }
233 
234 WindowsSubsystem LinkerDriver::inferSubsystem() {
235   if (Config->DLL)
236     return IMAGE_SUBSYSTEM_WINDOWS_GUI;
237   if (Symtab.findUnderscore("main") || Symtab.findUnderscore("wmain"))
238     return IMAGE_SUBSYSTEM_WINDOWS_CUI;
239   if (Symtab.findUnderscore("WinMain") || Symtab.findUnderscore("wWinMain"))
240     return IMAGE_SUBSYSTEM_WINDOWS_GUI;
241   return IMAGE_SUBSYSTEM_UNKNOWN;
242 }
243 
244 static uint64_t getDefaultImageBase() {
245   if (Config->is64())
246     return Config->DLL ? 0x180000000 : 0x140000000;
247   return Config->DLL ? 0x10000000 : 0x400000;
248 }
249 
250 void LinkerDriver::link(llvm::ArrayRef<const char *> ArgsArr) {
251   // If the first command line argument is "/lib", link.exe acts like lib.exe.
252   // We call our own implementation of lib.exe that understands bitcode files.
253   if (ArgsArr.size() > 1 && StringRef(ArgsArr[1]).equals_lower("/lib")) {
254     if (llvm::libDriverMain(ArgsArr.slice(1)) != 0)
255       fatal("lib failed");
256     return;
257   }
258 
259   // Needed for LTO.
260   llvm::InitializeAllTargetInfos();
261   llvm::InitializeAllTargets();
262   llvm::InitializeAllTargetMCs();
263   llvm::InitializeAllAsmParsers();
264   llvm::InitializeAllAsmPrinters();
265   llvm::InitializeAllDisassemblers();
266 
267   // Parse command line options.
268   llvm::opt::InputArgList Args = Parser.parseLINK(ArgsArr.slice(1));
269 
270   // Handle /help
271   if (Args.hasArg(OPT_help)) {
272     printHelp(ArgsArr[0]);
273     return;
274   }
275 
276   if (Args.filtered_begin(OPT_INPUT) == Args.filtered_end())
277     fatal("no input files");
278 
279   // Construct search path list.
280   SearchPaths.push_back("");
281   for (auto *Arg : Args.filtered(OPT_libpath))
282     SearchPaths.push_back(Arg->getValue());
283   addLibSearchPaths();
284 
285   // Handle /out
286   if (auto *Arg = Args.getLastArg(OPT_out))
287     Config->OutputFile = Arg->getValue();
288 
289   // Handle /verbose
290   if (Args.hasArg(OPT_verbose))
291     Config->Verbose = true;
292 
293   // Handle /force or /force:unresolved
294   if (Args.hasArg(OPT_force) || Args.hasArg(OPT_force_unresolved))
295     Config->Force = true;
296 
297   // Handle /debug
298   if (Args.hasArg(OPT_debug))
299     Config->Debug = true;
300 
301   // Handle /noentry
302   if (Args.hasArg(OPT_noentry)) {
303     if (!Args.hasArg(OPT_dll))
304       fatal("/noentry must be specified with /dll");
305     Config->NoEntry = true;
306   }
307 
308   // Handle /dll
309   if (Args.hasArg(OPT_dll)) {
310     Config->DLL = true;
311     Config->ManifestID = 2;
312   }
313 
314   // Handle /fixed
315   if (Args.hasArg(OPT_fixed)) {
316     if (Args.hasArg(OPT_dynamicbase))
317       fatal("/fixed must not be specified with /dynamicbase");
318     Config->Relocatable = false;
319     Config->DynamicBase = false;
320   }
321 
322   // Handle /machine
323   if (auto *Arg = Args.getLastArg(OPT_machine))
324     Config->Machine = getMachineType(Arg->getValue());
325 
326   // Handle /nodefaultlib:<filename>
327   for (auto *Arg : Args.filtered(OPT_nodefaultlib))
328     Config->NoDefaultLibs.insert(doFindLib(Arg->getValue()));
329 
330   // Handle /nodefaultlib
331   if (Args.hasArg(OPT_nodefaultlib_all))
332     Config->NoDefaultLibAll = true;
333 
334   // Handle /base
335   if (auto *Arg = Args.getLastArg(OPT_base))
336     parseNumbers(Arg->getValue(), &Config->ImageBase);
337 
338   // Handle /stack
339   if (auto *Arg = Args.getLastArg(OPT_stack))
340     parseNumbers(Arg->getValue(), &Config->StackReserve, &Config->StackCommit);
341 
342   // Handle /heap
343   if (auto *Arg = Args.getLastArg(OPT_heap))
344     parseNumbers(Arg->getValue(), &Config->HeapReserve, &Config->HeapCommit);
345 
346   // Handle /version
347   if (auto *Arg = Args.getLastArg(OPT_version))
348     parseVersion(Arg->getValue(), &Config->MajorImageVersion,
349                  &Config->MinorImageVersion);
350 
351   // Handle /subsystem
352   if (auto *Arg = Args.getLastArg(OPT_subsystem))
353     parseSubsystem(Arg->getValue(), &Config->Subsystem, &Config->MajorOSVersion,
354                    &Config->MinorOSVersion);
355 
356   // Handle /alternatename
357   for (auto *Arg : Args.filtered(OPT_alternatename))
358     parseAlternateName(Arg->getValue());
359 
360   // Handle /include
361   for (auto *Arg : Args.filtered(OPT_incl))
362     addUndefined(Arg->getValue());
363 
364   // Handle /implib
365   if (auto *Arg = Args.getLastArg(OPT_implib))
366     Config->Implib = Arg->getValue();
367 
368   // Handle /opt
369   for (auto *Arg : Args.filtered(OPT_opt)) {
370     std::string Str = StringRef(Arg->getValue()).lower();
371     SmallVector<StringRef, 1> Vec;
372     StringRef(Str).split(Vec, ',');
373     for (StringRef S : Vec) {
374       if (S == "noref") {
375         Config->DoGC = false;
376         Config->DoICF = false;
377         continue;
378       }
379       if (S == "icf" || StringRef(S).startswith("icf=")) {
380         Config->DoICF = true;
381         continue;
382       }
383       if (S == "noicf") {
384         Config->DoICF = false;
385         continue;
386       }
387       if (StringRef(S).startswith("lldlto=")) {
388         StringRef OptLevel = StringRef(S).substr(7);
389         if (OptLevel.getAsInteger(10, Config->LTOOptLevel) ||
390             Config->LTOOptLevel > 3)
391           fatal("/opt:lldlto: invalid optimization level: " + OptLevel);
392         continue;
393       }
394       if (StringRef(S).startswith("lldltojobs=")) {
395         StringRef Jobs = StringRef(S).substr(11);
396         if (Jobs.getAsInteger(10, Config->LTOJobs) || Config->LTOJobs == 0)
397           fatal("/opt:lldltojobs: invalid job count: " + Jobs);
398         continue;
399       }
400       if (S != "ref" && S != "lbr" && S != "nolbr")
401         fatal("/opt: unknown option: " + S);
402     }
403   }
404 
405   // Handle /failifmismatch
406   for (auto *Arg : Args.filtered(OPT_failifmismatch))
407     checkFailIfMismatch(Arg->getValue());
408 
409   // Handle /merge
410   for (auto *Arg : Args.filtered(OPT_merge))
411     parseMerge(Arg->getValue());
412 
413   // Handle /section
414   for (auto *Arg : Args.filtered(OPT_section))
415     parseSection(Arg->getValue());
416 
417   // Handle /manifest
418   if (auto *Arg = Args.getLastArg(OPT_manifest_colon))
419     parseManifest(Arg->getValue());
420 
421   // Handle /manifestuac
422   if (auto *Arg = Args.getLastArg(OPT_manifestuac))
423     parseManifestUAC(Arg->getValue());
424 
425   // Handle /manifestdependency
426   if (auto *Arg = Args.getLastArg(OPT_manifestdependency))
427     Config->ManifestDependency = Arg->getValue();
428 
429   // Handle /manifestfile
430   if (auto *Arg = Args.getLastArg(OPT_manifestfile))
431     Config->ManifestFile = Arg->getValue();
432 
433   // Handle /manifestinput
434   for (auto *Arg : Args.filtered(OPT_manifestinput))
435     Config->ManifestInput.push_back(Arg->getValue());
436 
437   // Handle miscellaneous boolean flags.
438   if (Args.hasArg(OPT_allowbind_no))
439     Config->AllowBind = false;
440   if (Args.hasArg(OPT_allowisolation_no))
441     Config->AllowIsolation = false;
442   if (Args.hasArg(OPT_dynamicbase_no))
443     Config->DynamicBase = false;
444   if (Args.hasArg(OPT_nxcompat_no))
445     Config->NxCompat = false;
446   if (Args.hasArg(OPT_tsaware_no))
447     Config->TerminalServerAware = false;
448   if (Args.hasArg(OPT_nosymtab))
449     Config->WriteSymtab = false;
450 
451   // Create a list of input files. Files can be given as arguments
452   // for /defaultlib option.
453   std::vector<StringRef> Paths;
454   std::vector<MemoryBufferRef> MBs;
455   for (auto *Arg : Args.filtered(OPT_INPUT))
456     if (Optional<StringRef> Path = findFile(Arg->getValue()))
457       Paths.push_back(*Path);
458   for (auto *Arg : Args.filtered(OPT_defaultlib))
459     if (Optional<StringRef> Path = findLib(Arg->getValue()))
460       Paths.push_back(*Path);
461   for (StringRef Path : Paths)
462     MBs.push_back(openFile(Path));
463 
464   // Windows specific -- Create a resource file containing a manifest file.
465   if (Config->Manifest == Configuration::Embed) {
466     std::unique_ptr<MemoryBuffer> MB = createManifestRes();
467     MBs.push_back(MB->getMemBufferRef());
468     OwningMBs.push_back(std::move(MB)); // take ownership
469   }
470 
471   // Windows specific -- Input files can be Windows resource files (.res files).
472   // We invoke cvtres.exe to convert resource files to a regular COFF file
473   // then link the result file normally.
474   std::vector<MemoryBufferRef> Resources;
475   auto NotResource = [](MemoryBufferRef MB) {
476     return identify_magic(MB.getBuffer()) != file_magic::windows_resource;
477   };
478   auto It = std::stable_partition(MBs.begin(), MBs.end(), NotResource);
479   if (It != MBs.end()) {
480     Resources.insert(Resources.end(), It, MBs.end());
481     MBs.erase(It, MBs.end());
482   }
483 
484   // Read all input files given via the command line. Note that step()
485   // doesn't read files that are specified by directive sections.
486   for (MemoryBufferRef MB : MBs)
487     Symtab.addFile(createFile(MB));
488   Symtab.step();
489 
490   // Determine machine type and check if all object files are
491   // for the same CPU type. Note that this needs to be done before
492   // any call to mangle().
493   for (std::unique_ptr<InputFile> &File : Symtab.getFiles()) {
494     MachineTypes MT = File->getMachineType();
495     if (MT == IMAGE_FILE_MACHINE_UNKNOWN)
496       continue;
497     if (Config->Machine == IMAGE_FILE_MACHINE_UNKNOWN) {
498       Config->Machine = MT;
499       continue;
500     }
501     if (Config->Machine != MT)
502       fatal(File->getShortName() + ": machine type " + machineToStr(MT) +
503             " conflicts with " + machineToStr(Config->Machine));
504   }
505   if (Config->Machine == IMAGE_FILE_MACHINE_UNKNOWN) {
506     llvm::errs() << "warning: /machine is not specified. x64 is assumed.\n";
507     Config->Machine = AMD64;
508   }
509 
510   // Windows specific -- Convert Windows resource files to a COFF file.
511   if (!Resources.empty()) {
512     std::unique_ptr<MemoryBuffer> MB = convertResToCOFF(Resources);
513     Symtab.addFile(createFile(MB->getMemBufferRef()));
514     OwningMBs.push_back(std::move(MB)); // take ownership
515   }
516 
517   // Handle /largeaddressaware
518   if (Config->is64() || Args.hasArg(OPT_largeaddressaware))
519     Config->LargeAddressAware = true;
520 
521   // Handle /highentropyva
522   if (Config->is64() && !Args.hasArg(OPT_highentropyva_no))
523     Config->HighEntropyVA = true;
524 
525   // Handle /entry and /dll
526   if (auto *Arg = Args.getLastArg(OPT_entry)) {
527     Config->Entry = addUndefined(mangle(Arg->getValue()));
528   } else if (Args.hasArg(OPT_dll) && !Config->NoEntry) {
529     StringRef S = (Config->Machine == I386) ? "__DllMainCRTStartup@12"
530                                             : "_DllMainCRTStartup";
531     Config->Entry = addUndefined(S);
532   } else if (!Config->NoEntry) {
533     // Windows specific -- If entry point name is not given, we need to
534     // infer that from user-defined entry name.
535     StringRef S = findDefaultEntry();
536     if (S.empty())
537       fatal("entry point must be defined");
538     Config->Entry = addUndefined(S);
539     if (Config->Verbose)
540       llvm::outs() << "Entry name inferred: " << S << "\n";
541   }
542 
543   // Handle /export
544   for (auto *Arg : Args.filtered(OPT_export)) {
545     Export E = parseExport(Arg->getValue());
546     if (Config->Machine == I386) {
547       if (!isDecorated(E.Name))
548         E.Name = Alloc.save("_" + E.Name);
549       if (!E.ExtName.empty() && !isDecorated(E.ExtName))
550         E.ExtName = Alloc.save("_" + E.ExtName);
551     }
552     Config->Exports.push_back(E);
553   }
554 
555   // Handle /def
556   if (auto *Arg = Args.getLastArg(OPT_deffile)) {
557     MemoryBufferRef MB = openFile(Arg->getValue());
558     // parseModuleDefs mutates Config object.
559     parseModuleDefs(MB, &Alloc);
560   }
561 
562   // Handle /delayload
563   for (auto *Arg : Args.filtered(OPT_delayload)) {
564     Config->DelayLoads.insert(StringRef(Arg->getValue()).lower());
565     if (Config->Machine == I386) {
566       Config->DelayLoadHelper = addUndefined("___delayLoadHelper2@8");
567     } else {
568       Config->DelayLoadHelper = addUndefined("__delayLoadHelper2");
569     }
570   }
571 
572   // Set default image base if /base is not given.
573   if (Config->ImageBase == uint64_t(-1))
574     Config->ImageBase = getDefaultImageBase();
575 
576   Symtab.addRelative(mangle("__ImageBase"), 0);
577   if (Config->Machine == I386) {
578     Config->SEHTable = Symtab.addRelative("___safe_se_handler_table", 0);
579     Config->SEHCount = Symtab.addAbsolute("___safe_se_handler_count", 0);
580   }
581 
582   // We do not support /guard:cf (control flow protection) yet.
583   // Define CFG symbols anyway so that we can link MSVC 2015 CRT.
584   Symtab.addAbsolute(mangle("__guard_fids_table"), 0);
585   Symtab.addAbsolute(mangle("__guard_fids_count"), 0);
586   Symtab.addAbsolute(mangle("__guard_flags"), 0x100);
587 
588   // Read as much files as we can from directives sections.
589   Symtab.run();
590 
591   // Resolve auxiliary symbols until we get a convergence.
592   // (Trying to resolve a symbol may trigger a Lazy symbol to load a new file.
593   // A new file may contain a directive section to add new command line options.
594   // That's why we have to repeat until converge.)
595   for (;;) {
596     // Windows specific -- if entry point is not found,
597     // search for its mangled names.
598     if (Config->Entry)
599       Symtab.mangleMaybe(Config->Entry);
600 
601     // Windows specific -- Make sure we resolve all dllexported symbols.
602     for (Export &E : Config->Exports) {
603       if (!E.ForwardTo.empty())
604         continue;
605       E.Sym = addUndefined(E.Name);
606       if (!E.Directives)
607         Symtab.mangleMaybe(E.Sym);
608     }
609 
610     // Add weak aliases. Weak aliases is a mechanism to give remaining
611     // undefined symbols final chance to be resolved successfully.
612     for (auto Pair : Config->AlternateNames) {
613       StringRef From = Pair.first;
614       StringRef To = Pair.second;
615       Symbol *Sym = Symtab.find(From);
616       if (!Sym)
617         continue;
618       if (auto *U = dyn_cast<Undefined>(Sym->Body))
619         if (!U->WeakAlias)
620           U->WeakAlias = Symtab.addUndefined(To);
621     }
622 
623     // Windows specific -- if __load_config_used can be resolved, resolve it.
624     if (Symtab.findUnderscore("_load_config_used"))
625       addUndefined(mangle("_load_config_used"));
626 
627     if (Symtab.queueEmpty())
628       break;
629     Symtab.run();
630   }
631 
632   // Do LTO by compiling bitcode input files to a set of native COFF files then
633   // link those files.
634   Symtab.addCombinedLTOObjects();
635 
636   // Make sure we have resolved all symbols.
637   Symtab.reportRemainingUndefines(/*Resolve=*/true);
638 
639   // Windows specific -- if no /subsystem is given, we need to infer
640   // that from entry point name.
641   if (Config->Subsystem == IMAGE_SUBSYSTEM_UNKNOWN) {
642     Config->Subsystem = inferSubsystem();
643     if (Config->Subsystem == IMAGE_SUBSYSTEM_UNKNOWN)
644       fatal("subsystem must be defined");
645   }
646 
647   // Handle /safeseh.
648   if (Args.hasArg(OPT_safeseh))
649     for (ObjectFile *File : Symtab.ObjectFiles)
650       if (!File->SEHCompat)
651         fatal("/safeseh: " + File->getName() + " is not compatible with SEH");
652 
653   // Windows specific -- when we are creating a .dll file, we also
654   // need to create a .lib file.
655   if (!Config->Exports.empty() || Config->DLL) {
656     fixupExports();
657     writeImportLibrary();
658     assignExportOrdinals();
659   }
660 
661   // Windows specific -- Create a side-by-side manifest file.
662   if (Config->Manifest == Configuration::SideBySide)
663     createSideBySideManifest();
664 
665   // Create a dummy PDB file to satisfy build sytem rules.
666   if (auto *Arg = Args.getLastArg(OPT_pdb))
667     createPDB(Arg->getValue());
668 
669   // Identify unreferenced COMDAT sections.
670   if (Config->DoGC)
671     markLive(Symtab.getChunks());
672 
673   // Identify identical COMDAT sections to merge them.
674   if (Config->DoICF)
675     doICF(Symtab.getChunks());
676 
677   // Write the result.
678   writeResult(&Symtab);
679 
680   // Create a symbol map file containing symbol VAs and their names
681   // to help debugging.
682   if (auto *Arg = Args.getLastArg(OPT_lldmap)) {
683     std::error_code EC;
684     llvm::raw_fd_ostream Out(Arg->getValue(), EC, OpenFlags::F_Text);
685     if (EC)
686       fatal(EC, "could not create the symbol map");
687     Symtab.printMap(Out);
688   }
689   // Call exit to avoid calling destructors.
690   exit(0);
691 }
692 
693 } // namespace coff
694 } // namespace lld
695