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