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
25using namespace lld;
26using namespace llvm;
27using namespace llvm::sys;
28
29static void err(const Twine &s) { llvm::errs() << s << "\n"; }
30
31static Flavor getFlavor(StringRef s) {
32 return StringSwitch<Flavor>(s)
33 .CasesLower(S0: "ld", S1: "ld.lld", S2: "gnu", Value: Gnu)
34 .CasesLower(S0: "wasm", S1: "ld-wasm", Value: Wasm)
35 .CaseLower(S: "link", Value: WinLink)
36 .CasesLower(S0: "ld64", S1: "ld64.lld", S2: "darwin", Value: Darwin)
37 .Default(Value: Invalid);
38}
39
40static cl::TokenizerCallback getDefaultQuotingStyle() {
41 if (Triple(sys::getProcessTriple()).getOS() == Triple::Win32)
42 return cl::TokenizeWindowsCommandLine;
43 return cl::TokenizeGNUCommandLine;
44}
45
46static bool isPETargetName(StringRef s) {
47 return s == "i386pe" || s == "i386pep" || s == "thumb2pe" || s == "arm64pe" ||
48 s == "arm64ecpe";
49}
50
51static 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(s: *(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(Argv&: expandedArgs)) {
66 err(s: toString(E: 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(s: *(it + 1));
74 }
75
76#ifdef LLD_DEFAULT_LD_LLD_IS_MINGW
77 return true;
78#else
79 return false;
80#endif
81}
82
83static 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(A&: v, Separator: "-");
91 for (StringRef s : v)
92 if (Flavor f = getFlavor(s))
93 return f;
94 return Invalid;
95}
96
97static Flavor
98parseFlavorWithoutMinGW(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(s: "missing arg value for '-flavor'");
103 return Invalid;
104 }
105 Flavor f = getFlavor(s: argsV[2]);
106 if (f == Invalid) {
107 err(s: "Unknown flavor: " + StringRef(argsV[2]));
108 return Invalid;
109 }
110 argsV.erase(CS: argsV.begin() + 1, CE: argsV.begin() + 3);
111 return f;
112 }
113
114 // Deduct the flavor from argv[0].
115 StringRef arg0 = path::filename(path: argsV[0]);
116 if (arg0.ends_with_insensitive(Suffix: ".exe"))
117 arg0 = arg0.drop_back(N: 4);
118 Flavor f = parseProgname(progname: arg0);
119 if (f == Invalid) {
120 err(s: "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
128static Flavor parseFlavor(llvm::SmallVectorImpl<const char *> &argsV) {
129 Flavor f = parseFlavorWithoutMinGW(argsV);
130 if (f == Gnu) {
131 auto isPE = isPETarget(args: argsV);
132 if (!isPE)
133 return Invalid;
134 if (*isPE)
135 return MinGW;
136 }
137 return f;
138}
139
140static Driver whichDriver(llvm::SmallVectorImpl<const char *> &argsV,
141 llvm::ArrayRef<DriverDef> drivers) {
142 Flavor f = parseFlavor(argsV);
143 auto it =
144 llvm::find_if(Range&: drivers, P: [=](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
153namespace lld {
154bool 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.
158int 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(val: 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
179Result 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(Fn: [&]() {
189 r = unsafeLldMain(args, stdoutOS, stderrOS, drivers,
190 /*exitEarly=*/false);
191 }))
192 return {.retCode: 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(Fn: [&]() { CommonLinkerContext::destroy(); })) {
199 // The memory is corrupted beyond any possible recovery.
200 return {.retCode: r, /*canRunAgain=*/false};
201 }
202 return {.retCode: r, /*canRunAgain=*/true};
203}
204

source code of lld/Common/DriverDispatcher.cpp