blob: e0efb7969819c0771f4f272ee47d9dfec6562d7c [file] [log] [blame]
Rui Ueyama411c63602015-05-28 19:09:30 +00001//===- 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
Rui Ueyama411c63602015-05-28 19:09:30 +000010#include "Driver.h"
Rui Ueyama1d99ab32016-09-15 22:24:51 +000011#include "Config.h"
Rui Ueyama562daa82015-06-18 21:50:38 +000012#include "Error.h"
Rui Ueyama411c63602015-05-28 19:09:30 +000013#include "InputFiles.h"
Rui Ueyama9381eb12016-12-18 14:06:06 +000014#include "Memory.h"
Rui Ueyama411c63602015-05-28 19:09:30 +000015#include "SymbolTable.h"
Rui Ueyama685c41c2015-08-05 23:43:53 +000016#include "Symbols.h"
Rui Ueyama411c63602015-05-28 19:09:30 +000017#include "Writer.h"
Rui Ueyamaa453c0a2016-03-02 19:08:05 +000018#include "lld/Driver/Driver.h"
Rui Ueyama411c63602015-05-28 19:09:30 +000019#include "llvm/ADT/Optional.h"
Saleem Abdulrasoola2cca7e2016-08-08 22:02:44 +000020#include "llvm/ADT/StringSwitch.h"
Zachary Turner264b5d92017-06-07 03:48:56 +000021#include "llvm/BinaryFormat/Magic.h"
Rui Ueyamae1bf1362017-03-16 21:19:36 +000022#include "llvm/Object/ArchiveWriter.h"
Reid Kleckner146eb7a2017-06-02 17:53:06 +000023#include "llvm/Object/COFFImportFile.h"
24#include "llvm/Object/COFFModuleDefinition.h"
Rui Ueyama411c63602015-05-28 19:09:30 +000025#include "llvm/Option/Arg.h"
26#include "llvm/Option/ArgList.h"
27#include "llvm/Option/Option.h"
Rui Ueyama411c63602015-05-28 19:09:30 +000028#include "llvm/Support/Debug.h"
Rui Ueyama411c63602015-05-28 19:09:30 +000029#include "llvm/Support/Path.h"
Rui Ueyama54b71da2015-05-31 19:17:12 +000030#include "llvm/Support/Process.h"
Rui Ueyama7f1f9122017-01-06 02:33:53 +000031#include "llvm/Support/TarWriter.h"
Peter Collingbourne60c16162015-06-01 20:10:10 +000032#include "llvm/Support/TargetSelect.h"
Rui Ueyama411c63602015-05-28 19:09:30 +000033#include "llvm/Support/raw_ostream.h"
Peter Collingbournec6f07c42017-05-13 22:06:46 +000034#include "llvm/ToolDrivers/llvm-lib/LibDriver.h"
Rui Ueyama2bf6a122015-06-14 21:50:50 +000035#include <algorithm>
Rui Ueyama411c63602015-05-28 19:09:30 +000036#include <memory>
37
Peter Collingbourne6ee0b4e2016-12-15 04:02:23 +000038#include <future>
39
Rui Ueyama411c63602015-05-28 19:09:30 +000040using namespace llvm;
Reid Kleckner146eb7a2017-06-02 17:53:06 +000041using namespace llvm::object;
Rui Ueyama84936e02015-07-07 23:39:18 +000042using namespace llvm::COFF;
Rui Ueyama54b71da2015-05-31 19:17:12 +000043using llvm::sys::Process;
Rui Ueyama411c63602015-05-28 19:09:30 +000044
Rui Ueyama3500f662015-05-28 20:30:06 +000045namespace lld {
46namespace coff {
Rui Ueyama411c63602015-05-28 19:09:30 +000047
Rui Ueyama3500f662015-05-28 20:30:06 +000048Configuration *Config;
Rui Ueyamaa9cbbf82015-05-31 19:17:09 +000049LinkerDriver *Driver;
50
Rui Ueyama9381eb12016-12-18 14:06:06 +000051BumpPtrAllocator BAlloc;
52StringSaver Saver{BAlloc};
53std::vector<SpecificAllocBase *> SpecificAllocBase::Instances;
54
Bob Haarman6c8f7362017-01-17 19:07:42 +000055bool link(ArrayRef<const char *> Args, raw_ostream &Diag) {
56 ErrorCount = 0;
57 ErrorOS = &Diag;
Rui Ueyamacbf969e2017-08-28 21:51:07 +000058
Rui Ueyama7fed58c2016-12-08 19:10:28 +000059 Config = make<Configuration>();
Zachary Turner6708e0b2017-07-10 21:01:37 +000060 Config->Argv = {Args.begin(), Args.end()};
Rui Ueyama8bee41e2017-08-24 20:32:58 +000061 Config->ColorDiagnostics = ErrorOS->has_colors();
Rui Ueyamacbf969e2017-08-28 21:51:07 +000062
63 Symtab = make<SymbolTable>();
64
Rui Ueyama7fed58c2016-12-08 19:10:28 +000065 Driver = make<LinkerDriver>();
Rui Ueyama417553d2016-02-28 19:54:51 +000066 Driver->link(Args);
Bob Haarmanac8f7fc2017-04-05 00:43:54 +000067 return !ErrorCount;
Rui Ueyamaa9cbbf82015-05-31 19:17:09 +000068}
Rui Ueyama411c63602015-05-28 19:09:30 +000069
Nico Weber5660de72016-04-20 22:34:15 +000070// Drop directory components and replace extension with ".exe" or ".dll".
Rui Ueyamaad660982015-06-07 00:20:32 +000071static std::string getOutputPath(StringRef Path) {
72 auto P = Path.find_last_of("\\/");
73 StringRef S = (P == StringRef::npos) ? Path : Path.substr(P + 1);
Nico Weber5660de72016-04-20 22:34:15 +000074 const char* E = Config->DLL ? ".dll" : ".exe";
75 return (S.substr(0, S.rfind('.')) + E).str();
Rui Ueyama411c63602015-05-28 19:09:30 +000076}
77
Peter Collingbourne6ee0b4e2016-12-15 04:02:23 +000078// ErrorOr is not default constructible, so it cannot be used as the type
79// parameter of a future.
80// FIXME: We could open the file in createFutureForFile and avoid needing to
81// return an error here, but for the moment that would cost us a file descriptor
82// (a limited resource on Windows) for the duration that the future is pending.
83typedef std::pair<std::unique_ptr<MemoryBuffer>, std::error_code> MBErrPair;
84
85// Create a std::future that opens and maps a file using the best strategy for
86// the host platform.
87static std::future<MBErrPair> createFutureForFile(std::string Path) {
88#if LLVM_ON_WIN32
89 // On Windows, file I/O is relatively slow so it is best to do this
90 // asynchronously.
91 auto Strategy = std::launch::async;
92#else
93 auto Strategy = std::launch::deferred;
94#endif
95 return std::async(Strategy, [=]() {
96 auto MBOrErr = MemoryBuffer::getFile(Path);
97 if (!MBOrErr)
98 return MBErrPair{nullptr, MBOrErr.getError()};
99 return MBErrPair{std::move(*MBOrErr), std::error_code()};
100 });
101}
102
103MemoryBufferRef LinkerDriver::takeBuffer(std::unique_ptr<MemoryBuffer> MB) {
104 MemoryBufferRef MBRef = *MB;
Rui Ueyama01f93332017-05-18 17:03:49 +0000105 make<std::unique_ptr<MemoryBuffer>>(std::move(MB)); // take ownership
Peter Collingbourne6ee0b4e2016-12-15 04:02:23 +0000106
Rui Ueyama7f1f9122017-01-06 02:33:53 +0000107 if (Driver->Tar)
108 Driver->Tar->append(relativeToRoot(MBRef.getBufferIdentifier()),
109 MBRef.getBuffer());
Rui Ueyama2bf6a122015-06-14 21:50:50 +0000110 return MBRef;
111}
Rui Ueyama711cd2d2015-05-31 21:17:10 +0000112
Martin Storsjo8278ba52017-09-13 07:28:03 +0000113void LinkerDriver::addBuffer(std::unique_ptr<MemoryBuffer> MB,
114 bool WholeArchive) {
Peter Collingbourne6ee0b4e2016-12-15 04:02:23 +0000115 MemoryBufferRef MBRef = takeBuffer(std::move(MB));
Peter Collingbournefeee2102016-07-26 02:00:42 +0000116
Rui Ueyama711cd2d2015-05-31 21:17:10 +0000117 // File type is detected by contents, not by file extension.
Peter Collingbourne6ee0b4e2016-12-15 04:02:23 +0000118 file_magic Magic = identify_magic(MBRef.getBuffer());
119 if (Magic == file_magic::windows_resource) {
120 Resources.push_back(MBRef);
121 return;
122 }
123
124 FilePaths.push_back(MBRef.getBufferIdentifier());
Martin Storsjo8278ba52017-09-13 07:28:03 +0000125 if (Magic == file_magic::archive) {
126 if (WholeArchive) {
127 std::unique_ptr<Archive> File =
128 check(Archive::create(MBRef),
129 MBRef.getBufferIdentifier() + ": failed to parse archive");
130
131 for (MemoryBufferRef M : getArchiveMembers(File.get()))
132 addArchiveBuffer(M, "<whole-archive>", MBRef.getBufferIdentifier());
133 return;
134 }
135 Symtab->addFile(make<ArchiveFile>(MBRef));
136 return;
137 }
138
139 if (Magic == file_magic::bitcode) {
140 Symtab->addFile(make<BitcodeFile>(MBRef));
141 return;
142 }
Bob Haarmanac8f7fc2017-04-05 00:43:54 +0000143
Rui Ueyamaf83806a2016-11-15 01:01:51 +0000144 if (Magic == file_magic::coff_cl_gl_object)
Bob Haarmanac8f7fc2017-04-05 00:43:54 +0000145 error(MBRef.getBufferIdentifier() + ": is not a native COFF file. "
Rui Ueyamaf83806a2016-11-15 01:01:51 +0000146 "Recompile without /GL");
Bob Haarmanac8f7fc2017-04-05 00:43:54 +0000147 else
Rui Ueyamacbf969e2017-08-28 21:51:07 +0000148 Symtab->addFile(make<ObjFile>(MBRef));
Peter Collingbourne6ee0b4e2016-12-15 04:02:23 +0000149}
150
Martin Storsjo8278ba52017-09-13 07:28:03 +0000151void LinkerDriver::enqueuePath(StringRef Path, bool WholeArchive) {
Peter Collingbourne6ee0b4e2016-12-15 04:02:23 +0000152 auto Future =
153 std::make_shared<std::future<MBErrPair>>(createFutureForFile(Path));
154 std::string PathStr = Path;
155 enqueueTask([=]() {
156 auto MBOrErr = Future->get();
157 if (MBOrErr.second)
Bob Haarmanac8f7fc2017-04-05 00:43:54 +0000158 error("could not open " + PathStr + ": " + MBOrErr.second.message());
159 else
Martin Storsjo8278ba52017-09-13 07:28:03 +0000160 Driver->addBuffer(std::move(MBOrErr.first), WholeArchive);
Peter Collingbourne6ee0b4e2016-12-15 04:02:23 +0000161 });
Peter Collingbourne6ee0b4e2016-12-15 04:02:23 +0000162}
163
164void LinkerDriver::addArchiveBuffer(MemoryBufferRef MB, StringRef SymName,
165 StringRef ParentName) {
166 file_magic Magic = identify_magic(MB.getBuffer());
167 if (Magic == file_magic::coff_import_library) {
Rui Ueyamacbf969e2017-08-28 21:51:07 +0000168 Symtab->addFile(make<ImportFile>(MB));
Peter Collingbourne6ee0b4e2016-12-15 04:02:23 +0000169 return;
170 }
171
172 InputFile *Obj;
Bob Haarmanac8f7fc2017-04-05 00:43:54 +0000173 if (Magic == file_magic::coff_object) {
Rui Ueyamae1b48e02017-07-26 23:05:24 +0000174 Obj = make<ObjFile>(MB);
Bob Haarmanac8f7fc2017-04-05 00:43:54 +0000175 } else if (Magic == file_magic::bitcode) {
Peter Collingbourne6ee0b4e2016-12-15 04:02:23 +0000176 Obj = make<BitcodeFile>(MB);
Bob Haarmanac8f7fc2017-04-05 00:43:54 +0000177 } else {
178 error("unknown file type: " + MB.getBufferIdentifier());
179 return;
180 }
Peter Collingbourne6ee0b4e2016-12-15 04:02:23 +0000181
182 Obj->ParentName = ParentName;
Rui Ueyamacbf969e2017-08-28 21:51:07 +0000183 Symtab->addFile(Obj);
Rui Ueyamae6e206d2017-02-21 23:22:56 +0000184 log("Loaded " + toString(Obj) + " for " + SymName);
Peter Collingbourne6ee0b4e2016-12-15 04:02:23 +0000185}
186
187void LinkerDriver::enqueueArchiveMember(const Archive::Child &C,
188 StringRef SymName,
189 StringRef ParentName) {
190 if (!C.getParent()->isThin()) {
191 MemoryBufferRef MB = check(
192 C.getMemoryBufferRef(),
193 "could not get the buffer for the member defining symbol " + SymName);
194 enqueueTask([=]() { Driver->addArchiveBuffer(MB, SymName, ParentName); });
195 return;
196 }
197
198 auto Future = std::make_shared<std::future<MBErrPair>>(createFutureForFile(
199 check(C.getFullName(),
200 "could not get the filename for the member defining symbol " +
201 SymName)));
202 enqueueTask([=]() {
203 auto MBOrErr = Future->get();
204 if (MBOrErr.second)
205 fatal(MBOrErr.second,
206 "could not get the buffer for the member defining " + SymName);
207 Driver->addArchiveBuffer(takeBuffer(std::move(MBOrErr.first)), SymName,
208 ParentName);
209 });
Rui Ueyama411c63602015-05-28 19:09:30 +0000210}
211
Rui Ueyamaf10a3202015-08-31 08:43:21 +0000212static bool isDecorated(StringRef Sym) {
213 return Sym.startswith("_") || Sym.startswith("@") || Sym.startswith("?");
214}
215
Rui Ueyama411c63602015-05-28 19:09:30 +0000216// Parses .drectve section contents and returns a list of files
217// specified by /defaultlib.
Rafael Espindolab835ae82015-08-06 14:58:50 +0000218void LinkerDriver::parseDirectives(StringRef S) {
Rui Ueyamaaffb40e2017-08-28 20:46:30 +0000219 ArgParser Parser;
Nico Webera05cbb82017-09-05 23:46:45 +0000220 // .drectve is always tokenized using Windows shell rules.
Rui Ueyama8fe17672016-12-08 20:50:47 +0000221 opt::InputArgList Args = Parser.parse(S);
Rui Ueyama411c63602015-05-28 19:09:30 +0000222
David Blaikie6521ed92015-06-22 22:06:52 +0000223 for (auto *Arg : Args) {
Rui Ueyama38b0f4a2017-07-19 20:30:04 +0000224 switch (Arg->getOption().getUnaliasedOption().getID()) {
Martin Storsjod2752aa2017-08-14 19:07:27 +0000225 case OPT_aligncomm:
226 parseAligncomm(Arg->getValue());
227 break;
Rui Ueyama562daa82015-06-18 21:50:38 +0000228 case OPT_alternatename:
Rafael Espindolab835ae82015-08-06 14:58:50 +0000229 parseAlternateName(Arg->getValue());
Rui Ueyama562daa82015-06-18 21:50:38 +0000230 break;
231 case OPT_defaultlib:
Peter Collingbourne6ee0b4e2016-12-15 04:02:23 +0000232 if (Optional<StringRef> Path = findLib(Arg->getValue()))
Martin Storsjo8278ba52017-09-13 07:28:03 +0000233 enqueuePath(*Path, false);
Rui Ueyama562daa82015-06-18 21:50:38 +0000234 break;
235 case OPT_export: {
Rafael Espindolab835ae82015-08-06 14:58:50 +0000236 Export E = parseExport(Arg->getValue());
Rui Ueyamaf10a3202015-08-31 08:43:21 +0000237 E.Directives = true;
Rafael Espindolab835ae82015-08-06 14:58:50 +0000238 Config->Exports.push_back(E);
Rui Ueyama562daa82015-06-18 21:50:38 +0000239 break;
240 }
241 case OPT_failifmismatch:
Rafael Espindolab835ae82015-08-06 14:58:50 +0000242 checkFailIfMismatch(Arg->getValue());
Rui Ueyama562daa82015-06-18 21:50:38 +0000243 break;
Rui Ueyama08d5e182015-06-18 23:20:11 +0000244 case OPT_incl:
Rui Ueyama32f8e1c2015-06-26 03:44:00 +0000245 addUndefined(Arg->getValue());
Rui Ueyama08d5e182015-06-18 23:20:11 +0000246 break;
Rui Ueyamace86c992015-06-18 23:22:39 +0000247 case OPT_merge:
Rafael Espindolab835ae82015-08-06 14:58:50 +0000248 parseMerge(Arg->getValue());
Rui Ueyamace86c992015-06-18 23:22:39 +0000249 break;
250 case OPT_nodefaultlib:
251 Config->NoDefaultLibs.insert(doFindLib(Arg->getValue()));
252 break;
Rui Ueyama440138c2016-06-20 03:39:39 +0000253 case OPT_section:
254 parseSection(Arg->getValue());
255 break;
Rui Ueyama3c4737d2015-08-11 16:46:08 +0000256 case OPT_editandcontinue:
Reid Kleckner9cd77ce2016-03-25 18:09:29 +0000257 case OPT_fastfail:
Rui Ueyama31e66e32015-09-03 16:20:47 +0000258 case OPT_guardsym:
Rui Ueyama9d9bdab2017-09-11 22:24:13 +0000259 case OPT_natvis:
Rui Ueyama432383172015-07-29 21:01:15 +0000260 case OPT_throwingnew:
Rui Ueyama46682632015-07-29 20:29:15 +0000261 break;
Rui Ueyama562daa82015-06-18 21:50:38 +0000262 default:
Bob Haarmanac8f7fc2017-04-05 00:43:54 +0000263 error(Arg->getSpelling() + " is not allowed in .drectve");
Rui Ueyamad7c2f582015-05-31 21:04:56 +0000264 }
265 }
Rui Ueyama411c63602015-05-28 19:09:30 +0000266}
267
Rui Ueyama54b71da2015-05-31 19:17:12 +0000268// Find file from search paths. You can omit ".obj", this function takes
269// care of that. Note that the returned path is not guaranteed to exist.
Rui Ueyamad21b00b2015-05-31 19:17:14 +0000270StringRef LinkerDriver::doFindFile(StringRef Filename) {
Rui Ueyamabf4ddeb2016-11-29 04:22:57 +0000271 bool HasPathSep = (Filename.find_first_of("/\\") != StringRef::npos);
272 if (HasPathSep)
Rui Ueyama54b71da2015-05-31 19:17:12 +0000273 return Filename;
Rui Ueyama12234f82017-07-19 21:40:26 +0000274 bool HasExt = Filename.contains('.');
Rui Ueyama54b71da2015-05-31 19:17:12 +0000275 for (StringRef Dir : SearchPaths) {
276 SmallString<128> Path = Dir;
Rui Ueyama8fe17672016-12-08 20:50:47 +0000277 sys::path::append(Path, Filename);
278 if (sys::fs::exists(Path.str()))
Rui Ueyama8d433d72016-12-08 21:27:09 +0000279 return Saver.save(Path.str());
Rui Ueyamabf4ddeb2016-11-29 04:22:57 +0000280 if (!HasExt) {
Rui Ueyama54b71da2015-05-31 19:17:12 +0000281 Path.append(".obj");
Rui Ueyama8fe17672016-12-08 20:50:47 +0000282 if (sys::fs::exists(Path.str()))
Rui Ueyama8d433d72016-12-08 21:27:09 +0000283 return Saver.save(Path.str());
Rui Ueyama54b71da2015-05-31 19:17:12 +0000284 }
285 }
286 return Filename;
287}
288
Rui Ueyamad21b00b2015-05-31 19:17:14 +0000289// Resolves a file path. This never returns the same path
290// (in that case, it returns None).
291Optional<StringRef> LinkerDriver::findFile(StringRef Filename) {
292 StringRef Path = doFindFile(Filename);
293 bool Seen = !VisitedFiles.insert(Path.lower()).second;
294 if (Seen)
295 return None;
296 return Path;
Rui Ueyama54b71da2015-05-31 19:17:12 +0000297}
298
Rui Ueyamad21b00b2015-05-31 19:17:14 +0000299// Find library file from search path.
300StringRef LinkerDriver::doFindLib(StringRef Filename) {
301 // Add ".lib" to Filename if that has no file extension.
Rui Ueyama12234f82017-07-19 21:40:26 +0000302 bool HasExt = Filename.contains('.');
Rui Ueyamabf4ddeb2016-11-29 04:22:57 +0000303 if (!HasExt)
Rui Ueyama8d433d72016-12-08 21:27:09 +0000304 Filename = Saver.save(Filename + ".lib");
Rui Ueyamad21b00b2015-05-31 19:17:14 +0000305 return doFindFile(Filename);
306}
307
308// Resolves a library path. /nodefaultlib options are taken into
309// consideration. This never returns the same path (in that case,
310// it returns None).
311Optional<StringRef> LinkerDriver::findLib(StringRef Filename) {
312 if (Config->NoDefaultLibAll)
313 return None;
Peter Collingbournec1ded7d2016-12-16 03:45:59 +0000314 if (!VisitedLibs.insert(Filename.lower()).second)
315 return None;
Rui Ueyamad21b00b2015-05-31 19:17:14 +0000316 StringRef Path = doFindLib(Filename);
317 if (Config->NoDefaultLibs.count(Path))
318 return None;
Peter Collingbournec1ded7d2016-12-16 03:45:59 +0000319 if (!VisitedFiles.insert(Path.lower()).second)
Rui Ueyamad21b00b2015-05-31 19:17:14 +0000320 return None;
321 return Path;
Rui Ueyama54b71da2015-05-31 19:17:12 +0000322}
323
324// Parses LIB environment which contains a list of search paths.
Rui Ueyamaf00df0a2015-06-19 22:39:48 +0000325void LinkerDriver::addLibSearchPaths() {
Rui Ueyama54b71da2015-05-31 19:17:12 +0000326 Optional<std::string> EnvOpt = Process::GetEnv("LIB");
327 if (!EnvOpt.hasValue())
Rui Ueyamaf00df0a2015-06-19 22:39:48 +0000328 return;
Rui Ueyama8d433d72016-12-08 21:27:09 +0000329 StringRef Env = Saver.save(*EnvOpt);
Rui Ueyama54b71da2015-05-31 19:17:12 +0000330 while (!Env.empty()) {
331 StringRef Path;
332 std::tie(Path, Env) = Env.split(';');
Rui Ueyamaf00df0a2015-06-19 22:39:48 +0000333 SearchPaths.push_back(Path);
Rui Ueyama54b71da2015-05-31 19:17:12 +0000334 }
Rui Ueyama54b71da2015-05-31 19:17:12 +0000335}
336
Peter Collingbourne79a5e6b2016-12-09 21:55:24 +0000337SymbolBody *LinkerDriver::addUndefined(StringRef Name) {
Rui Ueyamacbf969e2017-08-28 21:51:07 +0000338 SymbolBody *B = Symtab->addUndefined(Name);
Peter Collingbourne79a5e6b2016-12-09 21:55:24 +0000339 Config->GCRoot.insert(B);
340 return B;
Rui Ueyama32f8e1c2015-06-26 03:44:00 +0000341}
342
Rui Ueyama7c3e23f2015-07-09 01:25:49 +0000343// Symbol names are mangled by appending "_" prefix on x86.
344StringRef LinkerDriver::mangle(StringRef Sym) {
Rui Ueyama5e706b32015-07-25 21:54:50 +0000345 assert(Config->Machine != IMAGE_FILE_MACHINE_UNKNOWN);
346 if (Config->Machine == I386)
Rui Ueyama8d433d72016-12-08 21:27:09 +0000347 return Saver.save("_" + Sym);
Rui Ueyama7c3e23f2015-07-09 01:25:49 +0000348 return Sym;
349}
350
Rui Ueyama45044f42015-06-29 01:03:53 +0000351// Windows specific -- find default entry point name.
352StringRef LinkerDriver::findDefaultEntry() {
353 // User-defined main functions and their corresponding entry points.
354 static const char *Entries[][2] = {
355 {"main", "mainCRTStartup"},
356 {"wmain", "wmainCRTStartup"},
357 {"WinMain", "WinMainCRTStartup"},
358 {"wWinMain", "wWinMainCRTStartup"},
359 };
360 for (auto E : Entries) {
Rui Ueyamacbf969e2017-08-28 21:51:07 +0000361 StringRef Entry = Symtab->findMangle(mangle(E[0]));
362 if (!Entry.empty() && !isa<Undefined>(Symtab->find(Entry)->body()))
Rui Ueyama7c3e23f2015-07-09 01:25:49 +0000363 return mangle(E[1]);
Rui Ueyama45044f42015-06-29 01:03:53 +0000364 }
365 return "";
366}
367
368WindowsSubsystem LinkerDriver::inferSubsystem() {
Rui Ueyama97dff9e2015-06-17 00:16:33 +0000369 if (Config->DLL)
370 return IMAGE_SUBSYSTEM_WINDOWS_GUI;
Rui Ueyamacbf969e2017-08-28 21:51:07 +0000371 if (Symtab->findUnderscore("main") || Symtab->findUnderscore("wmain"))
Rui Ueyama45044f42015-06-29 01:03:53 +0000372 return IMAGE_SUBSYSTEM_WINDOWS_CUI;
Rui Ueyamacbf969e2017-08-28 21:51:07 +0000373 if (Symtab->findUnderscore("WinMain") || Symtab->findUnderscore("wWinMain"))
Rui Ueyama45044f42015-06-29 01:03:53 +0000374 return IMAGE_SUBSYSTEM_WINDOWS_GUI;
375 return IMAGE_SUBSYSTEM_UNKNOWN;
Rui Ueyama97dff9e2015-06-17 00:16:33 +0000376}
377
Rui Ueyama5c437cd2015-07-25 21:42:33 +0000378static uint64_t getDefaultImageBase() {
379 if (Config->is64())
380 return Config->DLL ? 0x180000000 : 0x140000000;
381 return Config->DLL ? 0x10000000 : 0x400000;
382}
383
Rui Ueyama8fe17672016-12-08 20:50:47 +0000384static std::string createResponseFile(const opt::InputArgList &Args,
Peter Collingbourne6ee0b4e2016-12-15 04:02:23 +0000385 ArrayRef<StringRef> FilePaths,
Peter Collingbournefeee2102016-07-26 02:00:42 +0000386 ArrayRef<StringRef> SearchPaths) {
387 SmallString<0> Data;
388 raw_svector_ostream OS(Data);
389
390 for (auto *Arg : Args) {
391 switch (Arg->getOption().getID()) {
392 case OPT_linkrepro:
393 case OPT_INPUT:
394 case OPT_defaultlib:
395 case OPT_libpath:
396 break;
397 default:
Rui Ueyamab4c63ca2017-01-06 10:04:35 +0000398 OS << toString(Arg) << "\n";
Peter Collingbournefeee2102016-07-26 02:00:42 +0000399 }
400 }
401
402 for (StringRef Path : SearchPaths) {
403 std::string RelPath = relativeToRoot(Path);
404 OS << "/libpath:" << quote(RelPath) << "\n";
405 }
406
Peter Collingbourne6ee0b4e2016-12-15 04:02:23 +0000407 for (StringRef Path : FilePaths)
408 OS << quote(relativeToRoot(Path)) << "\n";
Peter Collingbournefeee2102016-07-26 02:00:42 +0000409
410 return Data.str();
411}
412
Rui Ueyama8fe17672016-12-08 20:50:47 +0000413static unsigned getDefaultDebugType(const opt::InputArgList &Args) {
Saleem Abdulrasoola2cca7e2016-08-08 22:02:44 +0000414 unsigned DebugTypes = static_cast<unsigned>(DebugType::CV);
415 if (Args.hasArg(OPT_driver))
416 DebugTypes |= static_cast<unsigned>(DebugType::PData);
417 if (Args.hasArg(OPT_profile))
418 DebugTypes |= static_cast<unsigned>(DebugType::Fixup);
419 return DebugTypes;
420}
421
422static unsigned parseDebugType(StringRef Arg) {
Rui Ueyama8fe17672016-12-08 20:50:47 +0000423 SmallVector<StringRef, 3> Types;
Saleem Abdulrasoola2cca7e2016-08-08 22:02:44 +0000424 Arg.split(Types, ',', /*KeepEmpty=*/false);
425
426 unsigned DebugTypes = static_cast<unsigned>(DebugType::None);
427 for (StringRef Type : Types)
428 DebugTypes |= StringSwitch<unsigned>(Type.lower())
429 .Case("cv", static_cast<unsigned>(DebugType::CV))
430 .Case("pdata", static_cast<unsigned>(DebugType::PData))
Saleem Abdulrasoolb6394282017-02-07 04:28:05 +0000431 .Case("fixup", static_cast<unsigned>(DebugType::Fixup))
432 .Default(0);
Saleem Abdulrasoola2cca7e2016-08-08 22:02:44 +0000433 return DebugTypes;
434}
435
Hans Wennborg1818e652016-12-09 20:54:44 +0000436static std::string getMapFile(const opt::InputArgList &Args) {
437 auto *Arg = Args.getLastArg(OPT_lldmap, OPT_lldmap_file);
438 if (!Arg)
439 return "";
440 if (Arg->getOption().getID() == OPT_lldmap_file)
441 return Arg->getValue();
442
443 assert(Arg->getOption().getID() == OPT_lldmap);
444 StringRef OutFile = Config->OutputFile;
445 return (OutFile.substr(0, OutFile.rfind('.')) + ".map").str();
446}
447
Reid Kleckner146eb7a2017-06-02 17:53:06 +0000448static std::string getImplibPath() {
449 if (!Config->Implib.empty())
450 return Config->Implib;
451 SmallString<128> Out = StringRef(Config->OutputFile);
452 sys::path::replace_extension(Out, ".lib");
453 return Out.str();
454}
455
Saleem Abdulrasoolace2fa72017-07-19 02:01:27 +0000456//
457// The import name is caculated as the following:
458//
459// | LIBRARY w/ ext | LIBRARY w/o ext | no LIBRARY
460// -----+----------------+---------------------+------------------
461// LINK | {value} | {value}.{.dll/.exe} | {output name}
462// LIB | {value} | {value}.dll | {output name}.dll
463//
464static std::string getImportName(bool AsLib) {
465 SmallString<128> Out;
466
467 if (Config->ImportName.empty()) {
468 Out.assign(sys::path::filename(Config->OutputFile));
469 if (AsLib)
470 sys::path::replace_extension(Out, ".dll");
471 } else {
472 Out.assign(Config->ImportName);
473 if (!sys::path::has_extension(Out))
474 sys::path::replace_extension(Out,
475 (Config->DLL || AsLib) ? ".dll" : ".exe");
476 }
477
478 return Out.str();
479}
480
481static void createImportLibrary(bool AsLib) {
Reid Kleckner146eb7a2017-06-02 17:53:06 +0000482 std::vector<COFFShortExport> Exports;
483 for (Export &E1 : Config->Exports) {
484 COFFShortExport E2;
Martin Storsjoa50275cf2017-08-16 05:13:25 +0000485 E2.Name = E1.Name;
486 E2.SymbolName = E1.SymbolName;
Reid Kleckner146eb7a2017-06-02 17:53:06 +0000487 E2.ExtName = E1.ExtName;
488 E2.Ordinal = E1.Ordinal;
489 E2.Noname = E1.Noname;
490 E2.Data = E1.Data;
491 E2.Private = E1.Private;
492 E2.Constant = E1.Constant;
493 Exports.push_back(E2);
494 }
Reid Kleckner146eb7a2017-06-02 17:53:06 +0000495
Saleem Abdulrasoolace2fa72017-07-19 02:01:27 +0000496 writeImportLibrary(getImportName(AsLib), getImplibPath(), Exports,
Martin Storsjo92f32d02017-08-16 05:23:00 +0000497 Config->Machine, false);
Reid Kleckner146eb7a2017-06-02 17:53:06 +0000498}
499
500static void parseModuleDefs(StringRef Path) {
501 std::unique_ptr<MemoryBuffer> MB = check(
502 MemoryBuffer::getFile(Path, -1, false, true), "could not open " + Path);
Rui Ueyama67aea7372017-06-08 23:43:44 +0000503 COFFModuleDefinition M =
504 check(parseCOFFModuleDefinition(MB->getMemBufferRef(), Config->Machine));
Reid Kleckner146eb7a2017-06-02 17:53:06 +0000505
Reid Kleckner146eb7a2017-06-02 17:53:06 +0000506 if (Config->OutputFile.empty())
507 Config->OutputFile = Saver.save(M.OutputFile);
Saleem Abdulrasoolace2fa72017-07-19 02:01:27 +0000508 Config->ImportName = Saver.save(M.ImportName);
Reid Kleckner146eb7a2017-06-02 17:53:06 +0000509 if (M.ImageBase)
510 Config->ImageBase = M.ImageBase;
511 if (M.StackReserve)
512 Config->StackReserve = M.StackReserve;
513 if (M.StackCommit)
514 Config->StackCommit = M.StackCommit;
515 if (M.HeapReserve)
516 Config->HeapReserve = M.HeapReserve;
517 if (M.HeapCommit)
518 Config->HeapCommit = M.HeapCommit;
519 if (M.MajorImageVersion)
520 Config->MajorImageVersion = M.MajorImageVersion;
521 if (M.MinorImageVersion)
522 Config->MinorImageVersion = M.MinorImageVersion;
523 if (M.MajorOSVersion)
524 Config->MajorOSVersion = M.MajorOSVersion;
525 if (M.MinorOSVersion)
526 Config->MinorOSVersion = M.MinorOSVersion;
527
528 for (COFFShortExport E1 : M.Exports) {
529 Export E2;
530 E2.Name = Saver.save(E1.Name);
531 if (E1.isWeak())
532 E2.ExtName = Saver.save(E1.ExtName);
533 E2.Ordinal = E1.Ordinal;
534 E2.Noname = E1.Noname;
535 E2.Data = E1.Data;
536 E2.Private = E1.Private;
537 E2.Constant = E1.Constant;
538 Config->Exports.push_back(E2);
539 }
540}
541
Rui Ueyamae1bf1362017-03-16 21:19:36 +0000542// A helper function for filterBitcodeFiles.
543static bool needsRebuilding(MemoryBufferRef MB) {
544 // The MSVC linker doesn't support thin archives, so if it's a thin
545 // archive, we always need to rebuild it.
546 std::unique_ptr<Archive> File =
547 check(Archive::create(MB), "Failed to read " + MB.getBufferIdentifier());
548 if (File->isThin())
549 return true;
550
551 // Returns true if the archive contains at least one bitcode file.
Peter Collingbournea6ffbdd2017-03-17 02:03:20 +0000552 for (MemoryBufferRef Member : getArchiveMembers(File.get()))
Rui Ueyamae1bf1362017-03-16 21:19:36 +0000553 if (identify_magic(Member.getBuffer()) == file_magic::bitcode)
554 return true;
555 return false;
556}
557
558// Opens a given path as an archive file and removes bitcode files
559// from them if exists. This function is to appease the MSVC linker as
560// their linker doesn't like archive files containing non-native
561// object files.
562//
563// If a given archive doesn't contain bitcode files, the archive path
564// is returned as-is. Otherwise, a new temporary file is created and
565// its path is returned.
566static Optional<std::string>
567filterBitcodeFiles(StringRef Path, std::vector<std::string> &TemporaryFiles) {
Rui Ueyama85d54b02017-02-23 00:26:42 +0000568 std::unique_ptr<MemoryBuffer> MB = check(
569 MemoryBuffer::getFile(Path, -1, false, true), "could not open " + Path);
Rui Ueyamae1bf1362017-03-16 21:19:36 +0000570 MemoryBufferRef MBRef = MB->getMemBufferRef();
571 file_magic Magic = identify_magic(MBRef.getBuffer());
Rui Ueyamae0341db2017-03-07 19:45:53 +0000572
573 if (Magic == file_magic::bitcode)
Rui Ueyamae1bf1362017-03-16 21:19:36 +0000574 return None;
575 if (Magic != file_magic::archive)
576 return Path.str();
577 if (!needsRebuilding(MBRef))
578 return Path.str();
Rui Ueyamae0341db2017-03-07 19:45:53 +0000579
Peter Collingbournea6ffbdd2017-03-17 02:03:20 +0000580 std::unique_ptr<Archive> File =
581 check(Archive::create(MBRef),
582 MBRef.getBufferIdentifier() + ": failed to parse archive");
583
Rui Ueyamae1bf1362017-03-16 21:19:36 +0000584 std::vector<NewArchiveMember> New;
Peter Collingbournea6ffbdd2017-03-17 02:03:20 +0000585 for (MemoryBufferRef Member : getArchiveMembers(File.get()))
Rui Ueyamae1bf1362017-03-16 21:19:36 +0000586 if (identify_magic(Member.getBuffer()) != file_magic::bitcode)
587 New.emplace_back(Member);
Rui Ueyamae0341db2017-03-07 19:45:53 +0000588
Peter Collingbournedb7447d2017-03-17 02:04:22 +0000589 if (New.empty())
590 return None;
591
592 log("Creating a temporary archive for " + Path + " to remove bitcode files");
593
Rui Ueyamae1bf1362017-03-16 21:19:36 +0000594 SmallString<128> S;
595 if (auto EC = sys::fs::createTemporaryFile("lld-" + sys::path::stem(Path),
596 ".lib", S))
597 fatal(EC, "cannot create a temporary file");
598 std::string Temp = S.str();
599 TemporaryFiles.push_back(Temp);
600
Rui Ueyama01d02652017-08-30 22:11:03 +0000601 std::error_code EC =
Rui Ueyamae1bf1362017-03-16 21:19:36 +0000602 llvm::writeArchive(Temp, New, /*WriteSymtab=*/true, Archive::Kind::K_GNU,
603 /*Deterministics=*/true,
604 /*Thin=*/false);
Rui Ueyama01d02652017-08-30 22:11:03 +0000605 if (EC)
606 error("failed to create a new archive " + S.str() + ": " + EC.message());
Rui Ueyamae1bf1362017-03-16 21:19:36 +0000607 return Temp;
Rui Ueyama85d54b02017-02-23 00:26:42 +0000608}
609
610// Create response file contents and invoke the MSVC linker.
611void LinkerDriver::invokeMSVC(opt::InputArgList &Args) {
Bob Haarman630d0c02017-04-18 22:00:29 +0000612 std::string Rsp = "/nologo\n";
Rui Ueyamae1bf1362017-03-16 21:19:36 +0000613 std::vector<std::string> Temps;
Rui Ueyama85d54b02017-02-23 00:26:42 +0000614
Bob Haarman41108162017-04-21 21:38:01 +0000615 // Write out archive members that we used in symbol resolution and pass these
616 // to MSVC before any archives, so that MSVC uses the same objects to satisfy
617 // references.
Rui Ueyamaacd632d2017-07-27 00:45:26 +0000618 for (ObjFile *Obj : ObjFile::Instances) {
619 if (Obj->ParentName.empty())
Bob Haarman41108162017-04-21 21:38:01 +0000620 continue;
621 SmallString<128> S;
622 int Fd;
623 if (auto EC = sys::fs::createTemporaryFile(
Rui Ueyamaacd632d2017-07-27 00:45:26 +0000624 "lld-" + sys::path::filename(Obj->ParentName), ".obj", Fd, S))
Bob Haarman41108162017-04-21 21:38:01 +0000625 fatal(EC, "cannot create a temporary file");
626 raw_fd_ostream OS(Fd, /*shouldClose*/ true);
Rui Ueyamaacd632d2017-07-27 00:45:26 +0000627 OS << Obj->MB.getBuffer();
Bob Haarman41108162017-04-21 21:38:01 +0000628 Temps.push_back(S.str());
629 Rsp += quote(S) + "\n";
630 }
631
Rui Ueyama85d54b02017-02-23 00:26:42 +0000632 for (auto *Arg : Args) {
633 switch (Arg->getOption().getID()) {
634 case OPT_linkrepro:
635 case OPT_lldmap:
636 case OPT_lldmap_file:
Peter Collingbourne8713bf62017-03-17 02:11:09 +0000637 case OPT_lldsavetemps:
Rui Ueyama85d54b02017-02-23 00:26:42 +0000638 case OPT_msvclto:
639 // LLD-specific options are stripped.
640 break;
641 case OPT_opt:
642 if (!StringRef(Arg->getValue()).startswith("lld"))
643 Rsp += toString(Arg) + " ";
644 break;
Rui Ueyamae1bf1362017-03-16 21:19:36 +0000645 case OPT_INPUT: {
646 if (Optional<StringRef> Path = doFindFile(Arg->getValue())) {
647 if (Optional<std::string> S = filterBitcodeFiles(*Path, Temps))
Bob Haarman630d0c02017-04-18 22:00:29 +0000648 Rsp += quote(*S) + "\n";
Rui Ueyamae1bf1362017-03-16 21:19:36 +0000649 continue;
650 }
Bob Haarman630d0c02017-04-18 22:00:29 +0000651 Rsp += quote(Arg->getValue()) + "\n";
Rui Ueyama85d54b02017-02-23 00:26:42 +0000652 break;
Rui Ueyamae1bf1362017-03-16 21:19:36 +0000653 }
Rui Ueyama85d54b02017-02-23 00:26:42 +0000654 default:
Bob Haarman630d0c02017-04-18 22:00:29 +0000655 Rsp += toString(Arg) + "\n";
Rui Ueyama85d54b02017-02-23 00:26:42 +0000656 }
657 }
658
Rui Ueyamacbf969e2017-08-28 21:51:07 +0000659 std::vector<StringRef> ObjFiles = Symtab->compileBitcodeFiles();
Rui Ueyamae1b48e02017-07-26 23:05:24 +0000660 runMSVCLinker(Rsp, ObjFiles);
Rui Ueyamae1bf1362017-03-16 21:19:36 +0000661
662 for (StringRef Path : Temps)
663 sys::fs::remove(Path);
Rui Ueyama85d54b02017-02-23 00:26:42 +0000664}
665
Peter Collingbourne6ee0b4e2016-12-15 04:02:23 +0000666void LinkerDriver::enqueueTask(std::function<void()> Task) {
667 TaskQueue.push_back(std::move(Task));
668}
669
670bool LinkerDriver::run() {
671 bool DidWork = !TaskQueue.empty();
672 while (!TaskQueue.empty()) {
673 TaskQueue.front()();
674 TaskQueue.pop_front();
675 }
676 return DidWork;
677}
678
Rui Ueyama8fe17672016-12-08 20:50:47 +0000679void LinkerDriver::link(ArrayRef<const char *> ArgsArr) {
Rui Ueyama27e470a2015-08-09 20:45:17 +0000680 // If the first command line argument is "/lib", link.exe acts like lib.exe.
681 // We call our own implementation of lib.exe that understands bitcode files.
682 if (ArgsArr.size() > 1 && StringRef(ArgsArr[1]).equals_lower("/lib")) {
683 if (llvm::libDriverMain(ArgsArr.slice(1)) != 0)
Rui Ueyama60604792016-07-14 23:37:14 +0000684 fatal("lib failed");
Rui Ueyama27e470a2015-08-09 20:45:17 +0000685 return;
686 }
687
Peter Collingbourne60c16162015-06-01 20:10:10 +0000688 // Needed for LTO.
Rui Ueyama8fe17672016-12-08 20:50:47 +0000689 InitializeAllTargetInfos();
690 InitializeAllTargets();
691 InitializeAllTargetMCs();
692 InitializeAllAsmParsers();
693 InitializeAllAsmPrinters();
694 InitializeAllDisassemblers();
Peter Collingbourne60c16162015-06-01 20:10:10 +0000695
Rui Ueyama411c63602015-05-28 19:09:30 +0000696 // Parse command line options.
Rui Ueyamaaffb40e2017-08-28 20:46:30 +0000697 ArgParser Parser;
Rui Ueyama8fe17672016-12-08 20:50:47 +0000698 opt::InputArgList Args = Parser.parseLINK(ArgsArr.slice(1));
Rui Ueyama411c63602015-05-28 19:09:30 +0000699
Rui Ueyama9a3e7332017-03-30 20:10:40 +0000700 // Parse and evaluate -mllvm options.
701 std::vector<const char *> V;
702 V.push_back("lld-link (LLVM option parsing)");
703 for (auto *Arg : Args.filtered(OPT_mllvm))
704 V.push_back(Arg->getValue());
705 cl::ParseCommandLineOptions(V.size(), V.data());
706
Bob Haarmanac8f7fc2017-04-05 00:43:54 +0000707 // Handle /errorlimit early, because error() depends on it.
708 if (auto *Arg = Args.getLastArg(OPT_errorlimit)) {
709 int N = 20;
710 StringRef S = Arg->getValue();
711 if (S.getAsInteger(10, N))
712 error(Arg->getSpelling() + " number expected, but got " + S);
713 Config->ErrorLimit = N;
714 }
715
Rui Ueyama5c726432015-05-29 16:11:52 +0000716 // Handle /help
David Blaikie6521ed92015-06-22 22:06:52 +0000717 if (Args.hasArg(OPT_help)) {
David Blaikieb2b1c7c2015-06-21 06:32:10 +0000718 printHelp(ArgsArr[0]);
Rafael Espindolab835ae82015-08-06 14:58:50 +0000719 return;
Rui Ueyama5c726432015-05-29 16:11:52 +0000720 }
721
Peter Collingbournefeee2102016-07-26 02:00:42 +0000722 if (auto *Arg = Args.getLastArg(OPT_linkrepro)) {
723 SmallString<64> Path = StringRef(Arg->getValue());
Rui Ueyama7f1f9122017-01-06 02:33:53 +0000724 sys::path::append(Path, "repro.tar");
725
726 Expected<std::unique_ptr<TarWriter>> ErrOrWriter =
727 TarWriter::create(Path, "repro");
728
729 if (ErrOrWriter) {
730 Tar = std::move(*ErrOrWriter);
731 } else {
Rui Ueyamae6e206d2017-02-21 23:22:56 +0000732 error("/linkrepro: failed to open " + Path + ": " +
733 toString(ErrOrWriter.takeError()));
Rui Ueyama7f1f9122017-01-06 02:33:53 +0000734 }
Peter Collingbournefeee2102016-07-26 02:00:42 +0000735 }
736
Saleem Abdulrasoolbc7ff702017-06-15 20:39:58 +0000737 if (!Args.hasArgNoClaim(OPT_INPUT)) {
738 if (Args.hasArgNoClaim(OPT_deffile))
739 Config->NoEntry = true;
740 else
741 fatal("no input files");
742 }
Rui Ueyama3d3e6fb2015-05-29 16:06:00 +0000743
Rui Ueyamaf00df0a2015-06-19 22:39:48 +0000744 // Construct search path list.
745 SearchPaths.push_back("");
David Blaikie6521ed92015-06-22 22:06:52 +0000746 for (auto *Arg : Args.filtered(OPT_libpath))
Rui Ueyamaf00df0a2015-06-19 22:39:48 +0000747 SearchPaths.push_back(Arg->getValue());
748 addLibSearchPaths();
749
Rui Ueyamaad660982015-06-07 00:20:32 +0000750 // Handle /out
David Blaikie6521ed92015-06-22 22:06:52 +0000751 if (auto *Arg = Args.getLastArg(OPT_out))
Rui Ueyamaad660982015-06-07 00:20:32 +0000752 Config->OutputFile = Arg->getValue();
753
Rui Ueyama3d3e6fb2015-05-29 16:06:00 +0000754 // Handle /verbose
David Blaikie6521ed92015-06-22 22:06:52 +0000755 if (Args.hasArg(OPT_verbose))
Rui Ueyama411c63602015-05-28 19:09:30 +0000756 Config->Verbose = true;
Rui Ueyama3d3e6fb2015-05-29 16:06:00 +0000757
Rui Ueyama95925fd2015-06-28 19:35:15 +0000758 // Handle /force or /force:unresolved
759 if (Args.hasArg(OPT_force) || Args.hasArg(OPT_force_unresolved))
760 Config->Force = true;
761
Rui Ueyama6600eb12015-07-04 23:37:32 +0000762 // Handle /debug
Saleem Abdulrasoola2cca7e2016-08-08 22:02:44 +0000763 if (Args.hasArg(OPT_debug)) {
Rui Ueyama6600eb12015-07-04 23:37:32 +0000764 Config->Debug = true;
Rui Ueyama9f7032a2017-08-24 20:26:54 +0000765 if (auto *Arg = Args.getLastArg(OPT_debugtype))
766 Config->DebugTypes = parseDebugType(Arg->getValue());
767 else
768 Config->DebugTypes = getDefaultDebugType(Args);
Saleem Abdulrasoola2cca7e2016-08-08 22:02:44 +0000769 }
Rui Ueyama6600eb12015-07-04 23:37:32 +0000770
Saleem Abdulrasool8fcff932016-08-29 21:20:46 +0000771 // Create a dummy PDB file to satisfy build sytem rules.
Rui Ueyama9f66f822016-10-11 19:45:07 +0000772 if (auto *Arg = Args.getLastArg(OPT_pdb))
Saleem Abdulrasool8fcff932016-08-29 21:20:46 +0000773 Config->PDBPath = Arg->getValue();
Saleem Abdulrasool8fcff932016-08-29 21:20:46 +0000774
Rui Ueyamaa8b60452015-06-28 19:56:30 +0000775 // Handle /noentry
776 if (Args.hasArg(OPT_noentry)) {
Bob Haarmanac8f7fc2017-04-05 00:43:54 +0000777 if (Args.hasArg(OPT_dll))
778 Config->NoEntry = true;
779 else
780 error("/noentry must be specified with /dll");
Rui Ueyamaa8b60452015-06-28 19:56:30 +0000781 }
782
Rui Ueyama97dff9e2015-06-17 00:16:33 +0000783 // Handle /dll
David Blaikie6521ed92015-06-22 22:06:52 +0000784 if (Args.hasArg(OPT_dll)) {
Rui Ueyama97dff9e2015-06-17 00:16:33 +0000785 Config->DLL = true;
Rui Ueyama24c5fd02015-06-18 00:12:42 +0000786 Config->ManifestID = 2;
787 }
Rui Ueyama97dff9e2015-06-17 00:16:33 +0000788
Rui Ueyama588e8322015-06-15 01:23:58 +0000789 // Handle /fixed
David Blaikie6521ed92015-06-22 22:06:52 +0000790 if (Args.hasArg(OPT_fixed)) {
Bob Haarmanac8f7fc2017-04-05 00:43:54 +0000791 if (Args.hasArg(OPT_dynamicbase)) {
792 error("/fixed must not be specified with /dynamicbase");
793 } else {
794 Config->Relocatable = false;
795 Config->DynamicBase = false;
796 }
Rui Ueyama6592ff82015-06-16 23:13:00 +0000797 }
Rui Ueyama588e8322015-06-15 01:23:58 +0000798
Saleem Abdulrasool671029d2017-04-06 23:07:53 +0000799 if (Args.hasArg(OPT_appcontainer))
800 Config->AppContainer = true;
801
Rui Ueyama3d3e6fb2015-05-29 16:06:00 +0000802 // Handle /machine
Rafael Espindolab835ae82015-08-06 14:58:50 +0000803 if (auto *Arg = Args.getLastArg(OPT_machine))
804 Config->Machine = getMachineType(Arg->getValue());
Rui Ueyama3d3e6fb2015-05-29 16:06:00 +0000805
Rui Ueyamad21b00b2015-05-31 19:17:14 +0000806 // Handle /nodefaultlib:<filename>
David Blaikie6521ed92015-06-22 22:06:52 +0000807 for (auto *Arg : Args.filtered(OPT_nodefaultlib))
Rui Ueyamad21b00b2015-05-31 19:17:14 +0000808 Config->NoDefaultLibs.insert(doFindLib(Arg->getValue()));
809
810 // Handle /nodefaultlib
David Blaikie6521ed92015-06-22 22:06:52 +0000811 if (Args.hasArg(OPT_nodefaultlib_all))
Rui Ueyamad21b00b2015-05-31 19:17:14 +0000812 Config->NoDefaultLibAll = true;
813
Rui Ueyama804a8b62015-05-29 16:18:15 +0000814 // Handle /base
Rafael Espindolab835ae82015-08-06 14:58:50 +0000815 if (auto *Arg = Args.getLastArg(OPT_base))
816 parseNumbers(Arg->getValue(), &Config->ImageBase);
Rui Ueyamab41b7e52015-05-29 16:21:11 +0000817
818 // Handle /stack
Rafael Espindolab835ae82015-08-06 14:58:50 +0000819 if (auto *Arg = Args.getLastArg(OPT_stack))
820 parseNumbers(Arg->getValue(), &Config->StackReserve, &Config->StackCommit);
Rui Ueyama804a8b62015-05-29 16:18:15 +0000821
Rui Ueyamac377e9a2015-05-29 16:23:40 +0000822 // Handle /heap
Rafael Espindolab835ae82015-08-06 14:58:50 +0000823 if (auto *Arg = Args.getLastArg(OPT_heap))
824 parseNumbers(Arg->getValue(), &Config->HeapReserve, &Config->HeapCommit);
Rui Ueyamac377e9a2015-05-29 16:23:40 +0000825
Rui Ueyamab9dcdb52015-05-29 16:28:29 +0000826 // Handle /version
Rafael Espindolab835ae82015-08-06 14:58:50 +0000827 if (auto *Arg = Args.getLastArg(OPT_version))
828 parseVersion(Arg->getValue(), &Config->MajorImageVersion,
829 &Config->MinorImageVersion);
Rui Ueyamab9dcdb52015-05-29 16:28:29 +0000830
Rui Ueyama15cc47e2015-05-29 16:34:31 +0000831 // Handle /subsystem
Rafael Espindolab835ae82015-08-06 14:58:50 +0000832 if (auto *Arg = Args.getLastArg(OPT_subsystem))
833 parseSubsystem(Arg->getValue(), &Config->Subsystem, &Config->MajorOSVersion,
834 &Config->MinorOSVersion);
Rui Ueyama15cc47e2015-05-29 16:34:31 +0000835
Rui Ueyama2edb35a2015-06-18 19:09:30 +0000836 // Handle /alternatename
David Blaikie6521ed92015-06-22 22:06:52 +0000837 for (auto *Arg : Args.filtered(OPT_alternatename))
Rafael Espindolab835ae82015-08-06 14:58:50 +0000838 parseAlternateName(Arg->getValue());
Rui Ueyama2edb35a2015-06-18 19:09:30 +0000839
Rui Ueyama08d5e182015-06-18 23:20:11 +0000840 // Handle /include
David Blaikie6521ed92015-06-22 22:06:52 +0000841 for (auto *Arg : Args.filtered(OPT_incl))
Rui Ueyama32f8e1c2015-06-26 03:44:00 +0000842 addUndefined(Arg->getValue());
Rui Ueyama08d5e182015-06-18 23:20:11 +0000843
Rui Ueyamab95188c2015-06-18 20:27:09 +0000844 // Handle /implib
David Blaikie6521ed92015-06-22 22:06:52 +0000845 if (auto *Arg = Args.getLastArg(OPT_implib))
Rui Ueyamab95188c2015-06-18 20:27:09 +0000846 Config->Implib = Arg->getValue();
847
Rui Ueyamae2cbfea2015-06-07 03:17:42 +0000848 // Handle /opt
David Blaikie6521ed92015-06-22 22:06:52 +0000849 for (auto *Arg : Args.filtered(OPT_opt)) {
Rui Ueyama75656ee2015-10-19 19:40:43 +0000850 std::string Str = StringRef(Arg->getValue()).lower();
851 SmallVector<StringRef, 1> Vec;
852 StringRef(Str).split(Vec, ',');
853 for (StringRef S : Vec) {
854 if (S == "noref") {
855 Config->DoGC = false;
856 Config->DoICF = false;
857 continue;
858 }
Peter Collingbournecef80992017-09-07 23:49:09 +0000859 if (S == "icf" || S.startswith("icf=")) {
Rui Ueyama75656ee2015-10-19 19:40:43 +0000860 Config->DoICF = true;
861 continue;
862 }
863 if (S == "noicf") {
864 Config->DoICF = false;
865 continue;
866 }
Peter Collingbournecef80992017-09-07 23:49:09 +0000867 if (S.startswith("lldlto=")) {
868 StringRef OptLevel = S.substr(7);
Rui Ueyama75656ee2015-10-19 19:40:43 +0000869 if (OptLevel.getAsInteger(10, Config->LTOOptLevel) ||
870 Config->LTOOptLevel > 3)
Bob Haarmanac8f7fc2017-04-05 00:43:54 +0000871 error("/opt:lldlto: invalid optimization level: " + OptLevel);
Rui Ueyama75656ee2015-10-19 19:40:43 +0000872 continue;
873 }
Peter Collingbournecef80992017-09-07 23:49:09 +0000874 if (S.startswith("lldltojobs=")) {
875 StringRef Jobs = S.substr(11);
Rui Ueyama75656ee2015-10-19 19:40:43 +0000876 if (Jobs.getAsInteger(10, Config->LTOJobs) || Config->LTOJobs == 0)
Bob Haarmanac8f7fc2017-04-05 00:43:54 +0000877 error("/opt:lldltojobs: invalid job count: " + Jobs);
Rui Ueyama75656ee2015-10-19 19:40:43 +0000878 continue;
879 }
Peter Collingbournecef80992017-09-07 23:49:09 +0000880 if (S.startswith("lldltopartitions=")) {
881 StringRef N = S.substr(17);
Bob Haarmancde5e5b2017-02-02 23:58:14 +0000882 if (N.getAsInteger(10, Config->LTOPartitions) ||
883 Config->LTOPartitions == 0)
Bob Haarmanac8f7fc2017-04-05 00:43:54 +0000884 error("/opt:lldltopartitions: invalid partition count: " + N);
Bob Haarmancde5e5b2017-02-02 23:58:14 +0000885 continue;
886 }
Rui Ueyama75656ee2015-10-19 19:40:43 +0000887 if (S != "ref" && S != "lbr" && S != "nolbr")
Bob Haarmanac8f7fc2017-04-05 00:43:54 +0000888 error("/opt: unknown option: " + S);
Rui Ueyamae2cbfea2015-06-07 03:17:42 +0000889 }
Rui Ueyamae2cbfea2015-06-07 03:17:42 +0000890 }
891
Bob Haarman69b196d2017-02-08 18:36:41 +0000892 // Handle /lldsavetemps
893 if (Args.hasArg(OPT_lldsavetemps))
894 Config->SaveTemps = true;
895
Peter Collingbourne052e855e2017-09-08 00:50:50 +0000896 // Handle /lldltocache
897 if (auto *Arg = Args.getLastArg(OPT_lldltocache))
898 Config->LTOCache = Arg->getValue();
899
900 // Handle /lldsavecachepolicy
901 if (auto *Arg = Args.getLastArg(OPT_lldltocachepolicy))
902 Config->LTOCachePolicy = check(
903 parseCachePruningPolicy(Arg->getValue()),
904 Twine("/lldltocachepolicy: invalid cache policy: ") + Arg->getValue());
905
Rui Ueyama8854d8a2015-06-04 19:21:24 +0000906 // Handle /failifmismatch
David Blaikie6521ed92015-06-22 22:06:52 +0000907 for (auto *Arg : Args.filtered(OPT_failifmismatch))
Rafael Espindolab835ae82015-08-06 14:58:50 +0000908 checkFailIfMismatch(Arg->getValue());
Rui Ueyama8854d8a2015-06-04 19:21:24 +0000909
Rui Ueyama6600eb12015-07-04 23:37:32 +0000910 // Handle /merge
911 for (auto *Arg : Args.filtered(OPT_merge))
Rafael Espindolab835ae82015-08-06 14:58:50 +0000912 parseMerge(Arg->getValue());
Rui Ueyama6600eb12015-07-04 23:37:32 +0000913
Rui Ueyama440138c2016-06-20 03:39:39 +0000914 // Handle /section
915 for (auto *Arg : Args.filtered(OPT_section))
916 parseSection(Arg->getValue());
917
Martin Storsjod2752aa2017-08-14 19:07:27 +0000918 // Handle /aligncomm
919 for (auto *Arg : Args.filtered(OPT_aligncomm))
920 parseAligncomm(Arg->getValue());
921
Nico Webera7a2c442017-07-25 18:08:03 +0000922 // Handle /manifestdependency. This enables /manifest unless /manifest:no is
923 // also passed.
924 if (auto *Arg = Args.getLastArg(OPT_manifestdependency)) {
925 Config->ManifestDependency = Arg->getValue();
926 Config->Manifest = Configuration::SideBySide;
927 }
928
929 // Handle /manifest and /manifest:
930 if (auto *Arg = Args.getLastArg(OPT_manifest, OPT_manifest_colon)) {
931 if (Arg->getOption().getID() == OPT_manifest)
932 Config->Manifest = Configuration::SideBySide;
933 else
934 parseManifest(Arg->getValue());
935 }
Rui Ueyama24c5fd02015-06-18 00:12:42 +0000936
937 // Handle /manifestuac
Rafael Espindolab835ae82015-08-06 14:58:50 +0000938 if (auto *Arg = Args.getLastArg(OPT_manifestuac))
939 parseManifestUAC(Arg->getValue());
Rui Ueyama24c5fd02015-06-18 00:12:42 +0000940
Rui Ueyama24c5fd02015-06-18 00:12:42 +0000941 // Handle /manifestfile
David Blaikie6521ed92015-06-22 22:06:52 +0000942 if (auto *Arg = Args.getLastArg(OPT_manifestfile))
Rui Ueyama24c5fd02015-06-18 00:12:42 +0000943 Config->ManifestFile = Arg->getValue();
944
Rui Ueyamaafb19012016-04-19 01:21:58 +0000945 // Handle /manifestinput
946 for (auto *Arg : Args.filtered(OPT_manifestinput))
947 Config->ManifestInput.push_back(Arg->getValue());
948
Nico Webera7a2c442017-07-25 18:08:03 +0000949 if (!Config->ManifestInput.empty() &&
950 Config->Manifest != Configuration::Embed) {
951 fatal("/MANIFESTINPUT: requires /MANIFEST:EMBED");
952 }
953
Rui Ueyama6592ff82015-06-16 23:13:00 +0000954 // Handle miscellaneous boolean flags.
David Blaikie6521ed92015-06-22 22:06:52 +0000955 if (Args.hasArg(OPT_allowisolation_no))
956 Config->AllowIsolation = false;
957 if (Args.hasArg(OPT_dynamicbase_no))
958 Config->DynamicBase = false;
David Blaikie6521ed92015-06-22 22:06:52 +0000959 if (Args.hasArg(OPT_nxcompat_no))
960 Config->NxCompat = false;
961 if (Args.hasArg(OPT_tsaware_no))
962 Config->TerminalServerAware = false;
Rui Ueyama96401732015-09-21 23:43:31 +0000963 if (Args.hasArg(OPT_nosymtab))
964 Config->WriteSymtab = false;
Rui Ueyama6592ff82015-06-16 23:13:00 +0000965
Peter Collingbourne6f24fdb2017-01-14 03:14:46 +0000966 Config->MapFile = getMapFile(Args);
967
Bob Haarmanac8f7fc2017-04-05 00:43:54 +0000968 if (ErrorCount)
969 return;
970
Martin Storsjo8278ba52017-09-13 07:28:03 +0000971 bool WholeArchiveFlag = Args.hasArg(OPT_wholearchive_flag);
Rui Ueyamad21b00b2015-05-31 19:17:14 +0000972 // Create a list of input files. Files can be given as arguments
973 // for /defaultlib option.
Rui Ueyamaea533cd2015-07-09 19:54:13 +0000974 std::vector<MemoryBufferRef> MBs;
Martin Storsjo8278ba52017-09-13 07:28:03 +0000975 for (auto *Arg : Args.filtered(OPT_INPUT, OPT_wholearchive_file)) {
976 switch (Arg->getOption().getID()) {
977 case OPT_INPUT:
978 if (Optional<StringRef> Path = findFile(Arg->getValue()))
979 enqueuePath(*Path, WholeArchiveFlag);
980 break;
981 case OPT_wholearchive_file:
982 if (Optional<StringRef> Path = findFile(Arg->getValue()))
983 enqueuePath(*Path, true);
984 break;
985 }
986 }
David Blaikie6521ed92015-06-22 22:06:52 +0000987 for (auto *Arg : Args.filtered(OPT_defaultlib))
Rui Ueyamad21b00b2015-05-31 19:17:14 +0000988 if (Optional<StringRef> Path = findLib(Arg->getValue()))
Martin Storsjo8278ba52017-09-13 07:28:03 +0000989 enqueuePath(*Path, false);
Rui Ueyamad21b00b2015-05-31 19:17:14 +0000990
Rui Ueyama24c5fd02015-06-18 00:12:42 +0000991 // Windows specific -- Create a resource file containing a manifest file.
Peter Collingbourne6ee0b4e2016-12-15 04:02:23 +0000992 if (Config->Manifest == Configuration::Embed)
Martin Storsjo8278ba52017-09-13 07:28:03 +0000993 addBuffer(createManifestRes(), false);
Rui Ueyama2bf6a122015-06-14 21:50:50 +0000994
Peter Collingbourne8b65e512016-12-11 22:15:25 +0000995 // Read all input files given via the command line.
Peter Collingbourne6ee0b4e2016-12-15 04:02:23 +0000996 run();
Rui Ueyama5cff6852015-05-31 03:34:08 +0000997
Peter Collingbourne8b65e512016-12-11 22:15:25 +0000998 // We should have inferred a machine type by now from the input files, but if
999 // not we assume x64.
Rui Ueyama5e706b32015-07-25 21:54:50 +00001000 if (Config->Machine == IMAGE_FILE_MACHINE_UNKNOWN) {
Rui Ueyamae6e206d2017-02-21 23:22:56 +00001001 warn("/machine is not specified. x64 is assumed");
Rui Ueyama5e706b32015-07-25 21:54:50 +00001002 Config->Machine = AMD64;
Rui Ueyamaea533cd2015-07-09 19:54:13 +00001003 }
1004
Eric Beckmann9e19d792017-06-17 02:26:27 +00001005 // Input files can be Windows resource files (.res files). We use
1006 // WindowsResource to convert resource files to a regular COFF file,
1007 // then link the resulting file normally.
Peter Collingbourne6ee0b4e2016-12-15 04:02:23 +00001008 if (!Resources.empty())
Martin Storsjo8278ba52017-09-13 07:28:03 +00001009 addBuffer(convertResToCOFF(Resources), false);
Rui Ueyamaea533cd2015-07-09 19:54:13 +00001010
Rui Ueyama7f1f9122017-01-06 02:33:53 +00001011 if (Tar)
1012 Tar->append("response.txt",
1013 createResponseFile(Args, FilePaths,
1014 ArrayRef<StringRef>(SearchPaths).slice(1)));
Peter Collingbournefeee2102016-07-26 02:00:42 +00001015
Rui Ueyama4d545342015-07-28 03:12:00 +00001016 // Handle /largeaddressaware
1017 if (Config->is64() || Args.hasArg(OPT_largeaddressaware))
1018 Config->LargeAddressAware = true;
1019
Rui Ueyamad68e2112015-07-28 03:15:57 +00001020 // Handle /highentropyva
1021 if (Config->is64() && !Args.hasArg(OPT_highentropyva_no))
1022 Config->HighEntropyVA = true;
1023
Rui Ueyamabbdec4f2015-07-09 22:51:41 +00001024 // Handle /entry and /dll
1025 if (auto *Arg = Args.getLastArg(OPT_entry)) {
1026 Config->Entry = addUndefined(mangle(Arg->getValue()));
1027 } else if (Args.hasArg(OPT_dll) && !Config->NoEntry) {
Rui Ueyama5e706b32015-07-25 21:54:50 +00001028 StringRef S = (Config->Machine == I386) ? "__DllMainCRTStartup@12"
1029 : "_DllMainCRTStartup";
Rui Ueyamabbdec4f2015-07-09 22:51:41 +00001030 Config->Entry = addUndefined(S);
1031 } else if (!Config->NoEntry) {
1032 // Windows specific -- If entry point name is not given, we need to
1033 // infer that from user-defined entry name.
Rui Ueyama45044f42015-06-29 01:03:53 +00001034 StringRef S = findDefaultEntry();
David Blaikie4cdfe692017-02-19 02:25:47 +00001035 if (S.empty())
1036 fatal("entry point must be defined");
1037 Config->Entry = addUndefined(S);
Rui Ueyamae6e206d2017-02-21 23:22:56 +00001038 log("Entry name inferred: " + S);
Rui Ueyama45044f42015-06-29 01:03:53 +00001039 }
1040
Rui Ueyamabbdec4f2015-07-09 22:51:41 +00001041 // Handle /export
1042 for (auto *Arg : Args.filtered(OPT_export)) {
Rafael Espindolab835ae82015-08-06 14:58:50 +00001043 Export E = parseExport(Arg->getValue());
Rui Ueyamaf10a3202015-08-31 08:43:21 +00001044 if (Config->Machine == I386) {
1045 if (!isDecorated(E.Name))
Rui Ueyama8d433d72016-12-08 21:27:09 +00001046 E.Name = Saver.save("_" + E.Name);
Rui Ueyamaf10a3202015-08-31 08:43:21 +00001047 if (!E.ExtName.empty() && !isDecorated(E.ExtName))
Rui Ueyama8d433d72016-12-08 21:27:09 +00001048 E.ExtName = Saver.save("_" + E.ExtName);
Rui Ueyamaf10a3202015-08-31 08:43:21 +00001049 }
Rafael Espindolab835ae82015-08-06 14:58:50 +00001050 Config->Exports.push_back(E);
Rui Ueyamabbdec4f2015-07-09 22:51:41 +00001051 }
1052
1053 // Handle /def
1054 if (auto *Arg = Args.getLastArg(OPT_deffile)) {
Rui Ueyamabbdec4f2015-07-09 22:51:41 +00001055 // parseModuleDefs mutates Config object.
Reid Kleckner146eb7a2017-06-02 17:53:06 +00001056 parseModuleDefs(Arg->getValue());
Rui Ueyamabbdec4f2015-07-09 22:51:41 +00001057 }
1058
Saleem Abdulrasoolbc7ff702017-06-15 20:39:58 +00001059 // Handle generation of import library from a def file.
1060 if (!Args.hasArgNoClaim(OPT_INPUT)) {
1061 fixupExports();
Saleem Abdulrasoolace2fa72017-07-19 02:01:27 +00001062 createImportLibrary(/*AsLib=*/true);
Saleem Abdulrasoolbc7ff702017-06-15 20:39:58 +00001063 exit(0);
1064 }
1065
Rui Ueyama6d249082015-07-13 22:31:45 +00001066 // Handle /delayload
1067 for (auto *Arg : Args.filtered(OPT_delayload)) {
1068 Config->DelayLoads.insert(StringRef(Arg->getValue()).lower());
Rui Ueyama5e706b32015-07-25 21:54:50 +00001069 if (Config->Machine == I386) {
Rui Ueyama6d249082015-07-13 22:31:45 +00001070 Config->DelayLoadHelper = addUndefined("___delayLoadHelper2@8");
Rui Ueyama35ccb0f2015-07-25 00:20:06 +00001071 } else {
1072 Config->DelayLoadHelper = addUndefined("__delayLoadHelper2");
Rui Ueyama6d249082015-07-13 22:31:45 +00001073 }
1074 }
1075
Reid Kleckner7668182e2017-03-21 00:12:51 +00001076 // Set default image name if neither /out or /def set it.
1077 if (Config->OutputFile.empty()) {
1078 Config->OutputFile =
Richard Smitha13714e2017-04-12 23:51:20 +00001079 getOutputPath((*Args.filtered(OPT_INPUT).begin())->getValue());
Reid Kleckner7668182e2017-03-21 00:12:51 +00001080 }
1081
Reid Kleckner13bdbfb2017-03-22 00:57:14 +00001082 // Put the PDB next to the image if no /pdb flag was passed.
1083 if (Config->Debug && Config->PDBPath.empty()) {
1084 Config->PDBPath = Config->OutputFile;
1085 sys::path::replace_extension(Config->PDBPath, ".pdb");
1086 }
1087
Reid Kleckner77d3aa42017-03-22 19:49:12 +00001088 // Disable PDB generation if the user requested it.
1089 if (Args.hasArg(OPT_nopdb))
1090 Config->PDBPath = "";
1091
Rui Ueyama5c437cd2015-07-25 21:42:33 +00001092 // Set default image base if /base is not given.
1093 if (Config->ImageBase == uint64_t(-1))
1094 Config->ImageBase = getDefaultImageBase();
1095
Rui Ueyamacbf969e2017-08-28 21:51:07 +00001096 Symtab->addSynthetic(mangle("__ImageBase"), nullptr);
Rui Ueyama5e706b32015-07-25 21:54:50 +00001097 if (Config->Machine == I386) {
Rui Ueyamacbf969e2017-08-28 21:51:07 +00001098 Symtab->addAbsolute("___safe_se_handler_table", 0);
1099 Symtab->addAbsolute("___safe_se_handler_count", 0);
Rui Ueyamacd3f99b2015-07-24 23:51:14 +00001100 }
Rui Ueyamabbdec4f2015-07-09 22:51:41 +00001101
Rui Ueyama107db552015-08-09 21:01:06 +00001102 // We do not support /guard:cf (control flow protection) yet.
1103 // Define CFG symbols anyway so that we can link MSVC 2015 CRT.
Rui Ueyamacbf969e2017-08-28 21:51:07 +00001104 Symtab->addAbsolute(mangle("__guard_fids_count"), 0);
1105 Symtab->addAbsolute(mangle("__guard_fids_table"), 0);
1106 Symtab->addAbsolute(mangle("__guard_flags"), 0x100);
1107 Symtab->addAbsolute(mangle("__guard_iat_count"), 0);
1108 Symtab->addAbsolute(mangle("__guard_iat_table"), 0);
1109 Symtab->addAbsolute(mangle("__guard_longjmp_count"), 0);
1110 Symtab->addAbsolute(mangle("__guard_longjmp_table"), 0);
Rui Ueyama107db552015-08-09 21:01:06 +00001111
Peter Collingbourne6ee0b4e2016-12-15 04:02:23 +00001112 // This code may add new undefined symbols to the link, which may enqueue more
1113 // symbol resolution tasks, so we need to continue executing tasks until we
1114 // converge.
1115 do {
1116 // Windows specific -- if entry point is not found,
1117 // search for its mangled names.
1118 if (Config->Entry)
Rui Ueyamacbf969e2017-08-28 21:51:07 +00001119 Symtab->mangleMaybe(Config->Entry);
Rui Ueyama85225b02015-07-02 03:15:15 +00001120
Peter Collingbourne6ee0b4e2016-12-15 04:02:23 +00001121 // Windows specific -- Make sure we resolve all dllexported symbols.
1122 for (Export &E : Config->Exports) {
1123 if (!E.ForwardTo.empty())
1124 continue;
1125 E.Sym = addUndefined(E.Name);
1126 if (!E.Directives)
Rui Ueyamacbf969e2017-08-28 21:51:07 +00001127 Symtab->mangleMaybe(E.Sym);
Peter Collingbourne6ee0b4e2016-12-15 04:02:23 +00001128 }
Rui Ueyama2edb35a2015-06-18 19:09:30 +00001129
Peter Collingbourne6ee0b4e2016-12-15 04:02:23 +00001130 // Add weak aliases. Weak aliases is a mechanism to give remaining
1131 // undefined symbols final chance to be resolved successfully.
1132 for (auto Pair : Config->AlternateNames) {
1133 StringRef From = Pair.first;
1134 StringRef To = Pair.second;
Rui Ueyamacbf969e2017-08-28 21:51:07 +00001135 Symbol *Sym = Symtab->find(From);
Peter Collingbourne6ee0b4e2016-12-15 04:02:23 +00001136 if (!Sym)
1137 continue;
1138 if (auto *U = dyn_cast<Undefined>(Sym->body()))
1139 if (!U->WeakAlias)
Rui Ueyamacbf969e2017-08-28 21:51:07 +00001140 U->WeakAlias = Symtab->addUndefined(To);
Peter Collingbourne6ee0b4e2016-12-15 04:02:23 +00001141 }
Peter Collingbourne8b65e512016-12-11 22:15:25 +00001142
Peter Collingbourne6ee0b4e2016-12-15 04:02:23 +00001143 // Windows specific -- if __load_config_used can be resolved, resolve it.
Rui Ueyamacbf969e2017-08-28 21:51:07 +00001144 if (Symtab->findUnderscore("_load_config_used"))
Peter Collingbourne6ee0b4e2016-12-15 04:02:23 +00001145 addUndefined(mangle("_load_config_used"));
1146 } while (run());
Peter Collingbourne8b65e512016-12-11 22:15:25 +00001147
Bob Haarmanac8f7fc2017-04-05 00:43:54 +00001148 if (ErrorCount)
1149 return;
1150
Rui Ueyama1e0b1582017-02-06 20:47:55 +00001151 // If /msvclto is given, we use the MSVC linker to link LTO output files.
1152 // This is useful because MSVC link.exe can generate complete PDBs.
1153 if (Args.hasArg(OPT_msvclto)) {
Rui Ueyama85d54b02017-02-23 00:26:42 +00001154 invokeMSVC(Args);
Rui Ueyama1e0b1582017-02-06 20:47:55 +00001155 exit(0);
1156 }
1157
Peter Collingbournedf5783b2015-08-28 22:16:09 +00001158 // Do LTO by compiling bitcode input files to a set of native COFF files then
1159 // link those files.
Rui Ueyamacbf969e2017-08-28 21:51:07 +00001160 Symtab->addCombinedLTOObjects();
Peter Collingbourne6ee0b4e2016-12-15 04:02:23 +00001161 run();
Peter Collingbourne60c16162015-06-01 20:10:10 +00001162
Peter Collingbourne2612a322015-07-04 05:28:41 +00001163 // Make sure we have resolved all symbols.
Rui Ueyamacbf969e2017-08-28 21:51:07 +00001164 Symtab->reportRemainingUndefines();
Peter Collingbourne2612a322015-07-04 05:28:41 +00001165
Rui Ueyama3ee0fe42015-05-31 03:55:46 +00001166 // Windows specific -- if no /subsystem is given, we need to infer
1167 // that from entry point name.
1168 if (Config->Subsystem == IMAGE_SUBSYSTEM_UNKNOWN) {
Rui Ueyama97dff9e2015-06-17 00:16:33 +00001169 Config->Subsystem = inferSubsystem();
Rafael Espindolab835ae82015-08-06 14:58:50 +00001170 if (Config->Subsystem == IMAGE_SUBSYSTEM_UNKNOWN)
Rui Ueyama60604792016-07-14 23:37:14 +00001171 fatal("subsystem must be defined");
Rui Ueyama3ee0fe42015-05-31 03:55:46 +00001172 }
1173
Rui Ueyamaff88d5a2015-07-29 20:25:40 +00001174 // Handle /safeseh.
Bob Haarmanac8f7fc2017-04-05 00:43:54 +00001175 if (Args.hasArg(OPT_safeseh)) {
Rui Ueyamaacd632d2017-07-27 00:45:26 +00001176 for (ObjFile *File : ObjFile::Instances)
Rui Ueyama13563d82015-09-15 00:33:11 +00001177 if (!File->SEHCompat)
Bob Haarmanac8f7fc2017-04-05 00:43:54 +00001178 error("/safeseh: " + File->getName() + " is not compatible with SEH");
1179 if (ErrorCount)
1180 return;
1181 }
Rui Ueyamaff88d5a2015-07-29 20:25:40 +00001182
Rui Ueyama151d8622015-06-17 20:40:43 +00001183 // Windows specific -- when we are creating a .dll file, we also
1184 // need to create a .lib file.
Rui Ueyama100ffac2015-09-01 09:15:58 +00001185 if (!Config->Exports.empty() || Config->DLL) {
Rafael Espindolab835ae82015-08-06 14:58:50 +00001186 fixupExports();
Saleem Abdulrasoolace2fa72017-07-19 02:01:27 +00001187 createImportLibrary(/*AsLib=*/false);
Rui Ueyama8765fba2015-07-15 22:21:08 +00001188 assignExportOrdinals();
1189 }
Rui Ueyama97dff9e2015-06-17 00:16:33 +00001190
Martin Storsjod2752aa2017-08-14 19:07:27 +00001191 // Set extra alignment for .comm symbols
1192 for (auto Pair : Config->AlignComm) {
1193 StringRef Name = Pair.first;
1194 int Align = Pair.second;
Rui Ueyamacbf969e2017-08-28 21:51:07 +00001195 Symbol *Sym = Symtab->find(Name);
Martin Storsjod2752aa2017-08-14 19:07:27 +00001196 if (!Sym) {
1197 warn("/aligncomm symbol " + Name + " not found");
1198 continue;
1199 }
1200 auto *DC = dyn_cast<DefinedCommon>(Sym->body());
1201 if (!DC) {
1202 warn("/aligncomm symbol " + Name + " of wrong kind");
1203 continue;
1204 }
1205 DC->getChunk()->setAlign(Align);
1206 }
1207
Rui Ueyama24c5fd02015-06-18 00:12:42 +00001208 // Windows specific -- Create a side-by-side manifest file.
1209 if (Config->Manifest == Configuration::SideBySide)
Rafael Espindolab835ae82015-08-06 14:58:50 +00001210 createSideBySideManifest();
Rui Ueyama24c5fd02015-06-18 00:12:42 +00001211
Rui Ueyamaa5f0f752015-09-19 21:36:28 +00001212 // Identify unreferenced COMDAT sections.
1213 if (Config->DoGC)
Rui Ueyamacbf969e2017-08-28 21:51:07 +00001214 markLive(Symtab->getChunks());
Rui Ueyamaa5f0f752015-09-19 21:36:28 +00001215
1216 // Identify identical COMDAT sections to merge them.
1217 if (Config->DoICF)
Rui Ueyamacbf969e2017-08-28 21:51:07 +00001218 doICF(Symtab->getChunks());
Rui Ueyamaa5f0f752015-09-19 21:36:28 +00001219
Rui Ueyama411c63602015-05-28 19:09:30 +00001220 // Write the result.
Rui Ueyamacbf969e2017-08-28 21:51:07 +00001221 writeResult();
Peter Collingbournebe549552015-06-26 18:58:24 +00001222
Rui Ueyamaa51ce712015-07-03 05:31:35 +00001223 // Call exit to avoid calling destructors.
1224 exit(0);
Rui Ueyama411c63602015-05-28 19:09:30 +00001225}
1226
Rui Ueyama411c63602015-05-28 19:09:30 +00001227} // namespace coff
1228} // namespace lld