[libc] Fix WrapperGen seeing no arguments as a void argument.
[lldb.git] / lld / MinGW / Driver.cpp
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:
80   MinGWOptTable() : OptTable(infoTable, false) {}
81   opt::InputArgList parse(ArrayRef<const char *> argv);
82 };
83 } // namespace
84
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
92 static cl::TokenizerCallback getQuotingStyle() {
93   if (Triple(sys::getProcessTriple()).getOS() == Triple::Win32)
94     return cl::TokenizeWindowsCommandLine;
95   return cl::TokenizeGNUCommandLine;
96 }
97
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.
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
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.
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 }