1 //===- DriverDispatcher.cpp - Support using LLD as a library --------------===// 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 #include "lld/Common/CommonLinkerContext.h" 10 #include "lld/Common/Driver.h" 11 #include "lld/Common/ErrorHandler.h" 12 #include "lld/Common/Memory.h" 13 #include "llvm/ADT/STLExtras.h" 14 #include "llvm/ADT/SmallVector.h" 15 #include "llvm/ADT/StringSwitch.h" 16 #include "llvm/ADT/Twine.h" 17 #include "llvm/Support/CommandLine.h" 18 #include "llvm/Support/CrashRecoveryContext.h" 19 #include "llvm/Support/Path.h" 20 #include "llvm/Support/Process.h" 21 #include "llvm/TargetParser/Host.h" 22 #include "llvm/TargetParser/Triple.h" 23 #include <cstdlib> 24 25 using namespace lld; 26 using namespace llvm; 27 using namespace llvm::sys; 28 29 static void err(const Twine &s) { llvm::errs() << s << "\n"; } 30 31 static Flavor getFlavor(StringRef s) { 32 return StringSwitch<Flavor>(s) 33 .CasesLower("ld", "ld.lld", "gnu", Gnu) 34 .CasesLower("wasm", "ld-wasm", Wasm) 35 .CaseLower("link", WinLink) 36 .CasesLower("ld64", "ld64.lld", "darwin", Darwin) 37 .Default(Invalid); 38 } 39 40 static cl::TokenizerCallback getDefaultQuotingStyle() { 41 if (Triple(sys::getProcessTriple()).getOS() == Triple::Win32) 42 return cl::TokenizeWindowsCommandLine; 43 return cl::TokenizeGNUCommandLine; 44 } 45 46 static bool isPETargetName(StringRef s) { 47 return s == "i386pe" || s == "i386pep" || s == "thumb2pe" || s == "arm64pe" || 48 s == "arm64ecpe"; 49 } 50 51 static std::optional<bool> isPETarget(llvm::ArrayRef<const char *> args) { 52 for (auto it = args.begin(); it + 1 != args.end(); ++it) { 53 if (StringRef(*it) != "-m") 54 continue; 55 return isPETargetName(*(it + 1)); 56 } 57 58 // Expand response files (arguments in the form of @<filename>) 59 // to allow detecting the -m argument from arguments in them. 60 SmallVector<const char *, 256> expandedArgs(args.data(), 61 args.data() + args.size()); 62 BumpPtrAllocator a; 63 StringSaver saver(a); 64 cl::ExpansionContext ectx(saver.getAllocator(), getDefaultQuotingStyle()); 65 if (Error e = ectx.expandResponseFiles(expandedArgs)) { 66 err(toString(std::move(e))); 67 return std::nullopt; 68 } 69 70 for (auto it = expandedArgs.begin(); it + 1 != expandedArgs.end(); ++it) { 71 if (StringRef(*it) != "-m") 72 continue; 73 return isPETargetName(*(it + 1)); 74 } 75 76 #ifdef LLD_DEFAULT_LD_LLD_IS_MINGW 77 return true; 78 #else 79 return false; 80 #endif 81 } 82 83 static Flavor parseProgname(StringRef progname) { 84 // Use GNU driver for "ld" by default. 85 if (progname == "ld") 86 return Gnu; 87 88 // Progname may be something like "lld-gnu". Parse it. 89 SmallVector<StringRef, 3> v; 90 progname.split(v, "-"); 91 for (StringRef s : v) 92 if (Flavor f = getFlavor(s)) 93 return f; 94 return Invalid; 95 } 96 97 static Flavor 98 parseFlavorWithoutMinGW(llvm::SmallVectorImpl<const char *> &argsV) { 99 // Parse -flavor option. 100 if (argsV.size() > 1 && argsV[1] == StringRef("-flavor")) { 101 if (argsV.size() <= 2) { 102 err("missing arg value for '-flavor'"); 103 return Invalid; 104 } 105 Flavor f = getFlavor(argsV[2]); 106 if (f == Invalid) { 107 err("Unknown flavor: " + StringRef(argsV[2])); 108 return Invalid; 109 } 110 argsV.erase(argsV.begin() + 1, argsV.begin() + 3); 111 return f; 112 } 113 114 // Deduct the flavor from argv[0]. 115 StringRef arg0 = path::filename(argsV[0]); 116 arg0.consume_back_insensitive(".exe"); 117 Flavor f = parseProgname(arg0); 118 if (f == Invalid) { 119 err("lld is a generic driver.\n" 120 "Invoke ld.lld (Unix), ld64.lld (macOS), lld-link (Windows), wasm-ld" 121 " (WebAssembly) instead"); 122 return Invalid; 123 } 124 return f; 125 } 126 127 static Flavor parseFlavor(llvm::SmallVectorImpl<const char *> &argsV) { 128 Flavor f = parseFlavorWithoutMinGW(argsV); 129 if (f == Gnu) { 130 auto isPE = isPETarget(argsV); 131 if (!isPE) 132 return Invalid; 133 if (*isPE) 134 return MinGW; 135 } 136 return f; 137 } 138 139 static Driver whichDriver(llvm::SmallVectorImpl<const char *> &argsV, 140 llvm::ArrayRef<DriverDef> drivers) { 141 Flavor f = parseFlavor(argsV); 142 auto it = 143 llvm::find_if(drivers, [=](auto &driverdef) { return driverdef.f == f; }); 144 if (it == drivers.end()) { 145 // Driver is invalid or not available in this build. 146 return [](llvm::ArrayRef<const char *>, llvm::raw_ostream &, 147 llvm::raw_ostream &, bool, bool) { return false; }; 148 } 149 return it->d; 150 } 151 152 namespace lld { 153 bool inTestOutputDisabled = false; 154 155 /// Universal linker main(). This linker emulates the gnu, darwin, or 156 /// windows linker based on the argv[0] or -flavor option. 157 int unsafeLldMain(llvm::ArrayRef<const char *> args, 158 llvm::raw_ostream &stdoutOS, llvm::raw_ostream &stderrOS, 159 llvm::ArrayRef<DriverDef> drivers, bool exitEarly) { 160 SmallVector<const char *, 256> argsV(args); 161 Driver d = whichDriver(argsV, drivers); 162 // Run the driver. If an error occurs, false will be returned. 163 int r = !d(argsV, stdoutOS, stderrOS, exitEarly, inTestOutputDisabled); 164 // At this point 'r' is either 1 for error, and 0 for no error. 165 166 // Call exit() if we can to avoid calling destructors. 167 if (exitEarly) 168 exitLld(r); 169 170 // Delete the global context and clear the global context pointer, so that it 171 // cannot be accessed anymore. 172 CommonLinkerContext::destroy(); 173 174 return r; 175 } 176 } // namespace lld 177 178 Result lld::lldMain(llvm::ArrayRef<const char *> args, 179 llvm::raw_ostream &stdoutOS, llvm::raw_ostream &stderrOS, 180 llvm::ArrayRef<DriverDef> drivers) { 181 int r = 0; 182 { 183 // The crash recovery is here only to be able to recover from arbitrary 184 // control flow when fatal() is called (through setjmp/longjmp or 185 // __try/__except). 186 llvm::CrashRecoveryContext crc; 187 if (!crc.RunSafely([&]() { 188 r = unsafeLldMain(args, stdoutOS, stderrOS, drivers, 189 /*exitEarly=*/false); 190 })) 191 return {crc.RetCode, /*canRunAgain=*/false}; 192 } 193 194 // Cleanup memory and reset everything back in pristine condition. This path 195 // is only taken when LLD is in test, or when it is used as a library. 196 llvm::CrashRecoveryContext crc; 197 if (!crc.RunSafely([&]() { CommonLinkerContext::destroy(); })) { 198 // The memory is corrupted beyond any possible recovery. 199 return {r, /*canRunAgain=*/false}; 200 } 201 return {r, /*canRunAgain=*/true}; 202 } 203