contrib/llvm-project/lld/ELF/DriverUtils.cpp

   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 // This file contains utility functions for the driver. Because there
  10 // are so many small functions, we created this separate file to make
  11 // Driver.cpp less cluttered.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "Driver.h"
  16 #include "lld/Common/ErrorHandler.h"
  17 #include "lld/Common/Memory.h"
  18 #include "lld/Common/Reproduce.h"
  19 #include "lld/Common/Version.h"
  20 #include "llvm/ADT/Optional.h"
  21 #include "llvm/ADT/STLExtras.h"
  22 #include "llvm/ADT/Triple.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/Support/Process.h"
  28
  29 using namespace llvm;
  30 using namespace llvm::sys;
  31 using namespace llvm::opt;
  32
  33 namespace lld {
  34 namespace elf {
  35
  36 // Create OptTable
  37
  38 // Create prefix string literals used in Options.td
  39 #define PREFIX(NAME, VALUE) const char *const NAME[] = VALUE;
  40 #include "Options.inc"
  41 #undef PREFIX
  42
  43 // Create table mapping all options defined in Options.td
  44 static const opt::OptTable::Info optInfo[] = {
  45 #define OPTION(X1, X2, ID, KIND, GROUP, ALIAS, X7, X8, X9, X10, X11, X12)      \
  46   {X1, X2, X10,         X11,         OPT_##ID, opt::Option::KIND##Class,       \
  47    X9, X8, OPT_##GROUP, OPT_##ALIAS, X7,       X12},
  48 #include "Options.inc"
  49 #undef OPTION
  50 };
  51
  52 ELFOptTable::ELFOptTable() : OptTable(optInfo) {}
  53
  54 // Set color diagnostics according to -color-diagnostics={auto,always,never}
  55 // or -no-color-diagnostics flags.
  56 static void handleColorDiagnostics(opt::InputArgList &args) {
  57   auto *arg = 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 static cl::TokenizerCallback getQuotingStyle(opt::InputArgList &args) {
  77   if (auto *arg = args.getLastArg(OPT_rsp_quoting)) {
  78     StringRef s = arg->getValue();
  79     if (s != "windows" && s != "posix")
  80       error("invalid response file quoting: " + s);
  81     if (s == "windows")
  82       return cl::TokenizeWindowsCommandLine;
  83     return cl::TokenizeGNUCommandLine;
  84   }
  85   if (Triple(sys::getProcessTriple()).getOS() == Triple::Win32)
  86     return cl::TokenizeWindowsCommandLine;
  87   return cl::TokenizeGNUCommandLine;
  88 }
  89
  90 // Gold LTO plugin takes a `--plugin-opt foo=bar` option as an alias for
  91 // `--plugin-opt=foo=bar`. We want to handle `--plugin-opt=foo=` as an
  92 // option name and `bar` as a value. Unfortunately, OptParser cannot
  93 // handle an option with a space in it.
  94 //
  95 // In this function, we concatenate command line arguments so that
  96 // `--plugin-opt <foo>` is converted to `--plugin-opt=<foo>`. This is a
  97 // bit hacky, but looks like it is still better than handling --plugin-opt
  98 // options by hand.
  99 static void concatLTOPluginOptions(SmallVectorImpl<const char *> &args) {
 100   SmallVector<const char *, 256> v;
 101   for (size_t i = 0, e = args.size(); i != e; ++i) {
 102     StringRef s = args[i];
 103     if ((s == "-plugin-opt" || s == "--plugin-opt") && i + 1 != e) {
 104       v.push_back(saver.save(s + "=" + args[i + 1]).data());
 105       ++i;
 106     } else {
 107       v.push_back(args[i]);
 108     }
 109   }
 110   args = std::move(v);
 111 }
 112
 113 // Parses a given list of options.
 114 opt::InputArgList ELFOptTable::parse(ArrayRef<const char *> argv) {
 115   // Make InputArgList from string vectors.
 116   unsigned missingIndex;
 117   unsigned missingCount;
 118   SmallVector<const char *, 256> vec(argv.data(), argv.data() + argv.size());
 119
 120   // We need to get the quoting style for response files before parsing all
 121   // options so we parse here before and ignore all the options but
 122   // --rsp-quoting.
 123   opt::InputArgList args = this->ParseArgs(vec, missingIndex, missingCount);
 124
 125   // Expand response files (arguments in the form of @<filename>)
 126   // and then parse the argument again.
 127   cl::ExpandResponseFiles(saver, getQuotingStyle(args), vec);
 128   concatLTOPluginOptions(vec);
 129   args = this->ParseArgs(vec, missingIndex, missingCount);
 130
 131   handleColorDiagnostics(args);
 132   if (missingCount)
 133     error(Twine(args.getArgString(missingIndex)) + ": missing argument");
 134
 135   for (auto *arg : args.filtered(OPT_UNKNOWN)) {
 136     std::string nearest;
 137     if (findNearest(arg->getAsString(args), nearest) > 1)
 138       error("unknown argument '" + arg->getAsString(args) + "'");
 139     else
 140       error("unknown argument '" + arg->getAsString(args) +
 141             "', did you mean '" + nearest + "'");
 142   }
 143   return args;
 144 }
 145
 146 void printHelp() {
 147   ELFOptTable().PrintHelp(
 148       lld::outs(), (config->progName + " [options] file...").str().c_str(),
 149       "lld", false /*ShowHidden*/, true /*ShowAllAliases*/);
 150   lld::outs() << "\n";
 151
 152   // Scripts generated by Libtool versions up to at least 2.4.6 (the most
 153   // recent version as of March 2017) expect /: supported targets:.* elf/
 154   // in a message for the -help option. If it doesn't match, the scripts
 155   // assume that the linker doesn't support very basic features such as
 156   // shared libraries. Therefore, we need to print out at least "elf".
 157   lld::outs() << config->progName << ": supported targets: elf\n";
 158 }
 159
 160 static std::string rewritePath(StringRef s) {
 161   if (fs::exists(s))
 162     return relativeToRoot(s);
 163   return s;
 164 }
 165
 166 // Reconstructs command line arguments so that so that you can re-run
 167 // the same command with the same inputs. This is for --reproduce.
 168 std::string createResponseFile(const opt::InputArgList &args) {
 169   SmallString<0> data;
 170   raw_svector_ostream os(data);
 171   os << "--chroot .\n";
 172
 173   // Copy the command line to the output while rewriting paths.
 174   for (auto *arg : args) {
 175     switch (arg->getOption().getID()) {
 176     case OPT_reproduce:
 177       break;
 178     case OPT_INPUT:
 179       os << quote(rewritePath(arg->getValue())) << "\n";
 180       break;
 181     case OPT_o:
 182       // If -o path contains directories, "lld @response.txt" will likely
 183       // fail because the archive we are creating doesn't contain empty
 184       // directories for the output path (-o doesn't create directories).
 185       // Strip directories to prevent the issue.
 186       os << "-o " << quote(sys::path::filename(arg->getValue())) << "\n";
 187       break;
 188     case OPT_dynamic_list:
 189     case OPT_library_path:
 190     case OPT_rpath:
 191     case OPT_script:
 192     case OPT_symbol_ordering_file:
 193     case OPT_sysroot:
 194     case OPT_version_script:
 195       os << arg->getSpelling() << " " << quote(rewritePath(arg->getValue()))
 196          << "\n";
 197       break;
 198     default:
 199       os << toString(*arg) << "\n";
 200     }
 201   }
 202   return data.str();
 203 }
 204
 205 // Find a file by concatenating given paths. If a resulting path
 206 // starts with "=", the character is replaced with a --sysroot value.
 207 static Optional<std::string> findFile(StringRef path1, const Twine &path2) {
 208   SmallString<128> s;
 209   if (path1.startswith("="))
 210     path::append(s, config->sysroot, path1.substr(1), path2);
 211   else
 212     path::append(s, path1, path2);
 213
 214   if (fs::exists(s))
 215     return s.str().str();
 216   return None;
 217 }
 218
 219 Optional<std::string> findFromSearchPaths(StringRef path) {
 220   for (StringRef dir : config->searchPaths)
 221     if (Optional<std::string> s = findFile(dir, path))
 222       return s;
 223   return None;
 224 }
 225
 226 // This is for -l<basename>. We'll look for lib<basename>.so or lib<basename>.a from
 227 // search paths.
 228 Optional<std::string> searchLibraryBaseName(StringRef name) {
 229   for (StringRef dir : config->searchPaths) {
 230     if (!config->isStatic)
 231       if (Optional<std::string> s = findFile(dir, "lib" + name + ".so"))
 232         return s;
 233     if (Optional<std::string> s = findFile(dir, "lib" + name + ".a"))
 234       return s;
 235   }
 236   return None;
 237 }
 238
 239 // This is for -l<namespec>.
 240 Optional<std::string> searchLibrary(StringRef name) {
 241   if (name.startswith(":"))
 242     return findFromSearchPaths(name.substr(1));
 243   return searchLibraryBaseName(name);
 244 }
 245
 246 // If a linker/version script doesn't exist in the current directory, we also
 247 // look for the script in the '-L' search paths. This matches the behaviour of
 248 // '-T', --version-script=, and linker script INPUT() command in ld.bfd.
 249 Optional<std::string> searchScript(StringRef name) {
 250   if (fs::exists(name))
 251     return name.str();
 252   return findFromSearchPaths(name);
 253 }
 254
 255 } // namespace elf
 256 } // namespace lld