1 //===-- driver.cpp - Clang GCC-Compatible Driver --------------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // This is the entry point to the clang driver; it is a thin wrapper 10 // for functionality in the Driver clang library. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #include "clang/Driver/Driver.h" 15 #include "clang/Basic/DiagnosticOptions.h" 16 #include "clang/Basic/Stack.h" 17 #include "clang/Config/config.h" 18 #include "clang/Driver/Compilation.h" 19 #include "clang/Driver/DriverDiagnostic.h" 20 #include "clang/Driver/Options.h" 21 #include "clang/Driver/ToolChain.h" 22 #include "clang/Frontend/ChainedDiagnosticConsumer.h" 23 #include "clang/Frontend/CompilerInvocation.h" 24 #include "clang/Frontend/SerializedDiagnosticPrinter.h" 25 #include "clang/Frontend/TextDiagnosticPrinter.h" 26 #include "clang/Frontend/Utils.h" 27 #include "llvm/ADT/ArrayRef.h" 28 #include "llvm/ADT/SmallString.h" 29 #include "llvm/ADT/SmallVector.h" 30 #include "llvm/Option/ArgList.h" 31 #include "llvm/Option/OptTable.h" 32 #include "llvm/Option/Option.h" 33 #include "llvm/Support/BuryPointer.h" 34 #include "llvm/Support/CommandLine.h" 35 #include "llvm/Support/CrashRecoveryContext.h" 36 #include "llvm/Support/ErrorHandling.h" 37 #include "llvm/Support/FileSystem.h" 38 #include "llvm/Support/Host.h" 39 #include "llvm/Support/InitLLVM.h" 40 #include "llvm/Support/Path.h" 41 #include "llvm/Support/PrettyStackTrace.h" 42 #include "llvm/Support/Process.h" 43 #include "llvm/Support/Program.h" 44 #include "llvm/Support/Regex.h" 45 #include "llvm/Support/Signals.h" 46 #include "llvm/Support/StringSaver.h" 47 #include "llvm/Support/TargetSelect.h" 48 #include "llvm/Support/Timer.h" 49 #include "llvm/Support/raw_ostream.h" 50 #include <memory> 51 #include <set> 52 #include <system_error> 53 using namespace clang; 54 using namespace clang::driver; 55 using namespace llvm::opt; 56 57 std::string GetExecutablePath(const char *Argv0, bool CanonicalPrefixes) { 58 if (!CanonicalPrefixes) { 59 SmallString<128> ExecutablePath(Argv0); 60 // Do a PATH lookup if Argv0 isn't a valid path. 61 if (!llvm::sys::fs::exists(ExecutablePath)) 62 if (llvm::ErrorOr<std::string> P = 63 llvm::sys::findProgramByName(ExecutablePath)) 64 ExecutablePath = *P; 65 return std::string(ExecutablePath.str()); 66 } 67 68 // This just needs to be some symbol in the binary; C++ doesn't 69 // allow taking the address of ::main however. 70 void *P = (void*) (intptr_t) GetExecutablePath; 71 return llvm::sys::fs::getMainExecutable(Argv0, P); 72 } 73 74 static const char *GetStableCStr(std::set<std::string> &SavedStrings, 75 StringRef S) { 76 return SavedStrings.insert(std::string(S)).first->c_str(); 77 } 78 79 /// ApplyQAOverride - Apply a list of edits to the input argument lists. 80 /// 81 /// The input string is a space separate list of edits to perform, 82 /// they are applied in order to the input argument lists. Edits 83 /// should be one of the following forms: 84 /// 85 /// '#': Silence information about the changes to the command line arguments. 86 /// 87 /// '^': Add FOO as a new argument at the beginning of the command line. 88 /// 89 /// '+': Add FOO as a new argument at the end of the command line. 90 /// 91 /// 's/XXX/YYY/': Substitute the regular expression XXX with YYY in the command 92 /// line. 93 /// 94 /// 'xOPTION': Removes all instances of the literal argument OPTION. 95 /// 96 /// 'XOPTION': Removes all instances of the literal argument OPTION, 97 /// and the following argument. 98 /// 99 /// 'Ox': Removes all flags matching 'O' or 'O[sz0-9]' and adds 'Ox' 100 /// at the end of the command line. 101 /// 102 /// \param OS - The stream to write edit information to. 103 /// \param Args - The vector of command line arguments. 104 /// \param Edit - The override command to perform. 105 /// \param SavedStrings - Set to use for storing string representations. 106 static void ApplyOneQAOverride(raw_ostream &OS, 107 SmallVectorImpl<const char*> &Args, 108 StringRef Edit, 109 std::set<std::string> &SavedStrings) { 110 // This does not need to be efficient. 111 112 if (Edit[0] == '^') { 113 const char *Str = 114 GetStableCStr(SavedStrings, Edit.substr(1)); 115 OS << "### Adding argument " << Str << " at beginning\n"; 116 Args.insert(Args.begin() + 1, Str); 117 } else if (Edit[0] == '+') { 118 const char *Str = 119 GetStableCStr(SavedStrings, Edit.substr(1)); 120 OS << "### Adding argument " << Str << " at end\n"; 121 Args.push_back(Str); 122 } else if (Edit[0] == 's' && Edit[1] == '/' && Edit.endswith("/") && 123 Edit.slice(2, Edit.size()-1).find('/') != StringRef::npos) { 124 StringRef MatchPattern = Edit.substr(2).split('/').first; 125 StringRef ReplPattern = Edit.substr(2).split('/').second; 126 ReplPattern = ReplPattern.slice(0, ReplPattern.size()-1); 127 128 for (unsigned i = 1, e = Args.size(); i != e; ++i) { 129 // Ignore end-of-line response file markers 130 if (Args[i] == nullptr) 131 continue; 132 std::string Repl = llvm::Regex(MatchPattern).sub(ReplPattern, Args[i]); 133 134 if (Repl != Args[i]) { 135 OS << "### Replacing '" << Args[i] << "' with '" << Repl << "'\n"; 136 Args[i] = GetStableCStr(SavedStrings, Repl); 137 } 138 } 139 } else if (Edit[0] == 'x' || Edit[0] == 'X') { 140 auto Option = Edit.substr(1); 141 for (unsigned i = 1; i < Args.size();) { 142 if (Option == Args[i]) { 143 OS << "### Deleting argument " << Args[i] << '\n'; 144 Args.erase(Args.begin() + i); 145 if (Edit[0] == 'X') { 146 if (i < Args.size()) { 147 OS << "### Deleting argument " << Args[i] << '\n'; 148 Args.erase(Args.begin() + i); 149 } else 150 OS << "### Invalid X edit, end of command line!\n"; 151 } 152 } else 153 ++i; 154 } 155 } else if (Edit[0] == 'O') { 156 for (unsigned i = 1; i < Args.size();) { 157 const char *A = Args[i]; 158 // Ignore end-of-line response file markers 159 if (A == nullptr) 160 continue; 161 if (A[0] == '-' && A[1] == 'O' && 162 (A[2] == '\0' || 163 (A[3] == '\0' && (A[2] == 's' || A[2] == 'z' || 164 ('0' <= A[2] && A[2] <= '9'))))) { 165 OS << "### Deleting argument " << Args[i] << '\n'; 166 Args.erase(Args.begin() + i); 167 } else 168 ++i; 169 } 170 OS << "### Adding argument " << Edit << " at end\n"; 171 Args.push_back(GetStableCStr(SavedStrings, '-' + Edit.str())); 172 } else { 173 OS << "### Unrecognized edit: " << Edit << "\n"; 174 } 175 } 176 177 /// ApplyQAOverride - Apply a comma separate list of edits to the 178 /// input argument lists. See ApplyOneQAOverride. 179 static void ApplyQAOverride(SmallVectorImpl<const char*> &Args, 180 const char *OverrideStr, 181 std::set<std::string> &SavedStrings) { 182 raw_ostream *OS = &llvm::errs(); 183 184 if (OverrideStr[0] == '#') { 185 ++OverrideStr; 186 OS = &llvm::nulls(); 187 } 188 189 *OS << "### CCC_OVERRIDE_OPTIONS: " << OverrideStr << "\n"; 190 191 // This does not need to be efficient. 192 193 const char *S = OverrideStr; 194 while (*S) { 195 const char *End = ::strchr(S, ' '); 196 if (!End) 197 End = S + strlen(S); 198 if (End != S) 199 ApplyOneQAOverride(*OS, Args, std::string(S, End), SavedStrings); 200 S = End; 201 if (*S != '\0') 202 ++S; 203 } 204 } 205 206 extern int cc1_main(ArrayRef<const char *> Argv, const char *Argv0, 207 void *MainAddr); 208 extern int cc1as_main(ArrayRef<const char *> Argv, const char *Argv0, 209 void *MainAddr); 210 extern int cc1gen_reproducer_main(ArrayRef<const char *> Argv, 211 const char *Argv0, void *MainAddr); 212 213 static void insertTargetAndModeArgs(const ParsedClangName &NameParts, 214 SmallVectorImpl<const char *> &ArgVector, 215 std::set<std::string> &SavedStrings) { 216 // Put target and mode arguments at the start of argument list so that 217 // arguments specified in command line could override them. Avoid putting 218 // them at index 0, as an option like '-cc1' must remain the first. 219 int InsertionPoint = 0; 220 if (ArgVector.size() > 0) 221 ++InsertionPoint; 222 223 if (NameParts.DriverMode) { 224 // Add the mode flag to the arguments. 225 ArgVector.insert(ArgVector.begin() + InsertionPoint, 226 GetStableCStr(SavedStrings, NameParts.DriverMode)); 227 } 228 229 if (NameParts.TargetIsValid) { 230 const char *arr[] = {"-target", GetStableCStr(SavedStrings, 231 NameParts.TargetPrefix)}; 232 ArgVector.insert(ArgVector.begin() + InsertionPoint, 233 std::begin(arr), std::end(arr)); 234 } 235 } 236 237 static void getCLEnvVarOptions(std::string &EnvValue, llvm::StringSaver &Saver, 238 SmallVectorImpl<const char *> &Opts) { 239 llvm::cl::TokenizeWindowsCommandLine(EnvValue, Saver, Opts); 240 // The first instance of '#' should be replaced with '=' in each option. 241 for (const char *Opt : Opts) 242 if (char *NumberSignPtr = const_cast<char *>(::strchr(Opt, '#'))) 243 *NumberSignPtr = '='; 244 } 245 246 static void SetBackdoorDriverOutputsFromEnvVars(Driver &TheDriver) { 247 auto CheckEnvVar = [](const char *EnvOptSet, const char *EnvOptFile, 248 std::string &OptFile) { 249 bool OptSet = !!::getenv(EnvOptSet); 250 if (OptSet) { 251 if (const char *Var = ::getenv(EnvOptFile)) 252 OptFile = Var; 253 } 254 return OptSet; 255 }; 256 257 TheDriver.CCPrintOptions = 258 CheckEnvVar("CC_PRINT_OPTIONS", "CC_PRINT_OPTIONS_FILE", 259 TheDriver.CCPrintOptionsFilename); 260 TheDriver.CCPrintHeaders = 261 CheckEnvVar("CC_PRINT_HEADERS", "CC_PRINT_HEADERS_FILE", 262 TheDriver.CCPrintHeadersFilename); 263 TheDriver.CCLogDiagnostics = 264 CheckEnvVar("CC_LOG_DIAGNOSTICS", "CC_LOG_DIAGNOSTICS_FILE", 265 TheDriver.CCLogDiagnosticsFilename); 266 TheDriver.CCPrintProcessStats = 267 CheckEnvVar("CC_PRINT_PROC_STAT", "CC_PRINT_PROC_STAT_FILE", 268 TheDriver.CCPrintStatReportFilename); 269 } 270 271 static void FixupDiagPrefixExeName(TextDiagnosticPrinter *DiagClient, 272 const std::string &Path) { 273 // If the clang binary happens to be named cl.exe for compatibility reasons, 274 // use clang-cl.exe as the prefix to avoid confusion between clang and MSVC. 275 StringRef ExeBasename(llvm::sys::path::stem(Path)); 276 if (ExeBasename.equals_lower("cl")) 277 ExeBasename = "clang-cl"; 278 DiagClient->setPrefix(std::string(ExeBasename)); 279 } 280 281 // This lets us create the DiagnosticsEngine with a properly-filled-out 282 // DiagnosticOptions instance. 283 static DiagnosticOptions * 284 CreateAndPopulateDiagOpts(ArrayRef<const char *> argv, bool &UseNewCC1Process) { 285 auto *DiagOpts = new DiagnosticOptions; 286 unsigned MissingArgIndex, MissingArgCount; 287 InputArgList Args = getDriverOptTable().ParseArgs( 288 argv.slice(1), MissingArgIndex, MissingArgCount); 289 // We ignore MissingArgCount and the return value of ParseDiagnosticArgs. 290 // Any errors that would be diagnosed here will also be diagnosed later, 291 // when the DiagnosticsEngine actually exists. 292 (void)ParseDiagnosticArgs(*DiagOpts, Args); 293 294 UseNewCC1Process = 295 Args.hasFlag(clang::driver::options::OPT_fno_integrated_cc1, 296 clang::driver::options::OPT_fintegrated_cc1, 297 /*Default=*/CLANG_SPAWN_CC1); 298 299 return DiagOpts; 300 } 301 302 static void SetInstallDir(SmallVectorImpl<const char *> &argv, 303 Driver &TheDriver, bool CanonicalPrefixes) { 304 // Attempt to find the original path used to invoke the driver, to determine 305 // the installed path. We do this manually, because we want to support that 306 // path being a symlink. 307 SmallString<128> InstalledPath(argv[0]); 308 309 // Do a PATH lookup, if there are no directory components. 310 if (llvm::sys::path::filename(InstalledPath) == InstalledPath) 311 if (llvm::ErrorOr<std::string> Tmp = llvm::sys::findProgramByName( 312 llvm::sys::path::filename(InstalledPath.str()))) 313 InstalledPath = *Tmp; 314 315 // FIXME: We don't actually canonicalize this, we just make it absolute. 316 if (CanonicalPrefixes) 317 llvm::sys::fs::make_absolute(InstalledPath); 318 319 StringRef InstalledPathParent(llvm::sys::path::parent_path(InstalledPath)); 320 if (llvm::sys::fs::exists(InstalledPathParent)) 321 TheDriver.setInstalledDir(InstalledPathParent); 322 } 323 324 static int ExecuteCC1Tool(SmallVectorImpl<const char *> &ArgV) { 325 // If we call the cc1 tool from the clangDriver library (through 326 // Driver::CC1Main), we need to clean up the options usage count. The options 327 // are currently global, and they might have been used previously by the 328 // driver. 329 llvm::cl::ResetAllOptionOccurrences(); 330 331 llvm::BumpPtrAllocator A; 332 llvm::StringSaver Saver(A); 333 llvm::cl::ExpandResponseFiles(Saver, &llvm::cl::TokenizeGNUCommandLine, ArgV, 334 /*MarkEOLs=*/false); 335 StringRef Tool = ArgV[1]; 336 void *GetExecutablePathVP = (void *)(intptr_t)GetExecutablePath; 337 if (Tool == "-cc1") 338 return cc1_main(makeArrayRef(ArgV).slice(1), ArgV[0], GetExecutablePathVP); 339 if (Tool == "-cc1as") 340 return cc1as_main(makeArrayRef(ArgV).slice(2), ArgV[0], 341 GetExecutablePathVP); 342 if (Tool == "-cc1gen-reproducer") 343 return cc1gen_reproducer_main(makeArrayRef(ArgV).slice(2), ArgV[0], 344 GetExecutablePathVP); 345 // Reject unknown tools. 346 llvm::errs() << "error: unknown integrated tool '" << Tool << "'. " 347 << "Valid tools include '-cc1' and '-cc1as'.\n"; 348 return 1; 349 } 350 351 int main(int Argc, const char **Argv) { 352 noteBottomOfStack(); 353 llvm::InitLLVM X(Argc, Argv); 354 llvm::setBugReportMsg("PLEASE submit a bug report to " BUG_REPORT_URL 355 " and include the crash backtrace, preprocessed " 356 "source, and associated run script.\n"); 357 SmallVector<const char *, 256> Args(Argv, Argv + Argc); 358 359 if (llvm::sys::Process::FixupStandardFileDescriptors()) 360 return 1; 361 362 llvm::InitializeAllTargets(); 363 auto TargetAndMode = ToolChain::getTargetAndModeFromProgramName(Args[0]); 364 365 llvm::BumpPtrAllocator A; 366 llvm::StringSaver Saver(A); 367 368 // Parse response files using the GNU syntax, unless we're in CL mode. There 369 // are two ways to put clang in CL compatibility mode: Args[0] is either 370 // clang-cl or cl, or --driver-mode=cl is on the command line. The normal 371 // command line parsing can't happen until after response file parsing, so we 372 // have to manually search for a --driver-mode=cl argument the hard way. 373 // Finally, our -cc1 tools don't care which tokenization mode we use because 374 // response files written by clang will tokenize the same way in either mode. 375 bool ClangCLMode = false; 376 if (StringRef(TargetAndMode.DriverMode).equals("--driver-mode=cl") || 377 llvm::find_if(Args, [](const char *F) { 378 return F && strcmp(F, "--driver-mode=cl") == 0; 379 }) != Args.end()) { 380 ClangCLMode = true; 381 } 382 enum { Default, POSIX, Windows } RSPQuoting = Default; 383 for (const char *F : Args) { 384 if (strcmp(F, "--rsp-quoting=posix") == 0) 385 RSPQuoting = POSIX; 386 else if (strcmp(F, "--rsp-quoting=windows") == 0) 387 RSPQuoting = Windows; 388 } 389 390 // Determines whether we want nullptr markers in Args to indicate response 391 // files end-of-lines. We only use this for the /LINK driver argument with 392 // clang-cl.exe on Windows. 393 bool MarkEOLs = ClangCLMode; 394 395 llvm::cl::TokenizerCallback Tokenizer; 396 if (RSPQuoting == Windows || (RSPQuoting == Default && ClangCLMode)) 397 Tokenizer = &llvm::cl::TokenizeWindowsCommandLine; 398 else 399 Tokenizer = &llvm::cl::TokenizeGNUCommandLine; 400 401 if (MarkEOLs && Args.size() > 1 && StringRef(Args[1]).startswith("-cc1")) 402 MarkEOLs = false; 403 llvm::cl::ExpandResponseFiles(Saver, Tokenizer, Args, MarkEOLs); 404 405 // Handle -cc1 integrated tools, even if -cc1 was expanded from a response 406 // file. 407 auto FirstArg = std::find_if(Args.begin() + 1, Args.end(), 408 [](const char *A) { return A != nullptr; }); 409 if (FirstArg != Args.end() && StringRef(*FirstArg).startswith("-cc1")) { 410 // If -cc1 came from a response file, remove the EOL sentinels. 411 if (MarkEOLs) { 412 auto newEnd = std::remove(Args.begin(), Args.end(), nullptr); 413 Args.resize(newEnd - Args.begin()); 414 } 415 return ExecuteCC1Tool(Args); 416 } 417 418 // Handle options that need handling before the real command line parsing in 419 // Driver::BuildCompilation() 420 bool CanonicalPrefixes = true; 421 for (int i = 1, size = Args.size(); i < size; ++i) { 422 // Skip end-of-line response file markers 423 if (Args[i] == nullptr) 424 continue; 425 if (StringRef(Args[i]) == "-no-canonical-prefixes") { 426 CanonicalPrefixes = false; 427 break; 428 } 429 } 430 431 // Handle CL and _CL_ which permits additional command line options to be 432 // prepended or appended. 433 if (ClangCLMode) { 434 // Arguments in "CL" are prepended. 435 llvm::Optional<std::string> OptCL = llvm::sys::Process::GetEnv("CL"); 436 if (OptCL.hasValue()) { 437 SmallVector<const char *, 8> PrependedOpts; 438 getCLEnvVarOptions(OptCL.getValue(), Saver, PrependedOpts); 439 440 // Insert right after the program name to prepend to the argument list. 441 Args.insert(Args.begin() + 1, PrependedOpts.begin(), PrependedOpts.end()); 442 } 443 // Arguments in "_CL_" are appended. 444 llvm::Optional<std::string> Opt_CL_ = llvm::sys::Process::GetEnv("_CL_"); 445 if (Opt_CL_.hasValue()) { 446 SmallVector<const char *, 8> AppendedOpts; 447 getCLEnvVarOptions(Opt_CL_.getValue(), Saver, AppendedOpts); 448 449 // Insert at the end of the argument list to append. 450 Args.append(AppendedOpts.begin(), AppendedOpts.end()); 451 } 452 } 453 454 std::set<std::string> SavedStrings; 455 // Handle CCC_OVERRIDE_OPTIONS, used for editing a command line behind the 456 // scenes. 457 if (const char *OverrideStr = ::getenv("CCC_OVERRIDE_OPTIONS")) { 458 // FIXME: Driver shouldn't take extra initial argument. 459 ApplyQAOverride(Args, OverrideStr, SavedStrings); 460 } 461 462 std::string Path = GetExecutablePath(Args[0], CanonicalPrefixes); 463 464 // Whether the cc1 tool should be called inside the current process, or if we 465 // should spawn a new clang subprocess (old behavior). 466 // Not having an additional process saves some execution time of Windows, 467 // and makes debugging and profiling easier. 468 bool UseNewCC1Process; 469 470 IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = 471 CreateAndPopulateDiagOpts(Args, UseNewCC1Process); 472 473 TextDiagnosticPrinter *DiagClient 474 = new TextDiagnosticPrinter(llvm::errs(), &*DiagOpts); 475 FixupDiagPrefixExeName(DiagClient, Path); 476 477 IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs()); 478 479 DiagnosticsEngine Diags(DiagID, &*DiagOpts, DiagClient); 480 481 if (!DiagOpts->DiagnosticSerializationFile.empty()) { 482 auto SerializedConsumer = 483 clang::serialized_diags::create(DiagOpts->DiagnosticSerializationFile, 484 &*DiagOpts, /*MergeChildRecords=*/true); 485 Diags.setClient(new ChainedDiagnosticConsumer( 486 Diags.takeClient(), std::move(SerializedConsumer))); 487 } 488 489 ProcessWarningOptions(Diags, *DiagOpts, /*ReportDiags=*/false); 490 491 Driver TheDriver(Path, llvm::sys::getDefaultTargetTriple(), Diags); 492 SetInstallDir(Args, TheDriver, CanonicalPrefixes); 493 TheDriver.setTargetAndMode(TargetAndMode); 494 495 insertTargetAndModeArgs(TargetAndMode, Args, SavedStrings); 496 497 SetBackdoorDriverOutputsFromEnvVars(TheDriver); 498 499 if (!UseNewCC1Process) { 500 TheDriver.CC1Main = &ExecuteCC1Tool; 501 // Ensure the CC1Command actually catches cc1 crashes 502 llvm::CrashRecoveryContext::Enable(); 503 } 504 505 std::unique_ptr<Compilation> C(TheDriver.BuildCompilation(Args)); 506 int Res = 1; 507 bool IsCrash = false; 508 if (C && !C->containsError()) { 509 SmallVector<std::pair<int, const Command *>, 4> FailingCommands; 510 Res = TheDriver.ExecuteCompilation(*C, FailingCommands); 511 512 // Force a crash to test the diagnostics. 513 if (TheDriver.GenReproducer) { 514 Diags.Report(diag::err_drv_force_crash) 515 << !::getenv("FORCE_CLANG_DIAGNOSTICS_CRASH"); 516 517 // Pretend that every command failed. 518 FailingCommands.clear(); 519 for (const auto &J : C->getJobs()) 520 if (const Command *C = dyn_cast<Command>(&J)) 521 FailingCommands.push_back(std::make_pair(-1, C)); 522 523 // Print the bug report message that would be printed if we did actually 524 // crash, but only if we're crashing due to FORCE_CLANG_DIAGNOSTICS_CRASH. 525 if (::getenv("FORCE_CLANG_DIAGNOSTICS_CRASH")) 526 llvm::dbgs() << llvm::getBugReportMsg(); 527 } 528 529 for (const auto &P : FailingCommands) { 530 int CommandRes = P.first; 531 const Command *FailingCommand = P.second; 532 if (!Res) 533 Res = CommandRes; 534 535 // If result status is < 0, then the driver command signalled an error. 536 // If result status is 70, then the driver command reported a fatal error. 537 // On Windows, abort will return an exit code of 3. In these cases, 538 // generate additional diagnostic information if possible. 539 IsCrash = CommandRes < 0 || CommandRes == 70; 540 #ifdef _WIN32 541 IsCrash |= CommandRes == 3; 542 #endif 543 #if LLVM_ON_UNIX 544 // When running in integrated-cc1 mode, the CrashRecoveryContext returns 545 // the same codes as if the program crashed. See section "Exit Status for 546 // Commands": 547 // https://pubs.opengroup.org/onlinepubs/9699919799/xrat/V4_xcu_chap02.html 548 IsCrash |= CommandRes > 128; 549 #endif 550 if (IsCrash) { 551 TheDriver.generateCompilationDiagnostics(*C, *FailingCommand); 552 break; 553 } 554 } 555 } 556 557 Diags.getClient()->finish(); 558 559 if (!UseNewCC1Process && IsCrash) { 560 // When crashing in -fintegrated-cc1 mode, bury the timer pointers, because 561 // the internal linked list might point to already released stack frames. 562 llvm::BuryPointer(llvm::TimerGroup::aquireDefaultGroup()); 563 } else { 564 // If any timers were active but haven't been destroyed yet, print their 565 // results now. This happens in -disable-free mode. 566 llvm::TimerGroup::printAll(llvm::errs()); 567 llvm::TimerGroup::clearAll(); 568 } 569 570 #ifdef _WIN32 571 // Exit status should not be negative on Win32, unless abnormal termination. 572 // Once abnormal termination was caught, negative status should not be 573 // propagated. 574 if (Res < 0) 575 Res = 1; 576 #endif 577 578 // If we have multiple failing commands, we return the result of the first 579 // failing command. 580 return Res; 581 } 582