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