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
GetExecutablePath(const char * Argv0,bool CanonicalPrefixes)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
GetStableCStr(std::set<std::string> & SavedStrings,StringRef S)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.
ApplyOneQAOverride(raw_ostream & OS,SmallVectorImpl<const char * > & Args,StringRef Edit,std::set<std::string> & SavedStrings)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.
ApplyQAOverride(SmallVectorImpl<const char * > & Args,const char * OverrideStr,std::set<std::string> & SavedStrings)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
insertTargetAndModeArgs(const ParsedClangName & NameParts,SmallVectorImpl<const char * > & ArgVector,std::set<std::string> & SavedStrings)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
getCLEnvVarOptions(std::string & EnvValue,llvm::StringSaver & Saver,SmallVectorImpl<const char * > & Opts)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
SetBackdoorDriverOutputsFromEnvVars(Driver & TheDriver)246 static void SetBackdoorDriverOutputsFromEnvVars(Driver &TheDriver) {
247 // Handle CC_PRINT_OPTIONS and CC_PRINT_OPTIONS_FILE.
248 TheDriver.CCPrintOptions = !!::getenv("CC_PRINT_OPTIONS");
249 if (TheDriver.CCPrintOptions)
250 TheDriver.CCPrintOptionsFilename = ::getenv("CC_PRINT_OPTIONS_FILE");
251
252 // Handle CC_PRINT_HEADERS and CC_PRINT_HEADERS_FILE.
253 TheDriver.CCPrintHeaders = !!::getenv("CC_PRINT_HEADERS");
254 if (TheDriver.CCPrintHeaders)
255 TheDriver.CCPrintHeadersFilename = ::getenv("CC_PRINT_HEADERS_FILE");
256
257 // Handle CC_LOG_DIAGNOSTICS and CC_LOG_DIAGNOSTICS_FILE.
258 TheDriver.CCLogDiagnostics = !!::getenv("CC_LOG_DIAGNOSTICS");
259 if (TheDriver.CCLogDiagnostics)
260 TheDriver.CCLogDiagnosticsFilename = ::getenv("CC_LOG_DIAGNOSTICS_FILE");
261 }
262
FixupDiagPrefixExeName(TextDiagnosticPrinter * DiagClient,const std::string & Path)263 static void FixupDiagPrefixExeName(TextDiagnosticPrinter *DiagClient,
264 const std::string &Path) {
265 // If the clang binary happens to be named cl.exe for compatibility reasons,
266 // use clang-cl.exe as the prefix to avoid confusion between clang and MSVC.
267 StringRef ExeBasename(llvm::sys::path::stem(Path));
268 if (ExeBasename.equals_lower("cl"))
269 ExeBasename = "clang-cl";
270 DiagClient->setPrefix(std::string(ExeBasename));
271 }
272
273 // This lets us create the DiagnosticsEngine with a properly-filled-out
274 // DiagnosticOptions instance.
275 static DiagnosticOptions *
CreateAndPopulateDiagOpts(ArrayRef<const char * > argv,bool & UseNewCC1Process)276 CreateAndPopulateDiagOpts(ArrayRef<const char *> argv, bool &UseNewCC1Process) {
277 auto *DiagOpts = new DiagnosticOptions;
278 unsigned MissingArgIndex, MissingArgCount;
279 InputArgList Args = getDriverOptTable().ParseArgs(
280 argv.slice(1), MissingArgIndex, MissingArgCount);
281 // We ignore MissingArgCount and the return value of ParseDiagnosticArgs.
282 // Any errors that would be diagnosed here will also be diagnosed later,
283 // when the DiagnosticsEngine actually exists.
284 (void)ParseDiagnosticArgs(*DiagOpts, Args);
285
286 UseNewCC1Process =
287 Args.hasFlag(clang::driver::options::OPT_fno_integrated_cc1,
288 clang::driver::options::OPT_fintegrated_cc1,
289 /*Default=*/CLANG_SPAWN_CC1);
290
291 return DiagOpts;
292 }
293
SetInstallDir(SmallVectorImpl<const char * > & argv,Driver & TheDriver,bool CanonicalPrefixes)294 static void SetInstallDir(SmallVectorImpl<const char *> &argv,
295 Driver &TheDriver, bool CanonicalPrefixes) {
296 // Attempt to find the original path used to invoke the driver, to determine
297 // the installed path. We do this manually, because we want to support that
298 // path being a symlink.
299 SmallString<128> InstalledPath(argv[0]);
300
301 // Do a PATH lookup, if there are no directory components.
302 if (llvm::sys::path::filename(InstalledPath) == InstalledPath)
303 if (llvm::ErrorOr<std::string> Tmp = llvm::sys::findProgramByName(
304 llvm::sys::path::filename(InstalledPath.str())))
305 InstalledPath = *Tmp;
306
307 // FIXME: We don't actually canonicalize this, we just make it absolute.
308 if (CanonicalPrefixes)
309 llvm::sys::fs::make_absolute(InstalledPath);
310
311 StringRef InstalledPathParent(llvm::sys::path::parent_path(InstalledPath));
312 if (llvm::sys::fs::exists(InstalledPathParent))
313 TheDriver.setInstalledDir(InstalledPathParent);
314 }
315
ExecuteCC1Tool(SmallVectorImpl<const char * > & ArgV)316 static int ExecuteCC1Tool(SmallVectorImpl<const char *> &ArgV) {
317 // If we call the cc1 tool from the clangDriver library (through
318 // Driver::CC1Main), we need to clean up the options usage count. The options
319 // are currently global, and they might have been used previously by the
320 // driver.
321 llvm::cl::ResetAllOptionOccurrences();
322
323 llvm::BumpPtrAllocator A;
324 llvm::StringSaver Saver(A);
325 llvm::cl::ExpandResponseFiles(Saver, &llvm::cl::TokenizeGNUCommandLine, ArgV,
326 /*MarkEOLs=*/false);
327 StringRef Tool = ArgV[1];
328 void *GetExecutablePathVP = (void *)(intptr_t)GetExecutablePath;
329 if (Tool == "-cc1")
330 return cc1_main(makeArrayRef(ArgV).slice(1), ArgV[0], GetExecutablePathVP);
331 if (Tool == "-cc1as")
332 return cc1as_main(makeArrayRef(ArgV).slice(2), ArgV[0],
333 GetExecutablePathVP);
334 if (Tool == "-cc1gen-reproducer")
335 return cc1gen_reproducer_main(makeArrayRef(ArgV).slice(2), ArgV[0],
336 GetExecutablePathVP);
337 // Reject unknown tools.
338 llvm::errs() << "error: unknown integrated tool '" << Tool << "'. "
339 << "Valid tools include '-cc1' and '-cc1as'.\n";
340 return 1;
341 }
342
main(int argc_,const char ** argv_)343 int main(int argc_, const char **argv_) {
344 noteBottomOfStack();
345 llvm::InitLLVM X(argc_, argv_);
346 llvm::setBugReportMsg("PLEASE submit a bug report to " BUG_REPORT_URL
347 " and include the crash backtrace, preprocessed "
348 "source, and associated run script.\n");
349 SmallVector<const char *, 256> argv(argv_, argv_ + argc_);
350
351 if (llvm::sys::Process::FixupStandardFileDescriptors())
352 return 1;
353
354 llvm::InitializeAllTargets();
355 auto TargetAndMode = ToolChain::getTargetAndModeFromProgramName(argv[0]);
356
357 llvm::BumpPtrAllocator A;
358 llvm::StringSaver Saver(A);
359
360 // Parse response files using the GNU syntax, unless we're in CL mode. There
361 // are two ways to put clang in CL compatibility mode: argv[0] is either
362 // clang-cl or cl, or --driver-mode=cl is on the command line. The normal
363 // command line parsing can't happen until after response file parsing, so we
364 // have to manually search for a --driver-mode=cl argument the hard way.
365 // Finally, our -cc1 tools don't care which tokenization mode we use because
366 // response files written by clang will tokenize the same way in either mode.
367 bool ClangCLMode = false;
368 if (StringRef(TargetAndMode.DriverMode).equals("--driver-mode=cl") ||
369 llvm::find_if(argv, [](const char *F) {
370 return F && strcmp(F, "--driver-mode=cl") == 0;
371 }) != argv.end()) {
372 ClangCLMode = true;
373 }
374 enum { Default, POSIX, Windows } RSPQuoting = Default;
375 for (const char *F : argv) {
376 if (strcmp(F, "--rsp-quoting=posix") == 0)
377 RSPQuoting = POSIX;
378 else if (strcmp(F, "--rsp-quoting=windows") == 0)
379 RSPQuoting = Windows;
380 }
381
382 // Determines whether we want nullptr markers in argv to indicate response
383 // files end-of-lines. We only use this for the /LINK driver argument with
384 // clang-cl.exe on Windows.
385 bool MarkEOLs = ClangCLMode;
386
387 llvm::cl::TokenizerCallback Tokenizer;
388 if (RSPQuoting == Windows || (RSPQuoting == Default && ClangCLMode))
389 Tokenizer = &llvm::cl::TokenizeWindowsCommandLine;
390 else
391 Tokenizer = &llvm::cl::TokenizeGNUCommandLine;
392
393 if (MarkEOLs && argv.size() > 1 && StringRef(argv[1]).startswith("-cc1"))
394 MarkEOLs = false;
395 llvm::cl::ExpandResponseFiles(Saver, Tokenizer, argv, MarkEOLs);
396
397 // Handle -cc1 integrated tools, even if -cc1 was expanded from a response
398 // file.
399 auto FirstArg = std::find_if(argv.begin() + 1, argv.end(),
400 [](const char *A) { return A != nullptr; });
401 if (FirstArg != argv.end() && StringRef(*FirstArg).startswith("-cc1")) {
402 // If -cc1 came from a response file, remove the EOL sentinels.
403 if (MarkEOLs) {
404 auto newEnd = std::remove(argv.begin(), argv.end(), nullptr);
405 argv.resize(newEnd - argv.begin());
406 }
407 return ExecuteCC1Tool(argv);
408 }
409
410 // Handle options that need handling before the real command line parsing in
411 // Driver::BuildCompilation()
412 bool CanonicalPrefixes = true;
413 for (int i = 1, size = argv.size(); i < size; ++i) {
414 // Skip end-of-line response file markers
415 if (argv[i] == nullptr)
416 continue;
417 if (StringRef(argv[i]) == "-no-canonical-prefixes") {
418 CanonicalPrefixes = false;
419 break;
420 }
421 }
422
423 // Handle CL and _CL_ which permits additional command line options to be
424 // prepended or appended.
425 if (ClangCLMode) {
426 // Arguments in "CL" are prepended.
427 llvm::Optional<std::string> OptCL = llvm::sys::Process::GetEnv("CL");
428 if (OptCL.hasValue()) {
429 SmallVector<const char *, 8> PrependedOpts;
430 getCLEnvVarOptions(OptCL.getValue(), Saver, PrependedOpts);
431
432 // Insert right after the program name to prepend to the argument list.
433 argv.insert(argv.begin() + 1, PrependedOpts.begin(), PrependedOpts.end());
434 }
435 // Arguments in "_CL_" are appended.
436 llvm::Optional<std::string> Opt_CL_ = llvm::sys::Process::GetEnv("_CL_");
437 if (Opt_CL_.hasValue()) {
438 SmallVector<const char *, 8> AppendedOpts;
439 getCLEnvVarOptions(Opt_CL_.getValue(), Saver, AppendedOpts);
440
441 // Insert at the end of the argument list to append.
442 argv.append(AppendedOpts.begin(), AppendedOpts.end());
443 }
444 }
445
446 std::set<std::string> SavedStrings;
447 // Handle CCC_OVERRIDE_OPTIONS, used for editing a command line behind the
448 // scenes.
449 if (const char *OverrideStr = ::getenv("CCC_OVERRIDE_OPTIONS")) {
450 // FIXME: Driver shouldn't take extra initial argument.
451 ApplyQAOverride(argv, OverrideStr, SavedStrings);
452 }
453
454 std::string Path = GetExecutablePath(argv[0], CanonicalPrefixes);
455
456 // Whether the cc1 tool should be called inside the current process, or if we
457 // should spawn a new clang subprocess (old behavior).
458 // Not having an additional process saves some execution time of Windows,
459 // and makes debugging and profiling easier.
460 bool UseNewCC1Process;
461
462 IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts =
463 CreateAndPopulateDiagOpts(argv, UseNewCC1Process);
464
465 TextDiagnosticPrinter *DiagClient
466 = new TextDiagnosticPrinter(llvm::errs(), &*DiagOpts);
467 FixupDiagPrefixExeName(DiagClient, Path);
468
469 IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
470
471 DiagnosticsEngine Diags(DiagID, &*DiagOpts, DiagClient);
472
473 if (!DiagOpts->DiagnosticSerializationFile.empty()) {
474 auto SerializedConsumer =
475 clang::serialized_diags::create(DiagOpts->DiagnosticSerializationFile,
476 &*DiagOpts, /*MergeChildRecords=*/true);
477 Diags.setClient(new ChainedDiagnosticConsumer(
478 Diags.takeClient(), std::move(SerializedConsumer)));
479 }
480
481 ProcessWarningOptions(Diags, *DiagOpts, /*ReportDiags=*/false);
482
483 Driver TheDriver(Path, llvm::sys::getDefaultTargetTriple(), Diags);
484 SetInstallDir(argv, TheDriver, CanonicalPrefixes);
485 TheDriver.setTargetAndMode(TargetAndMode);
486
487 insertTargetAndModeArgs(TargetAndMode, argv, SavedStrings);
488
489 SetBackdoorDriverOutputsFromEnvVars(TheDriver);
490
491 if (!UseNewCC1Process) {
492 TheDriver.CC1Main = &ExecuteCC1Tool;
493 // Ensure the CC1Command actually catches cc1 crashes
494 llvm::CrashRecoveryContext::Enable();
495 }
496
497 std::unique_ptr<Compilation> C(TheDriver.BuildCompilation(argv));
498 int Res = 1;
499 bool IsCrash = false;
500 if (C && !C->containsError()) {
501 SmallVector<std::pair<int, const Command *>, 4> FailingCommands;
502 Res = TheDriver.ExecuteCompilation(*C, FailingCommands);
503
504 // Force a crash to test the diagnostics.
505 if (TheDriver.GenReproducer) {
506 Diags.Report(diag::err_drv_force_crash)
507 << !::getenv("FORCE_CLANG_DIAGNOSTICS_CRASH");
508
509 // Pretend that every command failed.
510 FailingCommands.clear();
511 for (const auto &J : C->getJobs())
512 if (const Command *C = dyn_cast<Command>(&J))
513 FailingCommands.push_back(std::make_pair(-1, C));
514
515 // Print the bug report message that would be printed if we did actually
516 // crash, but only if we're crashing due to FORCE_CLANG_DIAGNOSTICS_CRASH.
517 if (::getenv("FORCE_CLANG_DIAGNOSTICS_CRASH"))
518 llvm::dbgs() << llvm::getBugReportMsg();
519 }
520
521 for (const auto &P : FailingCommands) {
522 int CommandRes = P.first;
523 const Command *FailingCommand = P.second;
524 if (!Res)
525 Res = CommandRes;
526
527 // If result status is < 0, then the driver command signalled an error.
528 // If result status is 70, then the driver command reported a fatal error.
529 // On Windows, abort will return an exit code of 3. In these cases,
530 // generate additional diagnostic information if possible.
531 IsCrash = CommandRes < 0 || CommandRes == 70;
532 #ifdef _WIN32
533 IsCrash |= CommandRes == 3;
534 #endif
535 #if LLVM_ON_UNIX
536 // When running in integrated-cc1 mode, the CrashRecoveryContext returns
537 // the same codes as if the program crashed. See section "Exit Status for
538 // Commands":
539 // https://pubs.opengroup.org/onlinepubs/9699919799/xrat/V4_xcu_chap02.html
540 IsCrash |= CommandRes > 128;
541 #endif
542 if (IsCrash) {
543 TheDriver.generateCompilationDiagnostics(*C, *FailingCommand);
544 break;
545 }
546 }
547 }
548
549 Diags.getClient()->finish();
550
551 if (!UseNewCC1Process && IsCrash) {
552 // When crashing in -fintegrated-cc1 mode, bury the timer pointers, because
553 // the internal linked list might point to already released stack frames.
554 llvm::BuryPointer(llvm::TimerGroup::aquireDefaultGroup());
555 } else {
556 // If any timers were active but haven't been destroyed yet, print their
557 // results now. This happens in -disable-free mode.
558 llvm::TimerGroup::printAll(llvm::errs());
559 llvm::TimerGroup::clearAll();
560 }
561
562 #ifdef _WIN32
563 // Exit status should not be negative on Win32, unless abnormal termination.
564 // Once abnormal termination was caught, negative status should not be
565 // propagated.
566 if (Res < 0)
567 Res = 1;
568 #endif
569
570 // If we have multiple failing commands, we return the result of the first
571 // failing command.
572 return Res;
573 }
574