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