Home | History | Annotate | Download | only in driver 
      1 //===-- driver.cpp - Clang GCC-Compatible Driver --------------------------===//
      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 // This is the entry point to the clang driver; it is a thin wrapper
     11 // for functionality in the Driver clang library.
     12 //
     13 //===----------------------------------------------------------------------===//
     14 
     15 #include "clang/Driver/ArgList.h"
     16 #include "clang/Driver/Options.h"
     17 #include "clang/Driver/Compilation.h"
     18 #include "clang/Driver/Driver.h"
     19 #include "clang/Driver/Option.h"
     20 #include "clang/Driver/OptTable.h"
     21 #include "clang/Frontend/CompilerInvocation.h"
     22 #include "clang/Frontend/DiagnosticOptions.h"
     23 #include "clang/Frontend/TextDiagnosticPrinter.h"
     24 #include "clang/Frontend/Utils.h"
     25 
     26 #include "llvm/ADT/ArrayRef.h"
     27 #include "llvm/ADT/SmallString.h"
     28 #include "llvm/ADT/SmallVector.h"
     29 #include "llvm/ADT/OwningPtr.h"
     30 #include "llvm/Support/ErrorHandling.h"
     31 #include "llvm/Support/FileSystem.h"
     32 #include "llvm/Support/ManagedStatic.h"
     33 #include "llvm/Support/MemoryBuffer.h"
     34 #include "llvm/Support/PrettyStackTrace.h"
     35 #include "llvm/Support/Regex.h"
     36 #include "llvm/Support/Timer.h"
     37 #include "llvm/Support/raw_ostream.h"
     38 #include "llvm/Support/Host.h"
     39 #include "llvm/Support/Path.h"
     40 #include "llvm/Support/Program.h"
     41 #include "llvm/Support/Signals.h"
     42 #include "llvm/Support/TargetRegistry.h"
     43 #include "llvm/Support/TargetSelect.h"
     44 #include "llvm/Support/system_error.h"
     45 #include <cctype>
     46 using namespace clang;
     47 using namespace clang::driver;
     48 
     49 llvm::sys::Path GetExecutablePath(const char *Argv0, bool CanonicalPrefixes) {
     50   if (!CanonicalPrefixes)
     51     return llvm::sys::Path(Argv0);
     52 
     53   // This just needs to be some symbol in the binary; C++ doesn't
     54   // allow taking the address of ::main however.
     55   void *P = (void*) (intptr_t) GetExecutablePath;
     56   return llvm::sys::Path::GetMainExecutable(Argv0, P);
     57 }
     58 
     59 static const char *SaveStringInSet(std::set<std::string> &SavedStrings,
     60                                    StringRef S) {
     61   return SavedStrings.insert(S).first->c_str();
     62 }
     63 
     64 /// ApplyQAOverride - Apply a list of edits to the input argument lists.
     65 ///
     66 /// The input string is a space separate list of edits to perform,
     67 /// they are applied in order to the input argument lists. Edits
     68 /// should be one of the following forms:
     69 ///
     70 ///  '#': Silence information about the changes to the command line arguments.
     71 ///
     72 ///  '^': Add FOO as a new argument at the beginning of the command line.
     73 ///
     74 ///  '+': Add FOO as a new argument at the end of the command line.
     75 ///
     76 ///  's/XXX/YYY/': Substitute the regular expression XXX with YYY in the command
     77 ///  line.
     78 ///
     79 ///  'xOPTION': Removes all instances of the literal argument OPTION.
     80 ///
     81 ///  'XOPTION': Removes all instances of the literal argument OPTION,
     82 ///  and the following argument.
     83 ///
     84 ///  'Ox': Removes all flags matching 'O' or 'O[sz0-9]' and adds 'Ox'
     85 ///  at the end of the command line.
     86 ///
     87 /// \param OS - The stream to write edit information to.
     88 /// \param Args - The vector of command line arguments.
     89 /// \param Edit - The override command to perform.
     90 /// \param SavedStrings - Set to use for storing string representations.
     91 static void ApplyOneQAOverride(raw_ostream &OS,
     92                                SmallVectorImpl<const char*> &Args,
     93                                StringRef Edit,
     94                                std::set<std::string> &SavedStrings) {
     95   // This does not need to be efficient.
     96 
     97   if (Edit[0] == '^') {
     98     const char *Str =
     99       SaveStringInSet(SavedStrings, Edit.substr(1));
    100     OS << "### Adding argument " << Str << " at beginning\n";
    101     Args.insert(Args.begin() + 1, Str);
    102   } else if (Edit[0] == '+') {
    103     const char *Str =
    104       SaveStringInSet(SavedStrings, Edit.substr(1));
    105     OS << "### Adding argument " << Str << " at end\n";
    106     Args.push_back(Str);
    107   } else if (Edit[0] == 's' && Edit[1] == '/' && Edit.endswith("/") &&
    108              Edit.slice(2, Edit.size()-1).find('/') != StringRef::npos) {
    109     StringRef MatchPattern = Edit.substr(2).split('/').first;
    110     StringRef ReplPattern = Edit.substr(2).split('/').second;
    111     ReplPattern = ReplPattern.slice(0, ReplPattern.size()-1);
    112 
    113     for (unsigned i = 1, e = Args.size(); i != e; ++i) {
    114       std::string Repl = llvm::Regex(MatchPattern).sub(ReplPattern, Args[i]);
    115 
    116       if (Repl != Args[i]) {
    117         OS << "### Replacing '" << Args[i] << "' with '" << Repl << "'\n";
    118         Args[i] = SaveStringInSet(SavedStrings, Repl);
    119       }
    120     }
    121   } else if (Edit[0] == 'x' || Edit[0] == 'X') {
    122     std::string Option = Edit.substr(1, std::string::npos);
    123     for (unsigned i = 1; i < Args.size();) {
    124       if (Option == Args[i]) {
    125         OS << "### Deleting argument " << Args[i] << '\n';
    126         Args.erase(Args.begin() + i);
    127         if (Edit[0] == 'X') {
    128           if (i < Args.size()) {
    129             OS << "### Deleting argument " << Args[i] << '\n';
    130             Args.erase(Args.begin() + i);
    131           } else
    132             OS << "### Invalid X edit, end of command line!\n";
    133         }
    134       } else
    135         ++i;
    136     }
    137   } else if (Edit[0] == 'O') {
    138     for (unsigned i = 1; i < Args.size();) {
    139       const char *A = Args[i];
    140       if (A[0] == '-' && A[1] == 'O' &&
    141           (A[2] == '\0' ||
    142            (A[3] == '\0' && (A[2] == 's' || A[2] == 'z' ||
    143                              ('0' <= A[2] && A[2] <= '9'))))) {
    144         OS << "### Deleting argument " << Args[i] << '\n';
    145         Args.erase(Args.begin() + i);
    146       } else
    147         ++i;
    148     }
    149     OS << "### Adding argument " << Edit << " at end\n";
    150     Args.push_back(SaveStringInSet(SavedStrings, '-' + Edit.str()));
    151   } else {
    152     OS << "### Unrecognized edit: " << Edit << "\n";
    153   }
    154 }
    155 
    156 /// ApplyQAOverride - Apply a comma separate list of edits to the
    157 /// input argument lists. See ApplyOneQAOverride.
    158 static void ApplyQAOverride(SmallVectorImpl<const char*> &Args,
    159                             const char *OverrideStr,
    160                             std::set<std::string> &SavedStrings) {
    161   raw_ostream *OS = &llvm::errs();
    162 
    163   if (OverrideStr[0] == '#') {
    164     ++OverrideStr;
    165     OS = &llvm::nulls();
    166   }
    167 
    168   *OS << "### QA_OVERRIDE_GCC3_OPTIONS: " << OverrideStr << "\n";
    169 
    170   // This does not need to be efficient.
    171 
    172   const char *S = OverrideStr;
    173   while (*S) {
    174     const char *End = ::strchr(S, ' ');
    175     if (!End)
    176       End = S + strlen(S);
    177     if (End != S)
    178       ApplyOneQAOverride(*OS, Args, std::string(S, End), SavedStrings);
    179     S = End;
    180     if (*S != '\0')
    181       ++S;
    182   }
    183 }
    184 
    185 extern int cc1_main(const char **ArgBegin, const char **ArgEnd,
    186                     const char *Argv0, void *MainAddr);
    187 extern int cc1as_main(const char **ArgBegin, const char **ArgEnd,
    188                       const char *Argv0, void *MainAddr);
    189 
    190 static void ExpandArgsFromBuf(const char *Arg,
    191                               SmallVectorImpl<const char*> &ArgVector,
    192                               std::set<std::string> &SavedStrings) {
    193   const char *FName = Arg + 1;
    194   OwningPtr<llvm::MemoryBuffer> MemBuf;
    195   if (llvm::MemoryBuffer::getFile(FName, MemBuf)) {
    196     ArgVector.push_back(SaveStringInSet(SavedStrings, Arg));
    197     return;
    198   }
    199 
    200   const char *Buf = MemBuf->getBufferStart();
    201   char InQuote = ' ';
    202   std::string CurArg;
    203 
    204   for (const char *P = Buf; ; ++P) {
    205     if (*P == '\0' || (isspace(*P) && InQuote == ' ')) {
    206       if (!CurArg.empty()) {
    207 
    208         if (CurArg[0] != '@') {
    209           ArgVector.push_back(SaveStringInSet(SavedStrings, CurArg));
    210         } else {
    211           ExpandArgsFromBuf(CurArg.c_str(), ArgVector, SavedStrings);
    212         }
    213 
    214         CurArg = "";
    215       }
    216       if (*P == '\0')
    217         break;
    218       else
    219         continue;
    220     }
    221 
    222     if (isspace(*P)) {
    223       if (InQuote != ' ')
    224         CurArg.push_back(*P);
    225       continue;
    226     }
    227 
    228     if (*P == '"' || *P == '\'') {
    229       if (InQuote == *P)
    230         InQuote = ' ';
    231       else if (InQuote == ' ')
    232         InQuote = *P;
    233       else
    234         CurArg.push_back(*P);
    235       continue;
    236     }
    237 
    238     if (*P == '\\') {
    239       ++P;
    240       if (*P != '\0')
    241         CurArg.push_back(*P);
    242       continue;
    243     }
    244     CurArg.push_back(*P);
    245   }
    246 }
    247 
    248 static void ExpandArgv(int argc, const char **argv,
    249                        SmallVectorImpl<const char*> &ArgVector,
    250                        std::set<std::string> &SavedStrings) {
    251   for (int i = 0; i < argc; ++i) {
    252     const char *Arg = argv[i];
    253     if (Arg[0] != '@') {
    254       ArgVector.push_back(SaveStringInSet(SavedStrings, std::string(Arg)));
    255       continue;
    256     }
    257 
    258     ExpandArgsFromBuf(Arg, ArgVector, SavedStrings);
    259   }
    260 }
    261 
    262 static void ParseProgName(SmallVectorImpl<const char *> &ArgVector,
    263                           std::set<std::string> &SavedStrings,
    264                           Driver &TheDriver)
    265 {
    266   // Try to infer frontend type and default target from the program name.
    267 
    268   // suffixes[] contains the list of known driver suffixes.
    269   // Suffixes are compared against the program name in order.
    270   // If there is a match, the frontend type is updated as necessary (CPP/C++).
    271   // If there is no match, a second round is done after stripping the last
    272   // hyphen and everything following it. This allows using something like
    273   // "clang++-2.9".
    274 
    275   // If there is a match in either the first or second round,
    276   // the function tries to identify a target as prefix. E.g.
    277   // "x86_64-linux-clang" as interpreted as suffix "clang" with
    278   // target prefix "x86_64-linux". If such a target prefix is found,
    279   // is gets added via -target as implicit first argument.
    280   static const struct {
    281     const char *Suffix;
    282     bool IsCXX;
    283     bool IsCPP;
    284   } suffixes [] = {
    285     { "clang", false, false },
    286     { "clang++", true, false },
    287     { "clang-c++", true, false },
    288     { "clang-cc", false, false },
    289     { "clang-cpp", false, true },
    290     { "clang-g++", true, false },
    291     { "clang-gcc", false, false },
    292     { "cc", false, false },
    293     { "cpp", false, true },
    294     { "++", true, false },
    295   };
    296   std::string ProgName(llvm::sys::path::stem(ArgVector[0]));
    297   StringRef ProgNameRef(ProgName);
    298   StringRef Prefix;
    299 
    300   for (int Components = 2; Components; --Components) {
    301     bool FoundMatch = false;
    302     size_t i;
    303 
    304     for (i = 0; i < sizeof(suffixes) / sizeof(suffixes[0]); ++i) {
    305       if (ProgNameRef.endswith(suffixes[i].Suffix)) {
    306         FoundMatch = true;
    307         if (suffixes[i].IsCXX)
    308           TheDriver.CCCIsCXX = true;
    309         if (suffixes[i].IsCPP)
    310           TheDriver.CCCIsCPP = true;
    311         break;
    312       }
    313     }
    314 
    315     if (FoundMatch) {
    316       StringRef::size_type LastComponent = ProgNameRef.rfind('-',
    317         ProgNameRef.size() - strlen(suffixes[i].Suffix));
    318       if (LastComponent != StringRef::npos)
    319         Prefix = ProgNameRef.slice(0, LastComponent);
    320       break;
    321     }
    322 
    323     StringRef::size_type LastComponent = ProgNameRef.rfind('-');
    324     if (LastComponent == StringRef::npos)
    325       break;
    326     ProgNameRef = ProgNameRef.slice(0, LastComponent);
    327   }
    328 
    329   if (Prefix.empty())
    330     return;
    331 
    332   std::string IgnoredError;
    333   if (llvm::TargetRegistry::lookupTarget(Prefix, IgnoredError)) {
    334     SmallVectorImpl<const char *>::iterator it = ArgVector.begin();
    335     if (it != ArgVector.end())
    336       ++it;
    337     ArgVector.insert(it, SaveStringInSet(SavedStrings, Prefix));
    338     ArgVector.insert(it,
    339       SaveStringInSet(SavedStrings, std::string("-target")));
    340   }
    341 }
    342 
    343 int main(int argc_, const char **argv_) {
    344   llvm::sys::PrintStackTraceOnErrorSignal();
    345   llvm::PrettyStackTraceProgram X(argc_, argv_);
    346 
    347   std::set<std::string> SavedStrings;
    348   SmallVector<const char*, 256> argv;
    349 
    350   ExpandArgv(argc_, argv_, argv, SavedStrings);
    351 
    352   // Handle -cc1 integrated tools.
    353   if (argv.size() > 1 && StringRef(argv[1]).startswith("-cc1")) {
    354     StringRef Tool = argv[1] + 4;
    355 
    356     if (Tool == "")
    357       return cc1_main(argv.data()+2, argv.data()+argv.size(), argv[0],
    358                       (void*) (intptr_t) GetExecutablePath);
    359     if (Tool == "as")
    360       return cc1as_main(argv.data()+2, argv.data()+argv.size(), argv[0],
    361                       (void*) (intptr_t) GetExecutablePath);
    362 
    363     // Reject unknown tools.
    364     llvm::errs() << "error: unknown integrated tool '" << Tool << "'\n";
    365     return 1;
    366   }
    367 
    368   bool CanonicalPrefixes = true;
    369   for (int i = 1, size = argv.size(); i < size; ++i) {
    370     if (StringRef(argv[i]) == "-no-canonical-prefixes") {
    371       CanonicalPrefixes = false;
    372       break;
    373     }
    374   }
    375 
    376   llvm::sys::Path Path = GetExecutablePath(argv[0], CanonicalPrefixes);
    377 
    378   DiagnosticOptions DiagOpts;
    379   {
    380     // Note that ParseDiagnosticArgs() uses the cc1 option table.
    381     OwningPtr<OptTable> CC1Opts(createDriverOptTable());
    382     unsigned MissingArgIndex, MissingArgCount;
    383     OwningPtr<InputArgList> Args(CC1Opts->ParseArgs(argv.begin()+1, argv.end(),
    384                                             MissingArgIndex, MissingArgCount));
    385     // We ignore MissingArgCount and the return value of ParseDiagnosticArgs.
    386     // Any errors that would be diagnosed here will also be diagnosed later,
    387     // when the DiagnosticsEngine actually exists.
    388     (void) ParseDiagnosticArgs(DiagOpts, *Args);
    389   }
    390   // Now we can create the DiagnosticsEngine with a properly-filled-out
    391   // DiagnosticOptions instance.
    392   TextDiagnosticPrinter *DiagClient
    393     = new TextDiagnosticPrinter(llvm::errs(), DiagOpts);
    394   DiagClient->setPrefix(llvm::sys::path::stem(Path.str()));
    395   IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
    396 
    397   DiagnosticsEngine Diags(DiagID, DiagClient);
    398   ProcessWarningOptions(Diags, DiagOpts);
    399 
    400 #ifdef CLANG_IS_PRODUCTION
    401   const bool IsProduction = true;
    402 #else
    403   const bool IsProduction = false;
    404 #endif
    405   Driver TheDriver(Path.str(), llvm::sys::getDefaultTargetTriple(),
    406                    "a.out", IsProduction, Diags);
    407 
    408   // Attempt to find the original path used to invoke the driver, to determine
    409   // the installed path. We do this manually, because we want to support that
    410   // path being a symlink.
    411   {
    412     SmallString<128> InstalledPath(argv[0]);
    413 
    414     // Do a PATH lookup, if there are no directory components.
    415     if (llvm::sys::path::filename(InstalledPath) == InstalledPath) {
    416       llvm::sys::Path Tmp = llvm::sys::Program::FindProgramByName(
    417         llvm::sys::path::filename(InstalledPath.str()));
    418       if (!Tmp.empty())
    419         InstalledPath = Tmp.str();
    420     }
    421     llvm::sys::fs::make_absolute(InstalledPath);
    422     InstalledPath = llvm::sys::path::parent_path(InstalledPath);
    423     bool exists;
    424     if (!llvm::sys::fs::exists(InstalledPath.str(), exists) && exists)
    425       TheDriver.setInstalledDir(InstalledPath);
    426   }
    427 
    428   llvm::InitializeAllTargets();
    429   ParseProgName(argv, SavedStrings, TheDriver);
    430 
    431   // Handle CC_PRINT_OPTIONS and CC_PRINT_OPTIONS_FILE.
    432   TheDriver.CCPrintOptions = !!::getenv("CC_PRINT_OPTIONS");
    433   if (TheDriver.CCPrintOptions)
    434     TheDriver.CCPrintOptionsFilename = ::getenv("CC_PRINT_OPTIONS_FILE");
    435 
    436   // Handle CC_PRINT_HEADERS and CC_PRINT_HEADERS_FILE.
    437   TheDriver.CCPrintHeaders = !!::getenv("CC_PRINT_HEADERS");
    438   if (TheDriver.CCPrintHeaders)
    439     TheDriver.CCPrintHeadersFilename = ::getenv("CC_PRINT_HEADERS_FILE");
    440 
    441   // Handle CC_LOG_DIAGNOSTICS and CC_LOG_DIAGNOSTICS_FILE.
    442   TheDriver.CCLogDiagnostics = !!::getenv("CC_LOG_DIAGNOSTICS");
    443   if (TheDriver.CCLogDiagnostics)
    444     TheDriver.CCLogDiagnosticsFilename = ::getenv("CC_LOG_DIAGNOSTICS_FILE");
    445 
    446   // Handle QA_OVERRIDE_GCC3_OPTIONS and CCC_ADD_ARGS, used for editing a
    447   // command line behind the scenes.
    448   if (const char *OverrideStr = ::getenv("QA_OVERRIDE_GCC3_OPTIONS")) {
    449     // FIXME: Driver shouldn't take extra initial argument.
    450     ApplyQAOverride(argv, OverrideStr, SavedStrings);
    451   } else if (const char *Cur = ::getenv("CCC_ADD_ARGS")) {
    452     // FIXME: Driver shouldn't take extra initial argument.
    453     std::vector<const char*> ExtraArgs;
    454 
    455     for (;;) {
    456       const char *Next = strchr(Cur, ',');
    457 
    458       if (Next) {
    459         ExtraArgs.push_back(SaveStringInSet(SavedStrings,
    460                                             std::string(Cur, Next)));
    461         Cur = Next + 1;
    462       } else {
    463         if (*Cur != '\0')
    464           ExtraArgs.push_back(SaveStringInSet(SavedStrings, Cur));
    465         break;
    466       }
    467     }
    468 
    469     argv.insert(&argv[1], ExtraArgs.begin(), ExtraArgs.end());
    470   }
    471 
    472   OwningPtr<Compilation> C(TheDriver.BuildCompilation(argv));
    473   int Res = 0;
    474   const Command *FailingCommand = 0;
    475   if (C.get())
    476     Res = TheDriver.ExecuteCompilation(*C, FailingCommand);
    477 
    478   // Force a crash to test the diagnostics.
    479   if(::getenv("FORCE_CLANG_DIAGNOSTICS_CRASH"))
    480      Res = -1;
    481 
    482   // If result status is < 0, then the driver command signalled an error.
    483   // In this case, generate additional diagnostic information if possible.
    484   if (Res < 0)
    485     TheDriver.generateCompilationDiagnostics(*C, FailingCommand);
    486 
    487   // If any timers were active but haven't been destroyed yet, print their
    488   // results now.  This happens in -disable-free mode.
    489   llvm::TimerGroup::printAll(llvm::errs());
    490 
    491   llvm::llvm_shutdown();
    492 
    493 #ifdef _WIN32
    494   // Exit status should not be negative on Win32, unless abnormal termination.
    495   // Once abnormal termiation was caught, negative status should not be
    496   // propagated.
    497   if (Res < 0)
    498     Res = 1;
    499 #endif
    500 
    501   return Res;
    502 }
    503