1 //===- MinGW/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 // MinGW is a GNU development environment for Windows. It consists of GNU
10 // tools such as GCC and GNU ld. Unlike Cygwin, there's no POSIX-compatible
11 // layer, as it aims to be a native development toolchain.
12 //
13 // lld/MinGW is a drop-in replacement for GNU ld/MinGW.
14 //
15 // Being a native development tool, a MinGW linker is not very different from
16 // Microsoft link.exe, so a MinGW linker can be implemented as a thin wrapper
17 // for lld/COFF. This driver takes Unix-ish command line options, translates
18 // them to Windows-ish ones, and then passes them to lld/COFF.
19 //
20 // When this driver calls the lld/COFF driver, it passes a hidden option
21 // "-lldmingw" along with other user-supplied options, to run the lld/COFF
22 // linker in "MinGW mode".
23 //
24 // There are subtle differences between MS link.exe and GNU ld/MinGW, and GNU
25 // ld/MinGW implements a few GNU-specific features. Such features are directly
26 // implemented in lld/COFF and enabled only when the linker is running in MinGW
27 // mode.
28 //
29 //===----------------------------------------------------------------------===//
30
31 #include "lld/Common/Driver.h"
32 #include "lld/Common/ErrorHandler.h"
33 #include "lld/Common/Memory.h"
34 #include "lld/Common/Version.h"
35 #include "llvm/ADT/ArrayRef.h"
36 #include "llvm/ADT/Optional.h"
37 #include "llvm/ADT/StringExtras.h"
38 #include "llvm/ADT/StringRef.h"
39 #include "llvm/ADT/Triple.h"
40 #include "llvm/Option/Arg.h"
41 #include "llvm/Option/ArgList.h"
42 #include "llvm/Option/Option.h"
43 #include "llvm/Support/CommandLine.h"
44 #include "llvm/Support/FileSystem.h"
45 #include "llvm/Support/Host.h"
46 #include "llvm/Support/Path.h"
47
48 #if !defined(_MSC_VER) && !defined(__MINGW32__)
49 #include <unistd.h>
50 #endif
51
52 using namespace lld;
53 using namespace llvm;
54
55 // Create OptTable
56 enum {
57 OPT_INVALID = 0,
58 #define OPTION(_1, _2, ID, _4, _5, _6, _7, _8, _9, _10, _11, _12) OPT_##ID,
59 #include "Options.inc"
60 #undef OPTION
61 };
62
63 // Create prefix string literals used in Options.td
64 #define PREFIX(NAME, VALUE) static const char *const NAME[] = VALUE;
65 #include "Options.inc"
66 #undef PREFIX
67
68 // Create table mapping all options defined in Options.td
69 static const opt::OptTable::Info infoTable[] = {
70 #define OPTION(X1, X2, ID, KIND, GROUP, ALIAS, X7, X8, X9, X10, X11, X12) \
71 {X1, X2, X10, X11, OPT_##ID, opt::Option::KIND##Class, \
72 X9, X8, OPT_##GROUP, OPT_##ALIAS, X7, X12},
73 #include "Options.inc"
74 #undef OPTION
75 };
76
77 namespace {
78 class MinGWOptTable : public opt::OptTable {
79 public:
MinGWOptTable()80 MinGWOptTable() : OptTable(infoTable, false) {}
81 opt::InputArgList parse(ArrayRef<const char *> argv);
82 };
83 } // namespace
84
printHelp(const char * argv0)85 static void printHelp(const char *argv0) {
86 MinGWOptTable().printHelp(
87 lld::outs(), (std::string(argv0) + " [options] file...").c_str(), "lld",
88 false /*ShowHidden*/, true /*ShowAllAliases*/);
89 lld::outs() << "\n";
90 }
91
getQuotingStyle()92 static cl::TokenizerCallback getQuotingStyle() {
93 if (Triple(sys::getProcessTriple()).getOS() == Triple::Win32)
94 return cl::TokenizeWindowsCommandLine;
95 return cl::TokenizeGNUCommandLine;
96 }
97
parse(ArrayRef<const char * > argv)98 opt::InputArgList MinGWOptTable::parse(ArrayRef<const char *> argv) {
99 unsigned missingIndex;
100 unsigned missingCount;
101
102 SmallVector<const char *, 256> vec(argv.data(), argv.data() + argv.size());
103 cl::ExpandResponseFiles(saver(), getQuotingStyle(), vec);
104 opt::InputArgList args = this->ParseArgs(vec, missingIndex, missingCount);
105
106 if (missingCount)
107 error(StringRef(args.getArgString(missingIndex)) + ": missing argument");
108 for (auto *arg : args.filtered(OPT_UNKNOWN))
109 error("unknown argument: " + arg->getAsString(args));
110 return args;
111 }
112
113 // Find a file by concatenating given paths.
findFile(StringRef path1,const Twine & path2)114 static Optional<std::string> findFile(StringRef path1, const Twine &path2) {
115 SmallString<128> s;
116 sys::path::append(s, path1, path2);
117 if (sys::fs::exists(s))
118 return std::string(s);
119 return None;
120 }
121
122 // This is for -lfoo. We'll look for libfoo.dll.a or libfoo.a from search paths.
123 static std::string
searchLibrary(StringRef name,ArrayRef<StringRef> searchPaths,bool bStatic)124 searchLibrary(StringRef name, ArrayRef<StringRef> searchPaths, bool bStatic) {
125 if (name.startswith(":")) {
126 for (StringRef dir : searchPaths)
127 if (Optional<std::string> s = findFile(dir, name.substr(1)))
128 return *s;
129 error("unable to find library -l" + name);
130 return "";
131 }
132
133 for (StringRef dir : searchPaths) {
134 if (!bStatic) {
135 if (Optional<std::string> s = findFile(dir, "lib" + name + ".dll.a"))
136 return *s;
137 if (Optional<std::string> s = findFile(dir, name + ".dll.a"))
138 return *s;
139 }
140 if (Optional<std::string> s = findFile(dir, "lib" + name + ".a"))
141 return *s;
142 if (!bStatic) {
143 if (Optional<std::string> s = findFile(dir, name + ".lib"))
144 return *s;
145 if (Optional<std::string> s = findFile(dir, "lib" + name + ".dll"))
146 return *s;
147 if (Optional<std::string> s = findFile(dir, name + ".dll"))
148 return *s;
149 }
150 }
151 error("unable to find library -l" + name);
152 return "";
153 }
154
155 // Convert Unix-ish command line arguments to Windows-ish ones and
156 // then call coff::link.
link(ArrayRef<const char * > argsArr,llvm::raw_ostream & stdoutOS,llvm::raw_ostream & stderrOS,bool exitEarly,bool disableOutput)157 bool mingw::link(ArrayRef<const char *> argsArr, llvm::raw_ostream &stdoutOS,
158 llvm::raw_ostream &stderrOS, bool exitEarly,
159 bool disableOutput) {
160 auto *ctx = new CommonLinkerContext;
161 ctx->e.initialize(stdoutOS, stderrOS, exitEarly, disableOutput);
162
163 MinGWOptTable parser;
164 opt::InputArgList args = parser.parse(argsArr.slice(1));
165
166 if (errorCount())
167 return false;
168
169 if (args.hasArg(OPT_help)) {
170 printHelp(argsArr[0]);
171 return true;
172 }
173
174 // A note about "compatible with GNU linkers" message: this is a hack for
175 // scripts generated by GNU Libtool 2.4.6 (released in February 2014 and
176 // still the newest version in March 2017) or earlier to recognize LLD as
177 // a GNU compatible linker. As long as an output for the -v option
178 // contains "GNU" or "with BFD", they recognize us as GNU-compatible.
179 if (args.hasArg(OPT_v) || args.hasArg(OPT_version))
180 message(getLLDVersion() + " (compatible with GNU linkers)");
181
182 // The behavior of -v or --version is a bit strange, but this is
183 // needed for compatibility with GNU linkers.
184 if (args.hasArg(OPT_v) && !args.hasArg(OPT_INPUT) && !args.hasArg(OPT_l))
185 return true;
186 if (args.hasArg(OPT_version))
187 return true;
188
189 if (!args.hasArg(OPT_INPUT) && !args.hasArg(OPT_l)) {
190 error("no input files");
191 return false;
192 }
193
194 std::vector<std::string> linkArgs;
195 auto add = [&](const Twine &s) { linkArgs.push_back(s.str()); };
196
197 add("lld-link");
198 add("-lldmingw");
199
200 if (auto *a = args.getLastArg(OPT_entry)) {
201 StringRef s = a->getValue();
202 if (args.getLastArgValue(OPT_m) == "i386pe" && s.startswith("_"))
203 add("-entry:" + s.substr(1));
204 else
205 add("-entry:" + s);
206 }
207
208 if (args.hasArg(OPT_major_os_version, OPT_minor_os_version,
209 OPT_major_subsystem_version, OPT_minor_subsystem_version)) {
210 StringRef majOSVer = args.getLastArgValue(OPT_major_os_version, "6");
211 StringRef minOSVer = args.getLastArgValue(OPT_minor_os_version, "0");
212 StringRef majSubSysVer = "6";
213 StringRef minSubSysVer = "0";
214 StringRef subSysName = "default";
215 StringRef subSysVer;
216 // Iterate over --{major,minor}-subsystem-version and --subsystem, and pick
217 // the version number components from the last one of them that specifies
218 // a version.
219 for (auto *a : args.filtered(OPT_major_subsystem_version,
220 OPT_minor_subsystem_version, OPT_subs)) {
221 switch (a->getOption().getID()) {
222 case OPT_major_subsystem_version:
223 majSubSysVer = a->getValue();
224 break;
225 case OPT_minor_subsystem_version:
226 minSubSysVer = a->getValue();
227 break;
228 case OPT_subs:
229 std::tie(subSysName, subSysVer) = StringRef(a->getValue()).split(':');
230 if (!subSysVer.empty()) {
231 if (subSysVer.contains('.'))
232 std::tie(majSubSysVer, minSubSysVer) = subSysVer.split('.');
233 else
234 majSubSysVer = subSysVer;
235 }
236 break;
237 }
238 }
239 add("-osversion:" + majOSVer + "." + minOSVer);
240 add("-subsystem:" + subSysName + "," + majSubSysVer + "." + minSubSysVer);
241 } else if (args.hasArg(OPT_subs)) {
242 StringRef subSys = args.getLastArgValue(OPT_subs, "default");
243 StringRef subSysName, subSysVer;
244 std::tie(subSysName, subSysVer) = subSys.split(':');
245 StringRef sep = subSysVer.empty() ? "" : ",";
246 add("-subsystem:" + subSysName + sep + subSysVer);
247 }
248
249 if (auto *a = args.getLastArg(OPT_out_implib))
250 add("-implib:" + StringRef(a->getValue()));
251 if (auto *a = args.getLastArg(OPT_stack))
252 add("-stack:" + StringRef(a->getValue()));
253 if (auto *a = args.getLastArg(OPT_output_def))
254 add("-output-def:" + StringRef(a->getValue()));
255 if (auto *a = args.getLastArg(OPT_image_base))
256 add("-base:" + StringRef(a->getValue()));
257 if (auto *a = args.getLastArg(OPT_map))
258 add("-lldmap:" + StringRef(a->getValue()));
259 if (auto *a = args.getLastArg(OPT_reproduce))
260 add("-reproduce:" + StringRef(a->getValue()));
261 if (auto *a = args.getLastArg(OPT_thinlto_cache_dir))
262 add("-lldltocache:" + StringRef(a->getValue()));
263 if (auto *a = args.getLastArg(OPT_file_alignment))
264 add("-filealign:" + StringRef(a->getValue()));
265 if (auto *a = args.getLastArg(OPT_section_alignment))
266 add("-align:" + StringRef(a->getValue()));
267 if (auto *a = args.getLastArg(OPT_heap))
268 add("-heap:" + StringRef(a->getValue()));
269
270 if (auto *a = args.getLastArg(OPT_o))
271 add("-out:" + StringRef(a->getValue()));
272 else if (args.hasArg(OPT_shared))
273 add("-out:a.dll");
274 else
275 add("-out:a.exe");
276
277 if (auto *a = args.getLastArg(OPT_pdb)) {
278 add("-debug");
279 StringRef v = a->getValue();
280 if (!v.empty())
281 add("-pdb:" + v);
282 } else if (args.hasArg(OPT_strip_debug)) {
283 add("-debug:symtab");
284 } else if (!args.hasArg(OPT_strip_all)) {
285 add("-debug:dwarf");
286 }
287
288 if (args.hasFlag(OPT_fatal_warnings, OPT_no_fatal_warnings, false))
289 add("-WX");
290 else
291 add("-WX:no");
292
293 if (args.hasFlag(OPT_enable_stdcall_fixup, OPT_disable_stdcall_fixup, false))
294 add("-stdcall-fixup");
295 else if (args.hasArg(OPT_disable_stdcall_fixup))
296 add("-stdcall-fixup:no");
297
298 if (args.hasArg(OPT_shared))
299 add("-dll");
300 if (args.hasArg(OPT_verbose))
301 add("-verbose");
302 if (args.hasArg(OPT_exclude_all_symbols))
303 add("-exclude-all-symbols");
304 if (args.hasArg(OPT_export_all_symbols))
305 add("-export-all-symbols");
306 if (args.hasArg(OPT_large_address_aware))
307 add("-largeaddressaware");
308 if (args.hasArg(OPT_kill_at))
309 add("-kill-at");
310 if (args.hasArg(OPT_appcontainer))
311 add("-appcontainer");
312 if (args.hasFlag(OPT_no_seh, OPT_disable_no_seh, false))
313 add("-noseh");
314
315 if (args.getLastArgValue(OPT_m) != "thumb2pe" &&
316 args.getLastArgValue(OPT_m) != "arm64pe" &&
317 args.hasFlag(OPT_disable_dynamicbase, OPT_dynamicbase, false))
318 add("-dynamicbase:no");
319 if (args.hasFlag(OPT_disable_high_entropy_va, OPT_high_entropy_va, false))
320 add("-highentropyva:no");
321 if (args.hasFlag(OPT_disable_nxcompat, OPT_nxcompat, false))
322 add("-nxcompat:no");
323 if (args.hasFlag(OPT_disable_tsaware, OPT_tsaware, false))
324 add("-tsaware:no");
325
326 if (args.hasFlag(OPT_disable_reloc_section, OPT_enable_reloc_section, false))
327 add("-fixed");
328
329 if (args.hasFlag(OPT_no_insert_timestamp, OPT_insert_timestamp, false))
330 add("-timestamp:0");
331
332 if (args.hasFlag(OPT_gc_sections, OPT_no_gc_sections, false))
333 add("-opt:ref");
334 else
335 add("-opt:noref");
336
337 if (args.hasFlag(OPT_demangle, OPT_no_demangle, true))
338 add("-demangle");
339 else
340 add("-demangle:no");
341
342 if (args.hasFlag(OPT_enable_auto_import, OPT_disable_auto_import, true))
343 add("-auto-import");
344 else
345 add("-auto-import:no");
346 if (args.hasFlag(OPT_enable_runtime_pseudo_reloc,
347 OPT_disable_runtime_pseudo_reloc, true))
348 add("-runtime-pseudo-reloc");
349 else
350 add("-runtime-pseudo-reloc:no");
351
352 if (args.hasFlag(OPT_allow_multiple_definition,
353 OPT_no_allow_multiple_definition, false))
354 add("-force:multiple");
355
356 if (auto *a = args.getLastArg(OPT_icf)) {
357 StringRef s = a->getValue();
358 if (s == "all")
359 add("-opt:icf");
360 else if (s == "safe" || s == "none")
361 add("-opt:noicf");
362 else
363 error("unknown parameter: --icf=" + s);
364 } else {
365 add("-opt:noicf");
366 }
367
368 if (auto *a = args.getLastArg(OPT_m)) {
369 StringRef s = a->getValue();
370 if (s == "i386pe")
371 add("-machine:x86");
372 else if (s == "i386pep")
373 add("-machine:x64");
374 else if (s == "thumb2pe")
375 add("-machine:arm");
376 else if (s == "arm64pe")
377 add("-machine:arm64");
378 else
379 error("unknown parameter: -m" + s);
380 }
381
382 for (auto *a : args.filtered(OPT_mllvm))
383 add("-mllvm:" + StringRef(a->getValue()));
384
385 for (auto *a : args.filtered(OPT_Xlink))
386 add(a->getValue());
387
388 if (args.getLastArgValue(OPT_m) == "i386pe")
389 add("-alternatename:__image_base__=___ImageBase");
390 else
391 add("-alternatename:__image_base__=__ImageBase");
392
393 for (auto *a : args.filtered(OPT_require_defined))
394 add("-include:" + StringRef(a->getValue()));
395 for (auto *a : args.filtered(OPT_undefined))
396 add("-includeoptional:" + StringRef(a->getValue()));
397 for (auto *a : args.filtered(OPT_delayload))
398 add("-delayload:" + StringRef(a->getValue()));
399 for (auto *a : args.filtered(OPT_wrap))
400 add("-wrap:" + StringRef(a->getValue()));
401 for (auto *a : args.filtered(OPT_exclude_symbols))
402 add("-exclude-symbols:" + StringRef(a->getValue()));
403
404 std::vector<StringRef> searchPaths;
405 for (auto *a : args.filtered(OPT_L)) {
406 searchPaths.push_back(a->getValue());
407 add("-libpath:" + StringRef(a->getValue()));
408 }
409
410 StringRef prefix = "";
411 bool isStatic = false;
412 for (auto *a : args) {
413 switch (a->getOption().getID()) {
414 case OPT_INPUT:
415 if (StringRef(a->getValue()).endswith_insensitive(".def"))
416 add("-def:" + StringRef(a->getValue()));
417 else
418 add(prefix + StringRef(a->getValue()));
419 break;
420 case OPT_l:
421 add(prefix + searchLibrary(a->getValue(), searchPaths, isStatic));
422 break;
423 case OPT_whole_archive:
424 prefix = "-wholearchive:";
425 break;
426 case OPT_no_whole_archive:
427 prefix = "";
428 break;
429 case OPT_Bstatic:
430 isStatic = true;
431 break;
432 case OPT_Bdynamic:
433 isStatic = false;
434 break;
435 }
436 }
437
438 if (errorCount())
439 return false;
440
441 if (args.hasArg(OPT_verbose) || args.hasArg(OPT__HASH_HASH_HASH))
442 lld::errs() << llvm::join(linkArgs, " ") << "\n";
443
444 if (args.hasArg(OPT__HASH_HASH_HASH))
445 return true;
446
447 // Repack vector of strings to vector of const char pointers for coff::link.
448 std::vector<const char *> vec;
449 for (const std::string &s : linkArgs)
450 vec.push_back(s.c_str());
451 // Pass the actual binary name, to make error messages be printed with
452 // the right prefix.
453 vec[0] = argsArr[0];
454
455 // The context will be re-created in the COFF driver.
456 lld::CommonLinkerContext::destroy();
457
458 return coff::link(vec, stdoutOS, stderrOS, exitEarly, disableOutput);
459 }
460