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 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. 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_no_insert_timestamp, OPT_insert_timestamp, false)) 327 add("-timestamp:0"); 328 329 if (args.hasFlag(OPT_gc_sections, OPT_no_gc_sections, false)) 330 add("-opt:ref"); 331 else 332 add("-opt:noref"); 333 334 if (args.hasFlag(OPT_demangle, OPT_no_demangle, true)) 335 add("-demangle"); 336 else 337 add("-demangle:no"); 338 339 if (args.hasFlag(OPT_enable_auto_import, OPT_disable_auto_import, true)) 340 add("-auto-import"); 341 else 342 add("-auto-import:no"); 343 if (args.hasFlag(OPT_enable_runtime_pseudo_reloc, 344 OPT_disable_runtime_pseudo_reloc, true)) 345 add("-runtime-pseudo-reloc"); 346 else 347 add("-runtime-pseudo-reloc:no"); 348 349 if (args.hasFlag(OPT_allow_multiple_definition, 350 OPT_no_allow_multiple_definition, false)) 351 add("-force:multiple"); 352 353 if (auto *a = args.getLastArg(OPT_icf)) { 354 StringRef s = a->getValue(); 355 if (s == "all") 356 add("-opt:icf"); 357 else if (s == "safe" || s == "none") 358 add("-opt:noicf"); 359 else 360 error("unknown parameter: --icf=" + s); 361 } else { 362 add("-opt:noicf"); 363 } 364 365 if (auto *a = args.getLastArg(OPT_m)) { 366 StringRef s = a->getValue(); 367 if (s == "i386pe") 368 add("-machine:x86"); 369 else if (s == "i386pep") 370 add("-machine:x64"); 371 else if (s == "thumb2pe") 372 add("-machine:arm"); 373 else if (s == "arm64pe") 374 add("-machine:arm64"); 375 else 376 error("unknown parameter: -m" + s); 377 } 378 379 for (auto *a : args.filtered(OPT_mllvm)) 380 add("-mllvm:" + StringRef(a->getValue())); 381 382 for (auto *a : args.filtered(OPT_Xlink)) 383 add(a->getValue()); 384 385 if (args.getLastArgValue(OPT_m) == "i386pe") 386 add("-alternatename:__image_base__=___ImageBase"); 387 else 388 add("-alternatename:__image_base__=__ImageBase"); 389 390 for (auto *a : args.filtered(OPT_require_defined)) 391 add("-include:" + StringRef(a->getValue())); 392 for (auto *a : args.filtered(OPT_undefined)) 393 add("-includeoptional:" + StringRef(a->getValue())); 394 for (auto *a : args.filtered(OPT_delayload)) 395 add("-delayload:" + StringRef(a->getValue())); 396 for (auto *a : args.filtered(OPT_wrap)) 397 add("-wrap:" + StringRef(a->getValue())); 398 399 std::vector<StringRef> searchPaths; 400 for (auto *a : args.filtered(OPT_L)) { 401 searchPaths.push_back(a->getValue()); 402 add("-libpath:" + StringRef(a->getValue())); 403 } 404 405 StringRef prefix = ""; 406 bool isStatic = false; 407 for (auto *a : args) { 408 switch (a->getOption().getID()) { 409 case OPT_INPUT: 410 if (StringRef(a->getValue()).endswith_insensitive(".def")) 411 add("-def:" + StringRef(a->getValue())); 412 else 413 add(prefix + StringRef(a->getValue())); 414 break; 415 case OPT_l: 416 add(prefix + searchLibrary(a->getValue(), searchPaths, isStatic)); 417 break; 418 case OPT_whole_archive: 419 prefix = "-wholearchive:"; 420 break; 421 case OPT_no_whole_archive: 422 prefix = ""; 423 break; 424 case OPT_Bstatic: 425 isStatic = true; 426 break; 427 case OPT_Bdynamic: 428 isStatic = false; 429 break; 430 } 431 } 432 433 if (errorCount()) 434 return false; 435 436 if (args.hasArg(OPT_verbose) || args.hasArg(OPT__HASH_HASH_HASH)) 437 lld::errs() << llvm::join(linkArgs, " ") << "\n"; 438 439 if (args.hasArg(OPT__HASH_HASH_HASH)) 440 return true; 441 442 // Repack vector of strings to vector of const char pointers for coff::link. 443 std::vector<const char *> vec; 444 for (const std::string &s : linkArgs) 445 vec.push_back(s.c_str()); 446 // Pass the actual binary name, to make error messages be printed with 447 // the right prefix. 448 vec[0] = argsArr[0]; 449 450 // The context will be re-created in the COFF driver. 451 lld::CommonLinkerContext::destroy(); 452 453 return coff::link(vec, stdoutOS, stderrOS, exitEarly, disableOutput); 454 } 455