1//===- DriverUtils.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#include "Config.h"
10#include "Driver.h"
11#include "InputFiles.h"
12#include "ObjC.h"
13#include "Target.h"
14
15#include "lld/Common/Args.h"
16#include "lld/Common/ErrorHandler.h"
17#include "lld/Common/Memory.h"
18#include "lld/Common/Reproduce.h"
19#include "llvm/ADT/CachedHashString.h"
20#include "llvm/ADT/DenseMap.h"
21#include "llvm/Bitcode/BitcodeReader.h"
22#include "llvm/LTO/LTO.h"
23#include "llvm/Option/Arg.h"
24#include "llvm/Option/ArgList.h"
25#include "llvm/Option/Option.h"
26#include "llvm/Support/CommandLine.h"
27#include "llvm/Support/FileSystem.h"
28#include "llvm/Support/Path.h"
29#include "llvm/TextAPI/InterfaceFile.h"
30#include "llvm/TextAPI/TextAPIReader.h"
31
32using namespace llvm;
33using namespace llvm::MachO;
34using namespace llvm::opt;
35using namespace llvm::sys;
36using namespace lld;
37using namespace lld::macho;
38
39// Create prefix string literals used in Options.td
40#define PREFIX(NAME, VALUE) const char *NAME[] = VALUE;
41#include "Options.inc"
42#undef PREFIX
43
44// Create table mapping all options defined in Options.td
45static const OptTable::Info optInfo[] = {
46#define OPTION(X1, X2, ID, KIND, GROUP, ALIAS, X7, X8, X9, X10, X11, X12) \
47 {X1, X2, X10, X11, OPT_##ID, Option::KIND##Class, \
48 X9, X8, OPT_##GROUP, OPT_##ALIAS, X7, X12},
49#include "Options.inc"
50#undef OPTION
51};
52
53MachOOptTable::MachOOptTable() : OptTable(optInfo) {}
54
55// Set color diagnostics according to --color-diagnostics={auto,always,never}
56// or --no-color-diagnostics flags.
57static void handleColorDiagnostics(InputArgList &args) {
58 const Arg *arg =
59 args.getLastArg(OPT_color_diagnostics, OPT_color_diagnostics_eq,
60 OPT_no_color_diagnostics);
61 if (!arg)
62 return;
63 if (arg->getOption().getID() == OPT_color_diagnostics) {
64 lld::errs().enable_colors(true);
65 } else if (arg->getOption().getID() == OPT_no_color_diagnostics) {
66 lld::errs().enable_colors(false);
67 } else {
68 StringRef s = arg->getValue();
69 if (s == "always")
70 lld::errs().enable_colors(true);
71 else if (s == "never")
72 lld::errs().enable_colors(false);
73 else if (s != "auto")
74 error("unknown option: --color-diagnostics=" + s);
75 }
76}
77
78InputArgList MachOOptTable::parse(ArrayRef<const char *> argv) {
79 // Make InputArgList from string vectors.
80 unsigned missingIndex;
81 unsigned missingCount;
82 SmallVector<const char *, 256> vec(argv.data(), argv.data() + argv.size());
83
84 // Expand response files (arguments in the form of @<filename>)
85 // and then parse the argument again.
86 cl::ExpandResponseFiles(saver, cl::TokenizeGNUCommandLine, vec);
87 InputArgList args = ParseArgs(vec, missingIndex, missingCount);
88
89 // Handle -fatal_warnings early since it converts missing argument warnings
90 // to errors.
91 errorHandler().fatalWarnings = args.hasArg(OPT_fatal_warnings);
92
93 if (missingCount)
94 error(Twine(args.getArgString(missingIndex)) + ": missing argument");
95
96 handleColorDiagnostics(args);
97
98 for (const Arg *arg : args.filtered(OPT_UNKNOWN)) {
99 std::string nearest;
100 if (findNearest(arg->getAsString(args), nearest) > 1)
101 error("unknown argument '" + arg->getAsString(args) + "'");
102 else
103 error("unknown argument '" + arg->getAsString(args) +
104 "', did you mean '" + nearest + "'");
105 }
106 return args;
107}
108
109void MachOOptTable::printHelp(const char *argv0, bool showHidden) const {
110 PrintHelp(lld::outs(), (std::string(argv0) + " [options] file...").c_str(),
111 "LLVM Linker", showHidden);
112 lld::outs() << "\n";
113}
114
115static std::string rewritePath(StringRef s) {
116 if (fs::exists(s))
117 return relativeToRoot(s);
118 return std::string(s);
119}
120
121static std::string rewriteInputPath(StringRef s) {
122 // Don't bother rewriting "absolute" paths that are actually under the
123 // syslibroot; simply rewriting the syslibroot is sufficient.
124 if (rerootPath(s) == s && fs::exists(s))
125 return relativeToRoot(s);
126 return std::string(s);
127}
128
129// Reconstructs command line arguments so that so that you can re-run
130// the same command with the same inputs. This is for --reproduce.
131std::string macho::createResponseFile(const InputArgList &args) {
132 SmallString<0> data;
133 raw_svector_ostream os(data);
134
135 // Copy the command line to the output while rewriting paths.
136 for (const Arg *arg : args) {
137 switch (arg->getOption().getID()) {
138 case OPT_reproduce:
139 break;
140 case OPT_INPUT:
141 os << quote(rewriteInputPath(arg->getValue())) << "\n";
142 break;
143 case OPT_o:
144 os << "-o " << quote(path::filename(arg->getValue())) << "\n";
145 break;
146 case OPT_filelist:
147 if (Optional<MemoryBufferRef> buffer = readFile(arg->getValue()))
148 for (StringRef path : args::getLines(*buffer))
149 os << quote(rewriteInputPath(path)) << "\n";
150 break;
151 case OPT_force_load:
152 case OPT_weak_library:
153 os << arg->getSpelling() << " "
154 << quote(rewriteInputPath(arg->getValue())) << "\n";
155 break;
156 case OPT_F:
157 case OPT_L:
158 case OPT_bundle_loader:
159 case OPT_exported_symbols_list:
160 case OPT_order_file:
161 case OPT_rpath:
162 case OPT_syslibroot:
163 case OPT_unexported_symbols_list:
164 os << arg->getSpelling() << " " << quote(rewritePath(arg->getValue()))
165 << "\n";
166 break;
167 case OPT_sectcreate:
168 os << arg->getSpelling() << " " << quote(arg->getValue(0)) << " "
169 << quote(arg->getValue(1)) << " "
170 << quote(rewritePath(arg->getValue(2))) << "\n";
171 break;
172 default:
173 os << toString(*arg) << "\n";
174 }
175 }
176 return std::string(data.str());
177}
178
179Optional<std::string> macho::resolveDylibPath(StringRef path) {
180 // TODO: if a tbd and dylib are both present, we should check to make sure
181 // they are consistent.
182 if (fs::exists(path))
183 return std::string(path);
184 else
185 depTracker->logFileNotFound(path);
186
187 SmallString<261> location = path;
188 path::replace_extension(location, ".tbd");
189 if (fs::exists(location))
190 return std::string(location);
191 else
192 depTracker->logFileNotFound(location);
193 return {};
194}
195
196// It's not uncommon to have multiple attempts to load a single dylib,
197// especially if it's a commonly re-exported core library.
198static DenseMap<CachedHashStringRef, DylibFile *> loadedDylibs;
199
200Optional<DylibFile *> macho::loadDylib(MemoryBufferRef mbref,
201 DylibFile *umbrella,
202 bool isBundleLoader) {
203 CachedHashStringRef path(mbref.getBufferIdentifier());
204 DylibFile *file = loadedDylibs[path];
205 if (file)
206 return file;
207
208 file_magic magic = identify_magic(mbref.getBuffer());
209 if (magic == file_magic::tapi_file) {
210 Expected<std::unique_ptr<InterfaceFile>> result = TextAPIReader::get(mbref);
211 if (!result) {
212 error("could not load TAPI file at " + mbref.getBufferIdentifier() +
213 ": " + toString(result.takeError()));
214 return {};
215 }
216 file = make<DylibFile>(**result, umbrella, isBundleLoader);
217 } else {
218 assert(magic == file_magic::macho_dynamically_linked_shared_lib ||
219 magic == file_magic::macho_dynamically_linked_shared_lib_stub ||
220 magic == file_magic::macho_executable ||
221 magic == file_magic::macho_bundle);
222 file = make<DylibFile>(mbref, umbrella, isBundleLoader);
223 }
224 // Note that DylibFile's ctor may recursively invoke loadDylib(), which can
225 // cause loadedDylibs to get resized and its iterators invalidated. As such,
226 // we redo the key lookup here instead of caching an iterator from our earlier
227 // lookup at the start of the function.
228 loadedDylibs[path] = file;
229 return file;
230}
231
232Optional<StringRef>
233macho::findPathCombination(const Twine &name,
234 const std::vector<StringRef> &roots,
235 ArrayRef<StringRef> extensions) {
236 SmallString<261> base;
237 for (StringRef dir : roots) {
238 base = dir;
239 path::append(base, name);
240 for (StringRef ext : extensions) {
241 Twine location = base + ext;
242 if (fs::exists(location))
243 return saver.save(location.str());
244 else
245 depTracker->logFileNotFound(location);
246 }
247 }
248 return {};
249}
250
251StringRef macho::rerootPath(StringRef path) {
252 if (!path::is_absolute(path, path::Style::posix) || path.endswith(".o"))
253 return path;
254
255 if (Optional<StringRef> rerootedPath =
256 findPathCombination(path, config->systemLibraryRoots))
257 return *rerootedPath;
258
259 return path;
260}
261
262Optional<InputFile *> macho::loadArchiveMember(MemoryBufferRef mb,
263 uint32_t modTime,
264 StringRef archiveName,
265 bool objCOnly) {
266 switch (identify_magic(mb.getBuffer())) {
267 case file_magic::macho_object:
268 if (!objCOnly || hasObjCSection(mb))
269 return make<ObjFile>(mb, modTime, archiveName);
270 return None;
271 case file_magic::bitcode:
272 if (!objCOnly || check(isBitcodeContainingObjCCategory(mb)))
273 return make<BitcodeFile>(mb);
274 return None;
275 default:
276 error(archiveName + ": archive member " + mb.getBufferIdentifier() +
277 " has unhandled file type");
278 return None;
279 }
280}
281
282uint32_t macho::getModTime(StringRef path) {
283 fs::file_status stat;
284 if (!fs::status(path, stat))
285 if (fs::exists(stat))
286 return toTimeT(stat.getLastModificationTime());
287
288 warn("failed to get modification time of " + path);
289 return 0;
290}
291
292void macho::printArchiveMemberLoad(StringRef reason, const InputFile *f) {
293 if (config->printEachFile)
294 message(toString(f));
295 if (config->printWhyLoad)
296 message(reason + " forced load of " + toString(f));
297}
298
299macho::DependencyTracker::DependencyTracker(StringRef path)
300 : path(path), active(!path.empty()) {
301 if (active && fs::exists(path) && !fs::can_write(path)) {
302 warn("Ignoring dependency_info option since specified path is not "
303 "writeable.");
304 active = false;
305 }
306}
307
308void macho::DependencyTracker::write(llvm::StringRef version,
309 const llvm::SetVector<InputFile *> &inputs,
310 llvm::StringRef output) {
311 if (!active)
312 return;
313
314 std::error_code ec;
315 llvm::raw_fd_ostream os(path, ec, llvm::sys::fs::OF_None);
316 if (ec) {
317 warn("Error writing dependency info to file");
318 return;
319 }
320
321 auto addDep = [&os](DepOpCode opcode, const StringRef &path) {
322 // XXX: Even though DepOpCode's underlying type is uint8_t,
323 // this cast is still needed because Clang older than 10.x has a bug,
324 // where it doesn't know to cast the enum to its underlying type.
325 // Hence `<< DepOpCode` is ambiguous to it.
326 os << static_cast<uint8_t>(opcode);
327 os << path;
328 os << '\0';
329 };
330
331 addDep(DepOpCode::Version, version);
332
333 // Sort the input by its names.
334 std::vector<StringRef> inputNames;
335 inputNames.reserve(inputs.size());
336 for (InputFile *f : inputs)
337 inputNames.push_back(f->getName());
338 llvm::sort(inputNames);
339
340 for (const StringRef &in : inputNames)
341 addDep(DepOpCode::Input, in);
342
343 for (const std::string &f : notFounds)
344 addDep(DepOpCode::NotFound, f);
345
346 addDep(DepOpCode::Output, output);
347}
348