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

   1 //===--- Compilation.cpp - Compilation Task Implementation ----------------===//
   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 "clang/Driver/Compilation.h"
  11 #include "clang/Driver/Action.h"
  12 #include "clang/Driver/Driver.h"
  13 #include "clang/Driver/DriverDiagnostic.h"
  14 #include "clang/Driver/Options.h"
  15 #include "clang/Driver/ToolChain.h"
  16 #include "llvm/ADT/STLExtras.h"
  17 #include "llvm/Option/ArgList.h"
  18 #include "llvm/Support/FileSystem.h"
  19 #include "llvm/Support/raw_ostream.h"
  20
  21 using namespace clang::driver;
  22 using namespace clang;
  23 using namespace llvm::opt;
  24
  25 Compilation::Compilation(const Driver &D, const ToolChain &_DefaultToolChain,
  26                          InputArgList *_Args, DerivedArgList *_TranslatedArgs,
  27                          bool ContainsError)
  28     : TheDriver(D), DefaultToolChain(_DefaultToolChain), ActiveOffloadMask(0u),
  29       Args(_Args), TranslatedArgs(_TranslatedArgs), Redirects(nullptr),
  30       ForDiagnostics(false), ContainsError(ContainsError) {
  31   // The offloading host toolchain is the default tool chain.
  32   OrderedOffloadingToolchains.insert(
  33       std::make_pair(Action::OFK_Host, &DefaultToolChain));
  34 }
  35
  36 Compilation::~Compilation() {
  37   delete TranslatedArgs;
  38   delete Args;
  39
  40   // Free any derived arg lists.
  41   for (auto Arg : TCArgs)
  42     if (Arg.second != TranslatedArgs)
  43       delete Arg.second;
  44
  45   // Free redirections of stdout/stderr.
  46   if (Redirects) {
  47     delete Redirects[0];
  48     delete Redirects[1];
  49     delete Redirects[2];
  50     delete [] Redirects;
  51   }
  52 }
  53
  54 const DerivedArgList &
  55 Compilation::getArgsForToolChain(const ToolChain *TC, StringRef BoundArch,
  56                                  Action::OffloadKind DeviceOffloadKind) {
  57   if (!TC)
  58     TC = &DefaultToolChain;
  59
  60   DerivedArgList *&Entry = TCArgs[{TC, BoundArch, DeviceOffloadKind}];
  61   if (!Entry) {
  62     Entry = TC->TranslateArgs(*TranslatedArgs, BoundArch, DeviceOffloadKind);
  63     if (!Entry)
  64       Entry = TranslatedArgs;
  65   }
  66
  67   return *Entry;
  68 }
  69
  70 bool Compilation::CleanupFile(const char *File, bool IssueErrors) const {
  71   // FIXME: Why are we trying to remove files that we have not created? For
  72   // example we should only try to remove a temporary assembly file if
  73   // "clang -cc1" succeed in writing it. Was this a workaround for when
  74   // clang was writing directly to a .s file and sometimes leaving it behind
  75   // during a failure?
  76
  77   // FIXME: If this is necessary, we can still try to split
  78   // llvm::sys::fs::remove into a removeFile and a removeDir and avoid the
  79   // duplicated stat from is_regular_file.
  80
  81   // Don't try to remove files which we don't have write access to (but may be
  82   // able to remove), or non-regular files. Underlying tools may have
  83   // intentionally not overwritten them.
  84   if (!llvm::sys::fs::can_write(File) || !llvm::sys::fs::is_regular_file(File))
  85     return true;
  86
  87   if (std::error_code EC = llvm::sys::fs::remove(File)) {
  88     // Failure is only failure if the file exists and is "regular". We checked
  89     // for it being regular before, and llvm::sys::fs::remove ignores ENOENT,
  90     // so we don't need to check again.
  91
  92     if (IssueErrors)
  93       getDriver().Diag(clang::diag::err_drv_unable_to_remove_file)
  94         << EC.message();
  95     return false;
  96   }
  97   return true;
  98 }
  99
 100 bool Compilation::CleanupFileList(const ArgStringList &Files,
 101                                   bool IssueErrors) const {
 102   bool Success = true;
 103   for (ArgStringList::const_iterator
 104          it = Files.begin(), ie = Files.end(); it != ie; ++it)
 105     Success &= CleanupFile(*it, IssueErrors);
 106   return Success;
 107 }
 108
 109 bool Compilation::CleanupFileMap(const ArgStringMap &Files,
 110                                  const JobAction *JA,
 111                                  bool IssueErrors) const {
 112   bool Success = true;
 113   for (ArgStringMap::const_iterator
 114          it = Files.begin(), ie = Files.end(); it != ie; ++it) {
 115
 116     // If specified, only delete the files associated with the JobAction.
 117     // Otherwise, delete all files in the map.
 118     if (JA && it->first != JA)
 119       continue;
 120     Success &= CleanupFile(it->second, IssueErrors);
 121   }
 122   return Success;
 123 }
 124
 125 int Compilation::ExecuteCommand(const Command &C,
 126                                 const Command *&FailingCommand) const {
 127   if ((getDriver().CCPrintOptions ||
 128        getArgs().hasArg(options::OPT_v)) && !getDriver().CCGenDiagnostics) {
 129     raw_ostream *OS = &llvm::errs();
 130
 131     // Follow gcc implementation of CC_PRINT_OPTIONS; we could also cache the
 132     // output stream.
 133     if (getDriver().CCPrintOptions && getDriver().CCPrintOptionsFilename) {
 134       std::error_code EC;
 135       OS = new llvm::raw_fd_ostream(getDriver().CCPrintOptionsFilename, EC,
 136                                     llvm::sys::fs::F_Append |
 137                                         llvm::sys::fs::F_Text);
 138       if (EC) {
 139         getDriver().Diag(clang::diag::err_drv_cc_print_options_failure)
 140             << EC.message();
 141         FailingCommand = &C;
 142         delete OS;
 143         return 1;
 144       }
 145     }
 146
 147     if (getDriver().CCPrintOptions)
 148       *OS << "[Logging clang options]";
 149
 150     C.Print(*OS, "\n", /*Quote=*/getDriver().CCPrintOptions);
 151
 152     if (OS != &llvm::errs())
 153       delete OS;
 154   }
 155
 156   std::string Error;
 157   bool ExecutionFailed;
 158   int Res = C.Execute(Redirects, &Error, &ExecutionFailed);
 159   if (!Error.empty()) {
 160     assert(Res && "Error string set with 0 result code!");
 161     getDriver().Diag(clang::diag::err_drv_command_failure) << Error;
 162   }
 163
 164   if (Res)
 165     FailingCommand = &C;
 166
 167   return ExecutionFailed ? 1 : Res;
 168 }
 169
 170 void Compilation::ExecuteJobs(
 171     const JobList &Jobs,
 172     SmallVectorImpl<std::pair<int, const Command *>> &FailingCommands) const {
 173   for (const auto &Job : Jobs) {
 174     const Command *FailingCommand = nullptr;
 175     if (int Res = ExecuteCommand(Job, FailingCommand)) {
 176       FailingCommands.push_back(std::make_pair(Res, FailingCommand));
 177       // Bail as soon as one command fails, so we don't output duplicate error
 178       // messages if we die on e.g. the same file.
 179       return;
 180     }
 181   }
 182 }
 183
 184 void Compilation::initCompilationForDiagnostics() {
 185   ForDiagnostics = true;
 186
 187   // Free actions and jobs.
 188   Actions.clear();
 189   AllActions.clear();
 190   Jobs.clear();
 191
 192   // Clear temporary/results file lists.
 193   TempFiles.clear();
 194   ResultFiles.clear();
 195   FailureResultFiles.clear();
 196
 197   // Remove any user specified output.  Claim any unclaimed arguments, so as
 198   // to avoid emitting warnings about unused args.
 199   OptSpecifier OutputOpts[] = { options::OPT_o, options::OPT_MD,
 200                                 options::OPT_MMD };
 201   for (unsigned i = 0, e = llvm::array_lengthof(OutputOpts); i != e; ++i) {
 202     if (TranslatedArgs->hasArg(OutputOpts[i]))
 203       TranslatedArgs->eraseArg(OutputOpts[i]);
 204   }
 205   TranslatedArgs->ClaimAllArgs();
 206
 207   // Redirect stdout/stderr to /dev/null.
 208   Redirects = new const StringRef*[3]();
 209   Redirects[0] = nullptr;
 210   Redirects[1] = new StringRef();
 211   Redirects[2] = new StringRef();
 212 }
 213
 214 StringRef Compilation::getSysRoot() const {
 215   return getDriver().SysRoot;
 216 }
 217
 218 void Compilation::Redirect(const StringRef** Redirects) {
 219   this->Redirects = Redirects;
 220 }