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
13 #include "lld/Common/Args.h"
14 #include "lld/Common/CommonLinkerContext.h"
15 #include "lld/Common/Reproduce.h"
16 #include "llvm/ADT/CachedHashString.h"
17 #include "llvm/ADT/DenseMap.h"
18 #include "llvm/LTO/LTO.h"
19 #include "llvm/Option/Arg.h"
20 #include "llvm/Option/ArgList.h"
21 #include "llvm/Option/Option.h"
22 #include "llvm/Support/CommandLine.h"
23 #include "llvm/Support/FileSystem.h"
24 #include "llvm/Support/Path.h"
25 #include "llvm/TextAPI/InterfaceFile.h"
26 #include "llvm/TextAPI/TextAPIReader.h"
27
28 using namespace llvm;
29 using namespace llvm::MachO;
30 using namespace llvm::opt;
31 using namespace llvm::sys;
32 using namespace lld;
33 using namespace lld::macho;
34
35 #define OPTTABLE_STR_TABLE_CODE
36 #include "Options.inc"
37 #undef OPTTABLE_STR_TABLE_CODE
38
39 // Create prefix string literals used in Options.td
40 #define OPTTABLE_PREFIXES_TABLE_CODE
41 #include "Options.inc"
42 #undef OPTTABLE_PREFIXES_TABLE_CODE
43
44 // Create table mapping all options defined in Options.td
45 static constexpr OptTable::Info optInfo[] = {
46 #define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, \
47 VISIBILITY, PARAM, HELPTEXT, HELPTEXTSFORVARIANTS, METAVAR, \
48 VALUES) \
49 {PREFIX, \
50 NAME, \
51 HELPTEXT, \
52 HELPTEXTSFORVARIANTS, \
53 METAVAR, \
54 OPT_##ID, \
55 opt::Option::KIND##Class, \
56 PARAM, \
57 FLAGS, \
58 VISIBILITY, \
59 OPT_##GROUP, \
60 OPT_##ALIAS, \
61 ALIASARGS, \
62 VALUES},
63 #include "Options.inc"
64 #undef OPTION
65 };
66
MachOOptTable()67 MachOOptTable::MachOOptTable()
68 : GenericOptTable(OptionStrTable, OptionPrefixesTable, optInfo) {}
69
70 // Set color diagnostics according to --color-diagnostics={auto,always,never}
71 // or --no-color-diagnostics flags.
handleColorDiagnostics(CommonLinkerContext & ctx,InputArgList & args)72 static void handleColorDiagnostics(CommonLinkerContext &ctx,
73 InputArgList &args) {
74 const Arg *arg =
75 args.getLastArg(OPT_color_diagnostics, OPT_color_diagnostics_eq,
76 OPT_no_color_diagnostics);
77 if (!arg)
78 return;
79 auto &errs = ctx.e.errs();
80 if (arg->getOption().getID() == OPT_color_diagnostics) {
81 errs.enable_colors(true);
82 } else if (arg->getOption().getID() == OPT_no_color_diagnostics) {
83 errs.enable_colors(false);
84 } else {
85 StringRef s = arg->getValue();
86 if (s == "always")
87 errs.enable_colors(true);
88 else if (s == "never")
89 errs.enable_colors(false);
90 else if (s != "auto")
91 error("unknown option: --color-diagnostics=" + s);
92 }
93 }
94
parse(CommonLinkerContext & ctx,ArrayRef<const char * > argv)95 InputArgList MachOOptTable::parse(CommonLinkerContext &ctx,
96 ArrayRef<const char *> argv) {
97 // Make InputArgList from string vectors.
98 unsigned missingIndex;
99 unsigned missingCount;
100 SmallVector<const char *, 256> vec(argv.data(), argv.data() + argv.size());
101
102 // Expand response files (arguments in the form of @<filename>)
103 // and then parse the argument again.
104 cl::ExpandResponseFiles(saver(), cl::TokenizeGNUCommandLine, vec);
105 InputArgList args = ParseArgs(vec, missingIndex, missingCount);
106
107 // Handle -fatal_warnings early since it converts missing argument warnings
108 // to errors.
109 errorHandler().fatalWarnings = args.hasArg(OPT_fatal_warnings);
110 errorHandler().suppressWarnings = args.hasArg(OPT_w);
111
112 if (missingCount)
113 error(Twine(args.getArgString(missingIndex)) + ": missing argument");
114
115 handleColorDiagnostics(ctx, args);
116
117 for (const Arg *arg : args.filtered(OPT_UNKNOWN)) {
118 std::string nearest;
119 if (findNearest(arg->getAsString(args), nearest) > 1)
120 error("unknown argument '" + arg->getAsString(args) + "'");
121 else
122 error("unknown argument '" + arg->getAsString(args) +
123 "', did you mean '" + nearest + "'");
124 }
125 return args;
126 }
127
printHelp(CommonLinkerContext & ctx,const char * argv0,bool showHidden) const128 void MachOOptTable::printHelp(CommonLinkerContext &ctx, const char *argv0,
129 bool showHidden) const {
130 auto &outs = ctx.e.outs();
131 OptTable::printHelp(outs, (std::string(argv0) + " [options] file...").c_str(),
132 "LLVM Linker", showHidden);
133 outs << '\n';
134 }
135
rewritePath(StringRef s)136 static std::string rewritePath(StringRef s) {
137 if (fs::exists(s))
138 return relativeToRoot(s);
139 return std::string(s);
140 }
141
rewriteInputPath(StringRef s)142 static std::string rewriteInputPath(StringRef s) {
143 // Don't bother rewriting "absolute" paths that are actually under the
144 // syslibroot; simply rewriting the syslibroot is sufficient.
145 if (rerootPath(s) == s && fs::exists(s))
146 return relativeToRoot(s);
147 return std::string(s);
148 }
149
150 // Reconstructs command line arguments so that so that you can re-run
151 // the same command with the same inputs. This is for --reproduce.
createResponseFile(const InputArgList & args)152 std::string macho::createResponseFile(const InputArgList &args) {
153 SmallString<0> data;
154 raw_svector_ostream os(data);
155
156 // Copy the command line to the output while rewriting paths.
157 for (const Arg *arg : args) {
158 switch (arg->getOption().getID()) {
159 case OPT_reproduce:
160 break;
161 case OPT_INPUT:
162 os << quote(rewriteInputPath(arg->getValue())) << "\n";
163 break;
164 case OPT_o:
165 os << "-o " << quote(path::filename(arg->getValue())) << "\n";
166 break;
167 case OPT_filelist:
168 if (std::optional<MemoryBufferRef> buffer = readFile(arg->getValue()))
169 for (StringRef path : args::getLines(*buffer))
170 os << quote(rewriteInputPath(path)) << "\n";
171 break;
172 case OPT_force_load:
173 case OPT_weak_library:
174 case OPT_load_hidden:
175 os << arg->getSpelling() << " "
176 << quote(rewriteInputPath(arg->getValue())) << "\n";
177 break;
178 case OPT_F:
179 case OPT_L:
180 case OPT_bundle_loader:
181 case OPT_exported_symbols_list:
182 case OPT_order_file:
183 case OPT_syslibroot:
184 case OPT_unexported_symbols_list:
185 os << arg->getSpelling() << " " << quote(rewritePath(arg->getValue()))
186 << "\n";
187 break;
188 case OPT_sectcreate:
189 os << arg->getSpelling() << " " << quote(arg->getValue(0)) << " "
190 << quote(arg->getValue(1)) << " "
191 << quote(rewritePath(arg->getValue(2))) << "\n";
192 break;
193 default:
194 os << toString(*arg) << "\n";
195 }
196 }
197 return std::string(data);
198 }
199
searchedDylib(const Twine & path,bool found)200 static void searchedDylib(const Twine &path, bool found) {
201 if (config->printDylibSearch)
202 message("searched " + path + (found ? ", found " : ", not found"));
203 if (!found)
204 depTracker->logFileNotFound(path);
205 }
206
resolveDylibPath(StringRef dylibPath)207 std::optional<StringRef> macho::resolveDylibPath(StringRef dylibPath) {
208 // TODO: if a tbd and dylib are both present, we should check to make sure
209 // they are consistent.
210 SmallString<261> tbdPath = dylibPath;
211 path::replace_extension(tbdPath, ".tbd");
212 bool tbdExists = fs::exists(tbdPath);
213 searchedDylib(tbdPath, tbdExists);
214 if (tbdExists)
215 return saver().save(tbdPath.str());
216
217 bool dylibExists = fs::exists(dylibPath);
218 searchedDylib(dylibPath, dylibExists);
219 if (dylibExists)
220 return saver().save(dylibPath);
221 return {};
222 }
223
224 // It's not uncommon to have multiple attempts to load a single dylib,
225 // especially if it's a commonly re-exported core library.
226 static DenseMap<CachedHashStringRef, DylibFile *> loadedDylibs;
227
realPathIfDifferent(StringRef path)228 static StringRef realPathIfDifferent(StringRef path) {
229 SmallString<128> realPathBuf;
230 if (fs::real_path(path, realPathBuf))
231 return StringRef();
232
233 SmallString<128> absPathBuf = path;
234 if (!fs::make_absolute(absPathBuf) && realPathBuf == absPathBuf)
235 return StringRef();
236
237 return uniqueSaver().save(StringRef(realPathBuf));
238 }
239
loadDylib(MemoryBufferRef mbref,DylibFile * umbrella,bool isBundleLoader,bool explicitlyLinked)240 DylibFile *macho::loadDylib(MemoryBufferRef mbref, DylibFile *umbrella,
241 bool isBundleLoader, bool explicitlyLinked) {
242 CachedHashStringRef path(mbref.getBufferIdentifier());
243 DylibFile *&file = loadedDylibs[path];
244 if (file) {
245 if (explicitlyLinked)
246 file->setExplicitlyLinked();
247 return file;
248 }
249
250 // Frameworks can be found from different symlink paths, so resolve
251 // symlinks and look up in the dylib cache.
252 CachedHashStringRef realPath(
253 realPathIfDifferent(mbref.getBufferIdentifier()));
254 if (!realPath.val().empty()) {
255 // Avoid map insertions here so that we do not invalidate the "file"
256 // reference.
257 auto it = loadedDylibs.find(realPath);
258 if (it != loadedDylibs.end()) {
259 DylibFile *realfile = it->second;
260 if (explicitlyLinked)
261 realfile->setExplicitlyLinked();
262 return realfile;
263 }
264 }
265
266 DylibFile *newFile;
267 file_magic magic = identify_magic(mbref.getBuffer());
268 if (magic == file_magic::tapi_file) {
269 Expected<std::unique_ptr<InterfaceFile>> result = TextAPIReader::get(mbref);
270 if (!result) {
271 error("could not load TAPI file at " + mbref.getBufferIdentifier() +
272 ": " + toString(result.takeError()));
273 return nullptr;
274 }
275 file =
276 make<DylibFile>(**result, umbrella, isBundleLoader, explicitlyLinked);
277
278 // parseReexports() can recursively call loadDylib(). That's fine since
279 // we wrote the DylibFile we just loaded to the loadDylib cache via the
280 // `file` reference. But the recursive load can grow loadDylibs, so the
281 // `file` reference might become invalid after parseReexports() -- so copy
282 // the pointer it refers to before continuing.
283 newFile = file;
284 if (newFile->exportingFile)
285 newFile->parseReexports(**result);
286 } else {
287 assert(magic == file_magic::macho_dynamically_linked_shared_lib ||
288 magic == file_magic::macho_dynamically_linked_shared_lib_stub ||
289 magic == file_magic::macho_executable ||
290 magic == file_magic::macho_bundle);
291 file = make<DylibFile>(mbref, umbrella, isBundleLoader, explicitlyLinked);
292
293 // parseLoadCommands() can also recursively call loadDylib(). See comment
294 // in previous block for why this means we must copy `file` here.
295 newFile = file;
296 if (newFile->exportingFile)
297 newFile->parseLoadCommands(mbref);
298 }
299
300 if (explicitlyLinked && !newFile->allowableClients.empty()) {
301 bool allowed =
302 llvm::any_of(newFile->allowableClients, [&](StringRef allowableClient) {
303 // We only do a prefix match to match LD64's behaviour.
304 return allowableClient.starts_with(config->clientName);
305 });
306
307 // TODO: This behaviour doesn't quite match the latest available source
308 // release of LD64 (ld64-951.9), which allows "parents" and "siblings"
309 // to link to libraries even when they're not explicitly named as
310 // allowable clients. However, behaviour around this seems to have
311 // changed in the latest release of Xcode (ld64-1115.7.3), so it's not
312 // clear what the correct thing to do is yet.
313 if (!allowed)
314 error("cannot link directly with '" +
315 sys::path::filename(newFile->installName) + "' because " +
316 config->clientName + " is not an allowed client");
317 }
318
319 // If the load path was a symlink, cache the real path too.
320 if (!realPath.val().empty())
321 loadedDylibs[realPath] = newFile;
322
323 return newFile;
324 }
325
resetLoadedDylibs()326 void macho::resetLoadedDylibs() { loadedDylibs.clear(); }
327
328 std::optional<StringRef>
findPathCombination(const Twine & name,const std::vector<StringRef> & roots,ArrayRef<StringRef> extensions)329 macho::findPathCombination(const Twine &name,
330 const std::vector<StringRef> &roots,
331 ArrayRef<StringRef> extensions) {
332 SmallString<261> base;
333 for (StringRef dir : roots) {
334 base = dir;
335 path::append(base, name);
336 for (StringRef ext : extensions) {
337 Twine location = base + ext;
338 bool exists = fs::exists(location);
339 searchedDylib(location, exists);
340 if (exists)
341 return saver().save(location.str());
342 }
343 }
344 return {};
345 }
346
rerootPath(StringRef path)347 StringRef macho::rerootPath(StringRef path) {
348 if (!path::is_absolute(path, path::Style::posix) || path.ends_with(".o"))
349 return path;
350
351 if (std::optional<StringRef> rerootedPath =
352 findPathCombination(path, config->systemLibraryRoots))
353 return *rerootedPath;
354
355 return path;
356 }
357
getModTime(StringRef path)358 uint32_t macho::getModTime(StringRef path) {
359 if (config->zeroModTime)
360 return 0;
361
362 fs::file_status stat;
363 if (!fs::status(path, stat))
364 if (fs::exists(stat))
365 return toTimeT(stat.getLastModificationTime());
366
367 warn("failed to get modification time of " + path);
368 return 0;
369 }
370
printArchiveMemberLoad(StringRef reason,const InputFile * f)371 void macho::printArchiveMemberLoad(StringRef reason, const InputFile *f) {
372 if (config->printEachFile)
373 message(toString(f));
374 if (config->printWhyLoad)
375 message(reason + " forced load of " + toString(f));
376 }
377
DependencyTracker(StringRef path)378 macho::DependencyTracker::DependencyTracker(StringRef path)
379 : path(path), active(!path.empty()) {
380 if (active && fs::exists(path) && !fs::can_write(path)) {
381 warn("Ignoring dependency_info option since specified path is not "
382 "writeable.");
383 active = false;
384 }
385 }
386
write(StringRef version,const SetVector<InputFile * > & inputs,StringRef output)387 void macho::DependencyTracker::write(StringRef version,
388 const SetVector<InputFile *> &inputs,
389 StringRef output) {
390 if (!active)
391 return;
392
393 std::error_code ec;
394 raw_fd_ostream os(path, ec, fs::OF_None);
395 if (ec) {
396 warn("Error writing dependency info to file");
397 return;
398 }
399
400 auto addDep = [&os](DepOpCode opcode, const StringRef &path) {
401 // XXX: Even though DepOpCode's underlying type is uint8_t,
402 // this cast is still needed because Clang older than 10.x has a bug,
403 // where it doesn't know to cast the enum to its underlying type.
404 // Hence `<< DepOpCode` is ambiguous to it.
405 os << static_cast<uint8_t>(opcode);
406 os << path;
407 os << '\0';
408 };
409
410 addDep(DepOpCode::Version, version);
411
412 // Sort the input by its names.
413 std::vector<StringRef> inputNames;
414 inputNames.reserve(inputs.size());
415 for (InputFile *f : inputs)
416 inputNames.push_back(f->getName());
417 llvm::sort(inputNames);
418
419 for (const StringRef &in : inputNames)
420 addDep(DepOpCode::Input, in);
421
422 for (const std::string &f : notFounds)
423 addDep(DepOpCode::NotFound, f);
424
425 addDep(DepOpCode::Output, output);
426 }
427