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
  12 #include "clang/Driver/Action.h"
  13 #include "clang/Driver/ArgList.h"
  14 #include "clang/Driver/Driver.h"
  15 #include "clang/Driver/DriverDiagnostic.h"
  16 #include "clang/Driver/Options.h"
  17 #include "clang/Driver/ToolChain.h"
  18
  19 #include "llvm/ADT/STLExtras.h"
  20 #include "llvm/ADT/StringSwitch.h"
  21 #include "llvm/Support/raw_ostream.h"
  22 #include "llvm/Support/Program.h"
  23 #include <sys/stat.h>
  24 #include <errno.h>
  25
  26 using namespace clang::driver;
  27 using namespace clang;
  28
  29 Compilation::Compilation(const Driver &D, const ToolChain &_DefaultToolChain,
  30                          InputArgList *_Args, DerivedArgList *_TranslatedArgs)
  31   : TheDriver(D), DefaultToolChain(_DefaultToolChain), Args(_Args),
  32     TranslatedArgs(_TranslatedArgs), Redirects(0) {
  33 }
  34
  35 Compilation::~Compilation() {
  36   delete TranslatedArgs;
  37   delete Args;
  38
  39   // Free any derived arg lists.
  40   for (llvm::DenseMap<std::pair<const ToolChain*, const char*>,
  41                       DerivedArgList*>::iterator it = TCArgs.begin(),
  42          ie = TCArgs.end(); it != ie; ++it)
  43     if (it->second != TranslatedArgs)
  44       delete it->second;
  45
  46   // Free the actions, if built.
  47   for (ActionList::iterator it = Actions.begin(), ie = Actions.end();
  48        it != ie; ++it)
  49     delete *it;
  50
  51   // Free redirections of stdout/stderr.
  52   if (Redirects) {
  53     delete Redirects[1];
  54     delete Redirects[2];
  55     delete [] Redirects;
  56   }
  57 }
  58
  59 const DerivedArgList &Compilation::getArgsForToolChain(const ToolChain *TC,
  60                                                        const char *BoundArch) {
  61   if (!TC)
  62     TC = &DefaultToolChain;
  63
  64   DerivedArgList *&Entry = TCArgs[std::make_pair(TC, BoundArch)];
  65   if (!Entry) {
  66     Entry = TC->TranslateArgs(*TranslatedArgs, BoundArch);
  67     if (!Entry)
  68       Entry = TranslatedArgs;
  69   }
  70
  71   return *Entry;
  72 }
  73
  74 void Compilation::PrintJob(raw_ostream &OS, const Job &J,
  75                            const char *Terminator, bool Quote) const {
  76   if (const Command *C = dyn_cast<Command>(&J)) {
  77     OS << " \"" << C->getExecutable() << '"';
  78     for (ArgStringList::const_iterator it = C->getArguments().begin(),
  79            ie = C->getArguments().end(); it != ie; ++it) {
  80       OS << ' ';
  81       if (!Quote && !std::strpbrk(*it, " \"\\$")) {
  82         OS << *it;
  83         continue;
  84       }
  85
  86       // Quote the argument and escape shell special characters; this isn't
  87       // really complete but is good enough.
  88       OS << '"';
  89       for (const char *s = *it; *s; ++s) {
  90         if (*s == '"' || *s == '\\' || *s == '$')
  91           OS << '\\';
  92         OS << *s;
  93       }
  94       OS << '"';
  95     }
  96     OS << Terminator;
  97   } else {
  98     const JobList *Jobs = cast<JobList>(&J);
  99     for (JobList::const_iterator
 100            it = Jobs->begin(), ie = Jobs->end(); it != ie; ++it)
 101       PrintJob(OS, **it, Terminator, Quote);
 102   }
 103 }
 104
 105 static bool skipArg(const char *Flag, bool &SkipNextArg) {
 106   StringRef FlagRef(Flag);
 107
 108   // Assume we're going to see -Flag <Arg>.
 109   SkipNextArg = true;
 110
 111   // These flags are all of the form -Flag <Arg> and are treated as two
 112   // arguments.  Therefore, we need to skip the flag and the next argument.
 113   bool Res = llvm::StringSwitch<bool>(Flag)
 114     .Cases("-I", "-MF", "-MT", "-MQ", true)
 115     .Cases("-o", "-coverage-file", "-dependency-file", true)
 116     .Cases("-fdebug-compilation-dir", "-fmodule-cache-path", "-idirafter", true)
 117     .Cases("-include", "-include-pch", "-internal-isystem", true)
 118     .Cases("-internal-externc-isystem", "-iprefix", "-iwithprefix", true)
 119     .Cases("-iwithprefixbefore", "-isysroot", "-isystem", "-iquote", true)
 120     .Cases("-resource-dir", "-serialize-diagnostic-file", true)
 121     .Case("-dwarf-debug-flags", true)
 122     .Default(false);
 123
 124   // Match found.
 125   if (Res)
 126     return Res;
 127
 128   // The remaining flags are treated as a single argument.
 129   SkipNextArg = false;
 130
 131   // These flags are all of the form -Flag and have no second argument.
 132   Res = llvm::StringSwitch<bool>(Flag)
 133     .Cases("-M", "-MM", "-MG", "-MP", "-MD", true)
 134     .Case("-MMD", true)
 135     .Default(false);
 136
 137   // Match found.
 138   if (Res)
 139     return Res;
 140
 141   // These flags are treated as a single argument (e.g., -F<Dir>).
 142   if (FlagRef.startswith("-F") || FlagRef.startswith("-I"))
 143     return true;
 144
 145   return false;
 146 }
 147
 148 static bool quoteNextArg(const char *flag) {
 149   return llvm::StringSwitch<bool>(flag)
 150     .Case("-D", true)
 151     .Default(false);
 152 }
 153
 154 void Compilation::PrintDiagnosticJob(raw_ostream &OS, const Job &J) const {
 155   if (const Command *C = dyn_cast<Command>(&J)) {
 156     OS << C->getExecutable();
 157     unsigned QuoteNextArg = 0;
 158     for (ArgStringList::const_iterator it = C->getArguments().begin(),
 159            ie = C->getArguments().end(); it != ie; ++it) {
 160
 161       bool SkipNext;
 162       if (skipArg(*it, SkipNext)) {
 163         if (SkipNext) ++it;
 164         continue;
 165       }
 166
 167       if (!QuoteNextArg)
 168         QuoteNextArg = quoteNextArg(*it) ? 2 : 0;
 169
 170       OS << ' ';
 171
 172       if (QuoteNextArg == 1)
 173         OS << '"';
 174
 175       if (!std::strpbrk(*it, " \"\\$")) {
 176         OS << *it;
 177       } else {
 178         // Quote the argument and escape shell special characters; this isn't
 179         // really complete but is good enough.
 180         OS << '"';
 181         for (const char *s = *it; *s; ++s) {
 182           if (*s == '"' || *s == '\\' || *s == '$')
 183             OS << '\\';
 184           OS << *s;
 185         }
 186         OS << '"';
 187       }
 188
 189       if (QuoteNextArg) {
 190         if (QuoteNextArg == 1)
 191           OS << '"';
 192         --QuoteNextArg;
 193       }
 194     }
 195     OS << '\n';
 196   } else {
 197     const JobList *Jobs = cast<JobList>(&J);
 198     for (JobList::const_iterator
 199            it = Jobs->begin(), ie = Jobs->end(); it != ie; ++it)
 200       PrintDiagnosticJob(OS, **it);
 201   }
 202 }
 203
 204 bool Compilation::CleanupFileList(const ArgStringList &Files,
 205                                   bool IssueErrors) const {
 206   bool Success = true;
 207
 208   for (ArgStringList::const_iterator
 209          it = Files.begin(), ie = Files.end(); it != ie; ++it) {
 210
 211     llvm::sys::Path P(*it);
 212     std::string Error;
 213
 214     // Don't try to remove files which we don't have write access to (but may be
 215     // able to remove). Underlying tools may have intentionally not overwritten
 216     // them.
 217     if (!P.canWrite())
 218       continue;
 219
 220     if (P.eraseFromDisk(false, &Error)) {
 221       // Failure is only failure if the file exists and is "regular". There is
 222       // a race condition here due to the limited interface of
 223       // llvm::sys::Path, we want to know if the removal gave ENOENT.
 224
 225       // FIXME: Grumble, P.exists() is broken. PR3837.
 226       struct stat buf;
 227       if (::stat(P.c_str(), &buf) == 0 ? (buf.st_mode & S_IFMT) == S_IFREG :
 228                                          (errno != ENOENT)) {
 229         if (IssueErrors)
 230           getDriver().Diag(clang::diag::err_drv_unable_to_remove_file)
 231             << Error;
 232         Success = false;
 233       }
 234     }
 235   }
 236
 237   return Success;
 238 }
 239
 240 int Compilation::ExecuteCommand(const Command &C,
 241                                 const Command *&FailingCommand) const {
 242   llvm::sys::Path Prog(C.getExecutable());
 243   const char **Argv = new const char*[C.getArguments().size() + 2];
 244   Argv[0] = C.getExecutable();
 245   std::copy(C.getArguments().begin(), C.getArguments().end(), Argv+1);
 246   Argv[C.getArguments().size() + 1] = 0;
 247
 248   if ((getDriver().CCCEcho || getDriver().CCPrintOptions ||
 249        getArgs().hasArg(options::OPT_v)) && !getDriver().CCGenDiagnostics) {
 250     raw_ostream *OS = &llvm::errs();
 251
 252     // Follow gcc implementation of CC_PRINT_OPTIONS; we could also cache the
 253     // output stream.
 254     if (getDriver().CCPrintOptions && getDriver().CCPrintOptionsFilename) {
 255       std::string Error;
 256       OS = new llvm::raw_fd_ostream(getDriver().CCPrintOptionsFilename,
 257                                     Error,
 258                                     llvm::raw_fd_ostream::F_Append);
 259       if (!Error.empty()) {
 260         getDriver().Diag(clang::diag::err_drv_cc_print_options_failure)
 261           << Error;
 262         FailingCommand = &C;
 263         delete OS;
 264         return 1;
 265       }
 266     }
 267
 268     if (getDriver().CCPrintOptions)
 269       *OS << "[Logging clang options]";
 270
 271     PrintJob(*OS, C, "\n", /*Quote=*/getDriver().CCPrintOptions);
 272
 273     if (OS != &llvm::errs())
 274       delete OS;
 275   }
 276
 277   std::string Error;
 278   int Res =
 279     llvm::sys::Program::ExecuteAndWait(Prog, Argv,
 280                                        /*env*/0, Redirects,
 281                                        /*secondsToWait*/0, /*memoryLimit*/0,
 282                                        &Error);
 283   if (!Error.empty()) {
 284     assert(Res && "Error string set with 0 result code!");
 285     getDriver().Diag(clang::diag::err_drv_command_failure) << Error;
 286   }
 287
 288   if (Res)
 289     FailingCommand = &C;
 290
 291   delete[] Argv;
 292   return Res;
 293 }
 294
 295 int Compilation::ExecuteJob(const Job &J,
 296                             const Command *&FailingCommand) const {
 297   if (const Command *C = dyn_cast<Command>(&J)) {
 298     return ExecuteCommand(*C, FailingCommand);
 299   } else {
 300     const JobList *Jobs = cast<JobList>(&J);
 301     for (JobList::const_iterator
 302            it = Jobs->begin(), ie = Jobs->end(); it != ie; ++it)
 303       if (int Res = ExecuteJob(**it, FailingCommand))
 304         return Res;
 305     return 0;
 306   }
 307 }
 308
 309 void Compilation::initCompilationForDiagnostics(void) {
 310   // Free actions and jobs.
 311   DeleteContainerPointers(Actions);
 312   Jobs.clear();
 313
 314   // Clear temporary/results file lists.
 315   TempFiles.clear();
 316   ResultFiles.clear();
 317
 318   // Remove any user specified output.  Claim any unclaimed arguments, so as
 319   // to avoid emitting warnings about unused args.
 320   OptSpecifier OutputOpts[] = { options::OPT_o, options::OPT_MD,
 321                                 options::OPT_MMD };
 322   for (unsigned i = 0, e = llvm::array_lengthof(OutputOpts); i != e; ++i) {
 323     if (TranslatedArgs->hasArg(OutputOpts[i]))
 324       TranslatedArgs->eraseArg(OutputOpts[i]);
 325   }
 326   TranslatedArgs->ClaimAllArgs();
 327
 328   // Redirect stdout/stderr to /dev/null.
 329   Redirects = new const llvm::sys::Path*[3]();
 330   Redirects[1] = new const llvm::sys::Path();
 331   Redirects[2] = new const llvm::sys::Path();
 332 }
 333
 334 StringRef Compilation::getSysRoot(void) const {
 335   return getDriver().SysRoot;
 336 }