//===-- driver.cpp - Clang GCC-Compatible Driver --------------------------===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // This is the entry point to the clang driver; it is a thin wrapper // for functionality in the Driver clang library. // //===----------------------------------------------------------------------===// #include "clang/Driver/Compilation.h" #include "clang/Driver/Driver.h" #include "clang/Driver/Option.h" #include "clang/Frontend/DiagnosticOptions.h" #include "clang/Frontend/TextDiagnosticPrinter.h" #include "llvm/ADT/SmallString.h" #include "llvm/ADT/OwningPtr.h" #include "llvm/Config/config.h" #include "llvm/Support/ManagedStatic.h" #include "llvm/Support/PrettyStackTrace.h" #include "llvm/Support/Regex.h" #include "llvm/Support/raw_ostream.h" #include "llvm/System/Host.h" #include "llvm/System/Path.h" #include "llvm/System/Signals.h" using namespace clang; using namespace clang::driver; llvm::sys::Path GetExecutablePath(const char *Argv0, bool CanonicalPrefixes) { if (!CanonicalPrefixes) return llvm::sys::Path(Argv0); // This just needs to be some symbol in the binary; C++ doesn't // allow taking the address of ::main however. void *P = (void*) (intptr_t) GetExecutablePath; return llvm::sys::Path::GetMainExecutable(Argv0, P); } static const char *SaveStringInSet(std::set &SavedStrings, llvm::StringRef S) { return SavedStrings.insert(S).first->c_str(); } /// ApplyQAOverride - Apply a list of edits to the input argument lists. /// /// The input string is a space separate list of edits to perform, /// they are applied in order to the input argument lists. Edits /// should be one of the following forms: /// /// '#': Silence information about the changes to the command line arguments. /// /// '^': Add FOO as a new argument at the beginning of the command line. /// /// '+': Add FOO as a new argument at the end of the command line. /// /// 's/XXX/YYY/': Substitute the regular expression XXX with YYY in the command /// line. /// /// 'xOPTION': Removes all instances of the literal argument OPTION. /// /// 'XOPTION': Removes all instances of the literal argument OPTION, /// and the following argument. /// /// 'Ox': Removes all flags matching 'O' or 'O[sz0-9]' and adds 'Ox' /// at the end of the command line. /// /// \param OS - The stream to write edit information to. /// \param Args - The vector of command line arguments. /// \param Edit - The override command to perform. /// \param SavedStrings - Set to use for storing string representations. void ApplyOneQAOverride(llvm::raw_ostream &OS, std::vector &Args, llvm::StringRef Edit, std::set &SavedStrings) { // This does not need to be efficient. if (Edit[0] == '^') { const char *Str = SaveStringInSet(SavedStrings, Edit.substr(1)); OS << "### Adding argument " << Str << " at beginning\n"; Args.insert(Args.begin() + 1, Str); } else if (Edit[0] == '+') { const char *Str = SaveStringInSet(SavedStrings, Edit.substr(1)); OS << "### Adding argument " << Str << " at end\n"; Args.push_back(Str); } else if (Edit[0] == 's' && Edit[1] == '/' && Edit.endswith("/") && Edit.slice(2, Edit.size()-1).find('/') != llvm::StringRef::npos) { llvm::StringRef MatchPattern = Edit.substr(2).split('/').first; llvm::StringRef ReplPattern = Edit.substr(2).split('/').second; ReplPattern = ReplPattern.slice(0, ReplPattern.size()-1); for (unsigned i = 1, e = Args.size(); i != e; ++i) { std::string Repl = llvm::Regex(MatchPattern).sub(ReplPattern, Args[i]); if (Repl != Args[i]) { OS << "### Replacing '" << Args[i] << "' with '" << Repl << "'\n"; Args[i] = SaveStringInSet(SavedStrings, Repl); } } } else if (Edit[0] == 'x' || Edit[0] == 'X') { std::string Option = Edit.substr(1, std::string::npos); for (unsigned i = 1; i < Args.size();) { if (Option == Args[i]) { OS << "### Deleting argument " << Args[i] << '\n'; Args.erase(Args.begin() + i); if (Edit[0] == 'X') { if (i < Args.size()) { OS << "### Deleting argument " << Args[i] << '\n'; Args.erase(Args.begin() + i); } else OS << "### Invalid X edit, end of command line!\n"; } } else ++i; } } else if (Edit[0] == 'O') { for (unsigned i = 1; i < Args.size();) { const char *A = Args[i]; if (A[0] == '-' && A[1] == 'O' && (A[2] == '\0' || (A[3] == '\0' && (A[2] == 's' || A[2] == 'z' || ('0' <= A[2] && A[2] <= '9'))))) { OS << "### Deleting argument " << Args[i] << '\n'; Args.erase(Args.begin() + i); } else ++i; } OS << "### Adding argument " << Edit << " at end\n"; Args.push_back(SaveStringInSet(SavedStrings, '-' + Edit.str())); } else { OS << "### Unrecognized edit: " << Edit << "\n"; } } /// ApplyQAOverride - Apply a comma separate list of edits to the /// input argument lists. See ApplyOneQAOverride. void ApplyQAOverride(std::vector &Args, const char *OverrideStr, std::set &SavedStrings) { llvm::raw_ostream *OS = &llvm::errs(); if (OverrideStr[0] == '#') { ++OverrideStr; OS = &llvm::nulls(); } *OS << "### QA_OVERRIDE_GCC3_OPTIONS: " << OverrideStr << "\n"; // This does not need to be efficient. const char *S = OverrideStr; while (*S) { const char *End = ::strchr(S, ' '); if (!End) End = S + strlen(S); if (End != S) ApplyOneQAOverride(*OS, Args, std::string(S, End), SavedStrings); S = End; if (*S != '\0') ++S; } } extern int cc1_main(const char **ArgBegin, const char **ArgEnd, const char *Argv0, void *MainAddr); int main(int argc, const char **argv) { llvm::sys::PrintStackTraceOnErrorSignal(); llvm::PrettyStackTraceProgram X(argc, argv); // Dispatch to cc1_main if appropriate. if (argc > 1 && llvm::StringRef(argv[1]) == "-cc1") return cc1_main(argv+2, argv+argc, argv[0], (void*) (intptr_t) GetExecutablePath); bool CanonicalPrefixes = true; for (int i = 1; i < argc; ++i) { if (llvm::StringRef(argv[i]) == "-no-canonical-prefixes") { CanonicalPrefixes = false; break; } } llvm::sys::Path Path = GetExecutablePath(argv[0], CanonicalPrefixes); TextDiagnosticPrinter DiagClient(llvm::errs(), DiagnosticOptions()); DiagClient.setPrefix(Path.getBasename()); Diagnostic Diags(&DiagClient); #ifdef CLANG_IS_PRODUCTION const bool IsProduction = true; #else const bool IsProduction = false; #endif Driver TheDriver(Path.getBasename(), Path.getDirname(), llvm::sys::getHostTriple(), "a.out", IsProduction, Diags); // Check for ".*++" or ".*++-[^-]*" to determine if we are a C++ // compiler. This matches things like "c++", "clang++", and "clang++-1.1". // // Note that we intentionally want to use argv[0] here, to support "clang++" // being a symlink. // // We use *argv instead of argv[0] to work around a bogus g++ warning. std::string ProgName(llvm::sys::Path(*argv).getBasename()); if (llvm::StringRef(ProgName).endswith("++") || llvm::StringRef(ProgName).rsplit('-').first.endswith("++")) { TheDriver.CCCIsCXX = true; TheDriver.CCCGenericGCCName = "g++"; } llvm::OwningPtr C; // Handle CC_PRINT_OPTIONS and CC_PRINT_OPTIONS_FILE. TheDriver.CCPrintOptions = !!::getenv("CC_PRINT_OPTIONS"); if (TheDriver.CCPrintOptions) TheDriver.CCPrintOptionsFilename = ::getenv("CC_PRINT_OPTIONS_FILE"); // Handle QA_OVERRIDE_GCC3_OPTIONS and CCC_ADD_ARGS, used for editing a // command line behind the scenes. std::set SavedStrings; if (const char *OverrideStr = ::getenv("QA_OVERRIDE_GCC3_OPTIONS")) { // FIXME: Driver shouldn't take extra initial argument. std::vector StringPointers(argv, argv + argc); ApplyQAOverride(StringPointers, OverrideStr, SavedStrings); C.reset(TheDriver.BuildCompilation(StringPointers.size(), &StringPointers[0])); } else if (const char *Cur = ::getenv("CCC_ADD_ARGS")) { std::vector StringPointers; // FIXME: Driver shouldn't take extra initial argument. StringPointers.push_back(argv[0]); for (;;) { const char *Next = strchr(Cur, ','); if (Next) { StringPointers.push_back(SaveStringInSet(SavedStrings, std::string(Cur, Next))); Cur = Next + 1; } else { if (*Cur != '\0') StringPointers.push_back(SaveStringInSet(SavedStrings, Cur)); break; } } StringPointers.insert(StringPointers.end(), argv + 1, argv + argc); C.reset(TheDriver.BuildCompilation(StringPointers.size(), &StringPointers[0])); } else C.reset(TheDriver.BuildCompilation(argc, argv)); int Res = 0; if (C.get()) Res = TheDriver.ExecuteCompilation(*C); llvm::llvm_shutdown(); return Res; }