contrib/llvm/tools/clang/lib/Driver/Job.cpp

   1 //===--- Job.cpp - Command to Execute -------------------------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "InputInfo.h"
  11 #include "clang/Driver/Driver.h"
  12 #include "clang/Driver/DriverDiagnostic.h"
  13 #include "clang/Driver/Job.h"
  14 #include "clang/Driver/Tool.h"
  15 #include "clang/Driver/ToolChain.h"
  16 #include "llvm/ADT/ArrayRef.h"
  17 #include "llvm/ADT/STLExtras.h"
  18 #include "llvm/ADT/StringRef.h"
  19 #include "llvm/ADT/StringSet.h"
  20 #include "llvm/ADT/StringSwitch.h"
  21 #include "llvm/Support/FileSystem.h"
  22 #include "llvm/Support/Program.h"
  23 #include "llvm/Support/raw_ostream.h"
  24 #include <cassert>
  25 using namespace clang::driver;
  26 using llvm::raw_ostream;
  27 using llvm::StringRef;
  28 using llvm::ArrayRef;
  29
  30 Command::Command(const Action &Source, const Tool &Creator,
  31                  const char *Executable, const ArgStringList &Arguments,
  32                  ArrayRef<InputInfo> Inputs)
  33     : Source(Source), Creator(Creator), Executable(Executable),
  34       Arguments(Arguments), ResponseFile(nullptr) {
  35   for (const auto &II : Inputs)
  36     if (II.isFilename())
  37       InputFilenames.push_back(II.getFilename());
  38 }
  39
  40 static int skipArgs(const char *Flag, bool HaveCrashVFS) {
  41   // These flags are all of the form -Flag <Arg> and are treated as two
  42   // arguments.  Therefore, we need to skip the flag and the next argument.
  43   bool Res = llvm::StringSwitch<bool>(Flag)
  44     .Cases("-MF", "-MT", "-MQ", "-serialize-diagnostic-file", true)
  45     .Cases("-o", "-coverage-file", "-dependency-file", true)
  46     .Cases("-fdebug-compilation-dir", "-idirafter", true)
  47     .Cases("-include", "-include-pch", "-internal-isystem", true)
  48     .Cases("-internal-externc-isystem", "-iprefix", "-iwithprefix", true)
  49     .Cases("-iwithprefixbefore", "-isystem", "-iquote", true)
  50     .Cases("-dwarf-debug-flags", "-ivfsoverlay", true)
  51     .Cases("-header-include-file", "-diagnostic-log-file", true)
  52     // Some include flags shouldn't be skipped if we have a crash VFS
  53     .Cases("-isysroot", "-I", "-F", "-resource-dir", !HaveCrashVFS)
  54     .Default(false);
  55
  56   // Match found.
  57   if (Res)
  58     return 2;
  59
  60   // The remaining flags are treated as a single argument.
  61
  62   // These flags are all of the form -Flag and have no second argument.
  63   Res = llvm::StringSwitch<bool>(Flag)
  64     .Cases("-M", "-MM", "-MG", "-MP", "-MD", true)
  65     .Case("-MMD", true)
  66     .Default(false);
  67
  68   // Match found.
  69   if (Res)
  70     return 1;
  71
  72   // These flags are treated as a single argument (e.g., -F<Dir>).
  73   StringRef FlagRef(Flag);
  74   if ((!HaveCrashVFS &&
  75        (FlagRef.startswith("-F") || FlagRef.startswith("-I"))) ||
  76       FlagRef.startswith("-fmodules-cache-path="))
  77     return 1;
  78
  79   return 0;
  80 }
  81
  82 void Command::printArg(raw_ostream &OS, const char *Arg, bool Quote) {
  83   const bool Escape = std::strpbrk(Arg, "\"\\$");
  84
  85   if (!Quote && !Escape) {
  86     OS << Arg;
  87     return;
  88   }
  89
  90   // Quote and escape. This isn't really complete, but good enough.
  91   OS << '"';
  92   while (const char c = *Arg++) {
  93     if (c == '"' || c == '\\' || c == '$')
  94       OS << '\\';
  95     OS << c;
  96   }
  97   OS << '"';
  98 }
  99
 100 void Command::writeResponseFile(raw_ostream &OS) const {
 101   // In a file list, we only write the set of inputs to the response file
 102   if (Creator.getResponseFilesSupport() == Tool::RF_FileList) {
 103     for (const char *Arg : InputFileList) {
 104       OS << Arg << '\n';
 105     }
 106     return;
 107   }
 108
 109   // In regular response files, we send all arguments to the response file.
 110   // Wrapping all arguments in double quotes ensures that both Unix tools and
 111   // Windows tools understand the response file.
 112   for (const char *Arg : Arguments) {
 113     OS << '"';
 114
 115     for (; *Arg != '\0'; Arg++) {
 116       if (*Arg == '\"' || *Arg == '\\') {
 117         OS << '\\';
 118       }
 119       OS << *Arg;
 120     }
 121
 122     OS << "\" ";
 123   }
 124 }
 125
 126 void Command::buildArgvForResponseFile(
 127     llvm::SmallVectorImpl<const char *> &Out) const {
 128   // When not a file list, all arguments are sent to the response file.
 129   // This leaves us to set the argv to a single parameter, requesting the tool
 130   // to read the response file.
 131   if (Creator.getResponseFilesSupport() != Tool::RF_FileList) {
 132     Out.push_back(Executable);
 133     Out.push_back(ResponseFileFlag.c_str());
 134     return;
 135   }
 136
 137   llvm::StringSet<> Inputs;
 138   for (const char *InputName : InputFileList)
 139     Inputs.insert(InputName);
 140   Out.push_back(Executable);
 141   // In a file list, build args vector ignoring parameters that will go in the
 142   // response file (elements of the InputFileList vector)
 143   bool FirstInput = true;
 144   for (const char *Arg : Arguments) {
 145     if (Inputs.count(Arg) == 0) {
 146       Out.push_back(Arg);
 147     } else if (FirstInput) {
 148       FirstInput = false;
 149       Out.push_back(Creator.getResponseFileFlag());
 150       Out.push_back(ResponseFile);
 151     }
 152   }
 153 }
 154
 155 void Command::Print(raw_ostream &OS, const char *Terminator, bool Quote,
 156                     CrashReportInfo *CrashInfo) const {
 157   // Always quote the exe.
 158   OS << ' ';
 159   printArg(OS, Executable, /*Quote=*/true);
 160
 161   llvm::ArrayRef<const char *> Args = Arguments;
 162   llvm::SmallVector<const char *, 128> ArgsRespFile;
 163   if (ResponseFile != nullptr) {
 164     buildArgvForResponseFile(ArgsRespFile);
 165     Args = ArrayRef<const char *>(ArgsRespFile).slice(1); // no executable name
 166   }
 167
 168   bool HaveCrashVFS = CrashInfo && !CrashInfo->VFSPath.empty();
 169   for (size_t i = 0, e = Args.size(); i < e; ++i) {
 170     const char *const Arg = Args[i];
 171
 172     if (CrashInfo) {
 173       if (int Skip = skipArgs(Arg, HaveCrashVFS)) {
 174         i += Skip - 1;
 175         continue;
 176       }
 177       auto Found = std::find_if(InputFilenames.begin(), InputFilenames.end(),
 178                                 [&Arg](StringRef IF) { return IF == Arg; });
 179       if (Found != InputFilenames.end() &&
 180           (i == 0 || StringRef(Args[i - 1]) != "-main-file-name")) {
 181         // Replace the input file name with the crashinfo's file name.
 182         OS << ' ';
 183         StringRef ShortName = llvm::sys::path::filename(CrashInfo->Filename);
 184         printArg(OS, ShortName.str().c_str(), Quote);
 185         continue;
 186       }
 187     }
 188
 189     OS << ' ';
 190     printArg(OS, Arg, Quote);
 191   }
 192
 193   if (CrashInfo && HaveCrashVFS) {
 194     OS << ' ';
 195     printArg(OS, "-ivfsoverlay", Quote);
 196     OS << ' ';
 197     printArg(OS, CrashInfo->VFSPath.str().c_str(), Quote);
 198
 199     // Insert -fmodules-cache-path and use the relative module directory
 200     // <name>.cache/vfs/modules where we already dumped the modules.
 201     SmallString<128> RelModCacheDir = llvm::sys::path::parent_path(
 202         llvm::sys::path::parent_path(CrashInfo->VFSPath));
 203     llvm::sys::path::append(RelModCacheDir, "modules");
 204
 205     std::string ModCachePath = "-fmodules-cache-path=";
 206     ModCachePath.append(RelModCacheDir.c_str());
 207
 208     OS << ' ';
 209     printArg(OS, ModCachePath.c_str(), Quote);
 210   }
 211
 212   if (ResponseFile != nullptr) {
 213     OS << "\n Arguments passed via response file:\n";
 214     writeResponseFile(OS);
 215     // Avoiding duplicated newline terminator, since FileLists are
 216     // newline-separated.
 217     if (Creator.getResponseFilesSupport() != Tool::RF_FileList)
 218       OS << "\n";
 219     OS << " (end of response file)";
 220   }
 221
 222   OS << Terminator;
 223 }
 224
 225 void Command::setResponseFile(const char *FileName) {
 226   ResponseFile = FileName;
 227   ResponseFileFlag = Creator.getResponseFileFlag();
 228   ResponseFileFlag += FileName;
 229 }
 230
 231 int Command::Execute(const StringRef **Redirects, std::string *ErrMsg,
 232                      bool *ExecutionFailed) const {
 233   SmallVector<const char*, 128> Argv;
 234
 235   if (ResponseFile == nullptr) {
 236     Argv.push_back(Executable);
 237     Argv.append(Arguments.begin(), Arguments.end());
 238     Argv.push_back(nullptr);
 239
 240     return llvm::sys::ExecuteAndWait(Executable, Argv.data(), /*env*/ nullptr,
 241                                      Redirects, /*secondsToWait*/ 0,
 242                                      /*memoryLimit*/ 0, ErrMsg,
 243                                      ExecutionFailed);
 244   }
 245
 246   // We need to put arguments in a response file (command is too large)
 247   // Open stream to store the response file contents
 248   std::string RespContents;
 249   llvm::raw_string_ostream SS(RespContents);
 250
 251   // Write file contents and build the Argv vector
 252   writeResponseFile(SS);
 253   buildArgvForResponseFile(Argv);
 254   Argv.push_back(nullptr);
 255   SS.flush();
 256
 257   // Save the response file in the appropriate encoding
 258   if (std::error_code EC = writeFileWithEncoding(
 259           ResponseFile, RespContents, Creator.getResponseFileEncoding())) {
 260     if (ErrMsg)
 261       *ErrMsg = EC.message();
 262     if (ExecutionFailed)
 263       *ExecutionFailed = true;
 264     return -1;
 265   }
 266
 267   return llvm::sys::ExecuteAndWait(Executable, Argv.data(), /*env*/ nullptr,
 268                                    Redirects, /*secondsToWait*/ 0,
 269                                    /*memoryLimit*/ 0, ErrMsg, ExecutionFailed);
 270 }
 271
 272 FallbackCommand::FallbackCommand(const Action &Source_, const Tool &Creator_,
 273                                  const char *Executable_,
 274                                  const ArgStringList &Arguments_,
 275                                  ArrayRef<InputInfo> Inputs,
 276                                  std::unique_ptr<Command> Fallback_)
 277     : Command(Source_, Creator_, Executable_, Arguments_, Inputs),
 278       Fallback(std::move(Fallback_)) {}
 279
 280 void FallbackCommand::Print(raw_ostream &OS, const char *Terminator,
 281                             bool Quote, CrashReportInfo *CrashInfo) const {
 282   Command::Print(OS, "", Quote, CrashInfo);
 283   OS << " ||";
 284   Fallback->Print(OS, Terminator, Quote, CrashInfo);
 285 }
 286
 287 static bool ShouldFallback(int ExitCode) {
 288   // FIXME: We really just want to fall back for internal errors, such
 289   // as when some symbol cannot be mangled, when we should be able to
 290   // parse something but can't, etc.
 291   return ExitCode != 0;
 292 }
 293
 294 int FallbackCommand::Execute(const StringRef **Redirects, std::string *ErrMsg,
 295                              bool *ExecutionFailed) const {
 296   int PrimaryStatus = Command::Execute(Redirects, ErrMsg, ExecutionFailed);
 297   if (!ShouldFallback(PrimaryStatus))
 298     return PrimaryStatus;
 299
 300   // Clear ExecutionFailed and ErrMsg before falling back.
 301   if (ErrMsg)
 302     ErrMsg->clear();
 303   if (ExecutionFailed)
 304     *ExecutionFailed = false;
 305
 306   const Driver &D = getCreator().getToolChain().getDriver();
 307   D.Diag(diag::warn_drv_invoking_fallback) << Fallback->getExecutable();
 308
 309   int SecondaryStatus = Fallback->Execute(Redirects, ErrMsg, ExecutionFailed);
 310   return SecondaryStatus;
 311 }
 312
 313 ForceSuccessCommand::ForceSuccessCommand(const Action &Source_,
 314                                          const Tool &Creator_,
 315                                          const char *Executable_,
 316                                          const ArgStringList &Arguments_,
 317                                          ArrayRef<InputInfo> Inputs)
 318     : Command(Source_, Creator_, Executable_, Arguments_, Inputs) {}
 319
 320 void ForceSuccessCommand::Print(raw_ostream &OS, const char *Terminator,
 321                             bool Quote, CrashReportInfo *CrashInfo) const {
 322   Command::Print(OS, "", Quote, CrashInfo);
 323   OS << " || (exit 0)" << Terminator;
 324 }
 325
 326 int ForceSuccessCommand::Execute(const StringRef **Redirects,
 327                                  std::string *ErrMsg,
 328                                  bool *ExecutionFailed) const {
 329   int Status = Command::Execute(Redirects, ErrMsg, ExecutionFailed);
 330   (void)Status;
 331   if (ExecutionFailed)
 332     *ExecutionFailed = false;
 333   return 0;
 334 }
 335
 336 void JobList::Print(raw_ostream &OS, const char *Terminator, bool Quote,
 337                     CrashReportInfo *CrashInfo) const {
 338   for (const auto &Job : *this)
 339     Job.Print(OS, Terminator, Quote, CrashInfo);
 340 }
 341
 342 void JobList::clear() { Jobs.clear(); }