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/InitLLVM.h" 20 #include "llvm/Support/Path.h" 21 #include "llvm/Support/Process.h" 22 #include "llvm/TargetParser/Host.h" 23 #include "llvm/TargetParser/Triple.h" 24 #include <cstdlib> 25 26 using namespace lld; 27 using namespace llvm; 28 using namespace llvm::sys; 29 30 static void err(const Twine &s) { llvm::errs() << s << "\n"; } 31 32 static Flavor getFlavor(StringRef s) { 33 return StringSwitch<Flavor>(s) 34 .CasesLower("ld", "ld.lld", "gnu", Gnu) 35 .CasesLower("wasm", "ld-wasm", Wasm) 36 .CaseLower("link", WinLink) 37 .CasesLower("ld64", "ld64.lld", "darwin", Darwin) 38 .Default(Invalid); 39 } 40 41 static cl::TokenizerCallback getDefaultQuotingStyle() { 42 if (Triple(sys::getProcessTriple()).getOS() == Triple::Win32) 43 return cl::TokenizeWindowsCommandLine; 44 return cl::TokenizeGNUCommandLine; 45 } 46 47 static bool isPETargetName(StringRef s) { 48 return s == "i386pe" || s == "i386pep" || s == "thumb2pe" || s == "arm64pe"; 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 if (arg0.ends_with_insensitive(".exe")) 117 arg0 = arg0.drop_back(4); 118 Flavor f = parseProgname(arg0); 119 if (f == Invalid) { 120 err("lld is a generic driver.\n" 121 "Invoke ld.lld (Unix), ld64.lld (macOS), lld-link (Windows), wasm-ld" 122 " (WebAssembly) instead"); 123 return Invalid; 124 } 125 return f; 126 } 127 128 static Flavor parseFlavor(llvm::SmallVectorImpl<const char *> &argsV) { 129 Flavor f = parseFlavorWithoutMinGW(argsV); 130 if (f == Gnu) { 131 auto isPE = isPETarget(argsV); 132 if (!isPE) 133 return Invalid; 134 if (*isPE) 135 return MinGW; 136 } 137 return f; 138 } 139 140 static Driver whichDriver(llvm::SmallVectorImpl<const char *> &argsV, 141 llvm::ArrayRef<DriverDef> drivers) { 142 Flavor f = parseFlavor(argsV); 143 auto it = 144 llvm::find_if(drivers, [=](auto &driverdef) { return driverdef.f == f; }); 145 if (it == drivers.end()) { 146 // Driver is invalid or not available in this build. 147 return [](llvm::ArrayRef<const char *>, llvm::raw_ostream &, 148 llvm::raw_ostream &, bool, bool) { return false; }; 149 } 150 return it->d; 151 } 152 153 namespace lld { 154 bool inTestOutputDisabled = false; 155 156 /// Universal linker main(). This linker emulates the gnu, darwin, or 157 /// windows linker based on the argv[0] or -flavor option. 158 int unsafeLldMain(llvm::ArrayRef<const char *> args, 159 llvm::raw_ostream &stdoutOS, llvm::raw_ostream &stderrOS, 160 llvm::ArrayRef<DriverDef> drivers, bool exitEarly) { 161 SmallVector<const char *, 256> argsV(args); 162 Driver d = whichDriver(argsV, drivers); 163 // Run the driver. If an error occurs, false will be returned. 164 int r = !d(argsV, stdoutOS, stderrOS, exitEarly, inTestOutputDisabled); 165 // At this point 'r' is either 1 for error, and 0 for no error. 166 167 // Call exit() if we can to avoid calling destructors. 168 if (exitEarly) 169 exitLld(r); 170 171 // Delete the global context and clear the global context pointer, so that it 172 // cannot be accessed anymore. 173 CommonLinkerContext::destroy(); 174 175 return r; 176 } 177 } // namespace lld 178 179 Result lld::lldMain(llvm::ArrayRef<const char *> args, 180 llvm::raw_ostream &stdoutOS, llvm::raw_ostream &stderrOS, 181 llvm::ArrayRef<DriverDef> drivers) { 182 int r = 0; 183 { 184 // The crash recovery is here only to be able to recover from arbitrary 185 // control flow when fatal() is called (through setjmp/longjmp or 186 // __try/__except). 187 llvm::CrashRecoveryContext crc; 188 if (!crc.RunSafely([&]() { 189 r = unsafeLldMain(args, stdoutOS, stderrOS, drivers, 190 /*exitEarly=*/false); 191 })) 192 return {crc.RetCode, /*canRunAgain=*/false}; 193 } 194 195 // Cleanup memory and reset everything back in pristine condition. This path 196 // is only taken when LLD is in test, or when it is used as a library. 197 llvm::CrashRecoveryContext crc; 198 if (!crc.RunSafely([&]() { CommonLinkerContext::destroy(); })) { 199 // The memory is corrupted beyond any possible recovery. 200 return {r, /*canRunAgain=*/false}; 201 } 202 return {r, /*canRunAgain=*/true}; 203 } 204