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