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 error("lld doesn't support linking directly against " + *s +
147 ", use an import library");
148 return "";
149 }
150 if (Optional<std::string> s = findFile(dir, name + ".dll")) {
151 error("lld doesn't support linking directly against " + *s +
152 ", use an import library");
153 return "";
154 }
155 }
156 }
157 error("unable to find library -l" + name);
158 return "";
159 }
160
161 // Convert Unix-ish command line arguments to Windows-ish ones and
162 // then call coff::link.
link(ArrayRef<const char * > argsArr,bool canExitEarly,raw_ostream & stdoutOS,raw_ostream & stderrOS)163 bool mingw::link(ArrayRef<const char *> argsArr, bool canExitEarly,
164 raw_ostream &stdoutOS, raw_ostream &stderrOS) {
165 lld::stdoutOS = &stdoutOS;
166 lld::stderrOS = &stderrOS;
167
168 stderrOS.enable_colors(stderrOS.has_colors());
169
170 MinGWOptTable parser;
171 opt::InputArgList args = parser.parse(argsArr.slice(1));
172
173 if (errorCount())
174 return false;
175
176 if (args.hasArg(OPT_help)) {
177 printHelp(argsArr[0]);
178 return true;
179 }
180
181 // A note about "compatible with GNU linkers" message: this is a hack for
182 // scripts generated by GNU Libtool 2.4.6 (released in February 2014 and
183 // still the newest version in March 2017) or earlier to recognize LLD as
184 // a GNU compatible linker. As long as an output for the -v option
185 // contains "GNU" or "with BFD", they recognize us as GNU-compatible.
186 if (args.hasArg(OPT_v) || args.hasArg(OPT_version))
187 message(getLLDVersion() + " (compatible with GNU linkers)");
188
189 // The behavior of -v or --version is a bit strange, but this is
190 // needed for compatibility with GNU linkers.
191 if (args.hasArg(OPT_v) && !args.hasArg(OPT_INPUT) && !args.hasArg(OPT_l))
192 return true;
193 if (args.hasArg(OPT_version))
194 return true;
195
196 if (!args.hasArg(OPT_INPUT) && !args.hasArg(OPT_l)) {
197 error("no input files");
198 return false;
199 }
200
201 std::vector<std::string> linkArgs;
202 auto add = [&](const Twine &s) { linkArgs.push_back(s.str()); };
203
204 add("lld-link");
205 add("-lldmingw");
206
207 if (auto *a = args.getLastArg(OPT_entry)) {
208 StringRef s = a->getValue();
209 if (args.getLastArgValue(OPT_m) == "i386pe" && s.startswith("_"))
210 add("-entry:" + s.substr(1));
211 else
212 add("-entry:" + s);
213 }
214
215 if (args.hasArg(OPT_major_os_version, OPT_minor_os_version,
216 OPT_major_subsystem_version, OPT_minor_subsystem_version)) {
217 StringRef majOSVer = args.getLastArgValue(OPT_major_os_version, "6");
218 StringRef minOSVer = args.getLastArgValue(OPT_minor_os_version, "0");
219 StringRef majSubSysVer = "6";
220 StringRef minSubSysVer = "0";
221 StringRef subSysName = "default";
222 StringRef subSysVer;
223 // Iterate over --{major,minor}-subsystem-version and --subsystem, and pick
224 // the version number components from the last one of them that specifies
225 // a version.
226 for (auto *a : args.filtered(OPT_major_subsystem_version,
227 OPT_minor_subsystem_version, OPT_subs)) {
228 switch (a->getOption().getID()) {
229 case OPT_major_subsystem_version:
230 majSubSysVer = a->getValue();
231 break;
232 case OPT_minor_subsystem_version:
233 minSubSysVer = a->getValue();
234 break;
235 case OPT_subs:
236 std::tie(subSysName, subSysVer) = StringRef(a->getValue()).split(':');
237 if (!subSysVer.empty()) {
238 if (subSysVer.contains('.'))
239 std::tie(majSubSysVer, minSubSysVer) = subSysVer.split('.');
240 else
241 majSubSysVer = subSysVer;
242 }
243 break;
244 }
245 }
246 add("-osversion:" + majOSVer + "." + minOSVer);
247 add("-subsystem:" + subSysName + "," + majSubSysVer + "." + minSubSysVer);
248 } else if (args.hasArg(OPT_subs)) {
249 StringRef subSys = args.getLastArgValue(OPT_subs, "default");
250 StringRef subSysName, subSysVer;
251 std::tie(subSysName, subSysVer) = subSys.split(':');
252 StringRef sep = subSysVer.empty() ? "" : ",";
253 add("-subsystem:" + subSysName + sep + subSysVer);
254 }
255
256 if (auto *a = args.getLastArg(OPT_out_implib))
257 add("-implib:" + StringRef(a->getValue()));
258 if (auto *a = args.getLastArg(OPT_stack))
259 add("-stack:" + StringRef(a->getValue()));
260 if (auto *a = args.getLastArg(OPT_output_def))
261 add("-output-def:" + StringRef(a->getValue()));
262 if (auto *a = args.getLastArg(OPT_image_base))
263 add("-base:" + StringRef(a->getValue()));
264 if (auto *a = args.getLastArg(OPT_map))
265 add("-lldmap:" + StringRef(a->getValue()));
266 if (auto *a = args.getLastArg(OPT_reproduce))
267 add("-reproduce:" + StringRef(a->getValue()));
268 if (auto *a = args.getLastArg(OPT_thinlto_cache_dir))
269 add("-lldltocache:" + StringRef(a->getValue()));
270 if (auto *a = args.getLastArg(OPT_file_alignment))
271 add("-filealign:" + StringRef(a->getValue()));
272 if (auto *a = args.getLastArg(OPT_section_alignment))
273 add("-align:" + StringRef(a->getValue()));
274
275 if (auto *a = args.getLastArg(OPT_o))
276 add("-out:" + StringRef(a->getValue()));
277 else if (args.hasArg(OPT_shared))
278 add("-out:a.dll");
279 else
280 add("-out:a.exe");
281
282 if (auto *a = args.getLastArg(OPT_pdb)) {
283 add("-debug");
284 StringRef v = a->getValue();
285 if (!v.empty())
286 add("-pdb:" + v);
287 } else if (args.hasArg(OPT_strip_debug)) {
288 add("-debug:symtab");
289 } else if (!args.hasArg(OPT_strip_all)) {
290 add("-debug:dwarf");
291 }
292
293 if (args.hasArg(OPT_shared))
294 add("-dll");
295 if (args.hasArg(OPT_verbose))
296 add("-verbose");
297 if (args.hasArg(OPT_exclude_all_symbols))
298 add("-exclude-all-symbols");
299 if (args.hasArg(OPT_export_all_symbols))
300 add("-export-all-symbols");
301 if (args.hasArg(OPT_large_address_aware))
302 add("-largeaddressaware");
303 if (args.hasArg(OPT_kill_at))
304 add("-kill-at");
305 if (args.hasArg(OPT_appcontainer))
306 add("-appcontainer");
307 if (args.hasArg(OPT_no_seh))
308 add("-noseh");
309
310 if (args.getLastArgValue(OPT_m) != "thumb2pe" &&
311 args.getLastArgValue(OPT_m) != "arm64pe" &&
312 args.hasArg(OPT_no_dynamicbase))
313 add("-dynamicbase:no");
314
315 if (args.hasFlag(OPT_no_insert_timestamp, OPT_insert_timestamp, false))
316 add("-timestamp:0");
317
318 if (args.hasFlag(OPT_gc_sections, OPT_no_gc_sections, false))
319 add("-opt:ref");
320 else
321 add("-opt:noref");
322
323 if (args.hasFlag(OPT_enable_auto_import, OPT_disable_auto_import, true))
324 add("-auto-import");
325 else
326 add("-auto-import:no");
327 if (args.hasFlag(OPT_enable_runtime_pseudo_reloc,
328 OPT_disable_runtime_pseudo_reloc, true))
329 add("-runtime-pseudo-reloc");
330 else
331 add("-runtime-pseudo-reloc:no");
332
333 if (args.hasFlag(OPT_allow_multiple_definition,
334 OPT_no_allow_multiple_definition, false))
335 add("-force:multiple");
336
337 if (auto *a = args.getLastArg(OPT_icf)) {
338 StringRef s = a->getValue();
339 if (s == "all")
340 add("-opt:icf");
341 else if (s == "safe" || s == "none")
342 add("-opt:noicf");
343 else
344 error("unknown parameter: --icf=" + s);
345 } else {
346 add("-opt:noicf");
347 }
348
349 if (auto *a = args.getLastArg(OPT_m)) {
350 StringRef s = a->getValue();
351 if (s == "i386pe")
352 add("-machine:x86");
353 else if (s == "i386pep")
354 add("-machine:x64");
355 else if (s == "thumb2pe")
356 add("-machine:arm");
357 else if (s == "arm64pe")
358 add("-machine:arm64");
359 else
360 error("unknown parameter: -m" + s);
361 }
362
363 for (auto *a : args.filtered(OPT_mllvm))
364 add("-mllvm:" + StringRef(a->getValue()));
365
366 for (auto *a : args.filtered(OPT_Xlink))
367 add(a->getValue());
368
369 if (args.getLastArgValue(OPT_m) == "i386pe")
370 add("-alternatename:__image_base__=___ImageBase");
371 else
372 add("-alternatename:__image_base__=__ImageBase");
373
374 for (auto *a : args.filtered(OPT_require_defined))
375 add("-include:" + StringRef(a->getValue()));
376 for (auto *a : args.filtered(OPT_undefined))
377 add("-includeoptional:" + StringRef(a->getValue()));
378 for (auto *a : args.filtered(OPT_delayload))
379 add("-delayload:" + StringRef(a->getValue()));
380 for (auto *a : args.filtered(OPT_wrap))
381 add("-wrap:" + StringRef(a->getValue()));
382
383 std::vector<StringRef> searchPaths;
384 for (auto *a : args.filtered(OPT_L)) {
385 searchPaths.push_back(a->getValue());
386 add("-libpath:" + StringRef(a->getValue()));
387 }
388
389 StringRef prefix = "";
390 bool isStatic = false;
391 for (auto *a : args) {
392 switch (a->getOption().getID()) {
393 case OPT_INPUT:
394 if (StringRef(a->getValue()).endswith_lower(".def"))
395 add("-def:" + StringRef(a->getValue()));
396 else
397 add(prefix + StringRef(a->getValue()));
398 break;
399 case OPT_l:
400 add(prefix + searchLibrary(a->getValue(), searchPaths, isStatic));
401 break;
402 case OPT_whole_archive:
403 prefix = "-wholearchive:";
404 break;
405 case OPT_no_whole_archive:
406 prefix = "";
407 break;
408 case OPT_Bstatic:
409 isStatic = true;
410 break;
411 case OPT_Bdynamic:
412 isStatic = false;
413 break;
414 }
415 }
416
417 if (errorCount())
418 return false;
419
420 if (args.hasArg(OPT_verbose) || args.hasArg(OPT__HASH_HASH_HASH))
421 lld::outs() << llvm::join(linkArgs, " ") << "\n";
422
423 if (args.hasArg(OPT__HASH_HASH_HASH))
424 return true;
425
426 // Repack vector of strings to vector of const char pointers for coff::link.
427 std::vector<const char *> vec;
428 for (const std::string &s : linkArgs)
429 vec.push_back(s.c_str());
430 return coff::link(vec, true, stdoutOS, stderrOS);
431 }
432