1 //===--- Driver.cpp - Clang GCC Compatible Driver -------------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #include "clang/Driver/Driver.h"
11 #include "InputInfo.h"
12 #include "ToolChains.h"
13 #include "clang/Basic/Version.h"
14 #include "clang/Driver/Action.h"
15 #include "clang/Driver/Compilation.h"
16 #include "clang/Driver/DriverDiagnostic.h"
17 #include "clang/Driver/Job.h"
18 #include "clang/Driver/Options.h"
19 #include "clang/Driver/Tool.h"
20 #include "clang/Driver/ToolChain.h"
21 #include "llvm/ADT/ArrayRef.h"
22 #include "llvm/ADT/OwningPtr.h"
23 #include "llvm/ADT/STLExtras.h"
24 #include "llvm/ADT/StringSet.h"
25 #include "llvm/ADT/StringSwitch.h"
26 #include "llvm/Option/Arg.h"
27 #include "llvm/Option/ArgList.h"
28 #include "llvm/Option/OptTable.h"
29 #include "llvm/Option/Option.h"
30 #include "llvm/Option/OptSpecifier.h"
31 #include "llvm/Support/Debug.h"
32 #include "llvm/Support/ErrorHandling.h"
33 #include "llvm/Support/FileSystem.h"
34 #include "llvm/Support/Path.h"
35 #include "llvm/Support/PrettyStackTrace.h"
36 #include "llvm/Support/Program.h"
37 #include "llvm/Support/raw_ostream.h"
40 // FIXME: It would prevent us from including llvm-config.h
41 // if config.h were included before system_error.h.
42 #include "clang/Config/config.h"
44 using namespace clang::driver;
45 using namespace clang;
46 using namespace llvm::opt;
48 Driver::Driver(StringRef ClangExecutable,
49 StringRef DefaultTargetTriple,
50 StringRef DefaultImageName,
51 DiagnosticsEngine &Diags)
52 : Opts(createDriverOptTable()), Diags(Diags), Mode(GCCMode),
53 ClangExecutable(ClangExecutable), SysRoot(DEFAULT_SYSROOT),
54 UseStdLib(true), DefaultTargetTriple(DefaultTargetTriple),
55 DefaultImageName(DefaultImageName),
56 DriverTitle("clang LLVM compiler"),
57 CCPrintOptionsFilename(0), CCPrintHeadersFilename(0),
58 CCLogDiagnosticsFilename(0),
59 CCCPrintBindings(false),
60 CCPrintHeaders(false), CCLogDiagnostics(false),
61 CCGenDiagnostics(false), CCCGenericGCCName(""), CheckInputsExist(true),
62 CCCUsePCH(true), SuppressMissingInputWarning(false) {
64 Name = llvm::sys::path::stem(ClangExecutable);
65 Dir = llvm::sys::path::parent_path(ClangExecutable);
67 // Compute the path to the resource directory.
68 StringRef ClangResourceDir(CLANG_RESOURCE_DIR);
69 SmallString<128> P(Dir);
70 if (ClangResourceDir != "")
71 llvm::sys::path::append(P, ClangResourceDir);
73 llvm::sys::path::append(P, "..", "lib", "clang", CLANG_VERSION_STRING);
74 ResourceDir = P.str();
80 for (llvm::StringMap<ToolChain *>::iterator I = ToolChains.begin(),
86 void Driver::ParseDriverMode(ArrayRef<const char *> Args) {
87 const std::string OptName =
88 getOpts().getOption(options::OPT_driver_mode).getPrefixedName();
90 for (size_t I = 0, E = Args.size(); I != E; ++I) {
91 const StringRef Arg = Args[I];
92 if (!Arg.startswith(OptName))
95 const StringRef Value = Arg.drop_front(OptName.size());
96 const unsigned M = llvm::StringSwitch<unsigned>(Value)
104 Mode = static_cast<DriverMode>(M);
106 Diag(diag::err_drv_unsupported_option_argument) << OptName << Value;
110 InputArgList *Driver::ParseArgStrings(ArrayRef<const char *> ArgList) {
111 llvm::PrettyStackTraceString CrashInfo("Command line argument parsing");
113 unsigned IncludedFlagsBitmask;
114 unsigned ExcludedFlagsBitmask;
115 llvm::tie(IncludedFlagsBitmask, ExcludedFlagsBitmask) =
116 getIncludeExcludeOptionFlagMasks();
118 unsigned MissingArgIndex, MissingArgCount;
119 InputArgList *Args = getOpts().ParseArgs(ArgList.begin(), ArgList.end(),
120 MissingArgIndex, MissingArgCount,
121 IncludedFlagsBitmask,
122 ExcludedFlagsBitmask);
124 // Check for missing argument error.
126 Diag(clang::diag::err_drv_missing_argument)
127 << Args->getArgString(MissingArgIndex) << MissingArgCount;
129 // Check for unsupported options.
130 for (ArgList::const_iterator it = Args->begin(), ie = Args->end();
133 if (A->getOption().hasFlag(options::Unsupported)) {
134 Diag(clang::diag::err_drv_unsupported_opt) << A->getAsString(*Args);
138 // Warn about -mcpu= without an argument.
139 if (A->getOption().matches(options::OPT_mcpu_EQ) &&
140 A->containsValue("")) {
141 Diag(clang::diag::warn_drv_empty_joined_argument) <<
142 A->getAsString(*Args);
146 for (arg_iterator it = Args->filtered_begin(options::OPT_UNKNOWN),
147 ie = Args->filtered_end(); it != ie; ++it) {
148 Diags.Report(diag::err_drv_unknown_argument) << (*it) ->getAsString(*Args);
154 // Determine which compilation mode we are in. We look for options which
155 // affect the phase, starting with the earliest phases, and record which
156 // option we used to determine the final phase.
157 phases::ID Driver::getFinalPhase(const DerivedArgList &DAL, Arg **FinalPhaseArg)
160 phases::ID FinalPhase;
162 // -{E,M,MM} only run the preprocessor.
164 (PhaseArg = DAL.getLastArg(options::OPT_E)) ||
165 (PhaseArg = DAL.getLastArg(options::OPT_M, options::OPT_MM))) {
166 FinalPhase = phases::Preprocess;
168 // -{fsyntax-only,-analyze,emit-ast,S} only run up to the compiler.
169 } else if ((PhaseArg = DAL.getLastArg(options::OPT_fsyntax_only)) ||
170 (PhaseArg = DAL.getLastArg(options::OPT_module_file_info)) ||
171 (PhaseArg = DAL.getLastArg(options::OPT_rewrite_objc)) ||
172 (PhaseArg = DAL.getLastArg(options::OPT_rewrite_legacy_objc)) ||
173 (PhaseArg = DAL.getLastArg(options::OPT__migrate)) ||
174 (PhaseArg = DAL.getLastArg(options::OPT__analyze,
175 options::OPT__analyze_auto)) ||
176 (PhaseArg = DAL.getLastArg(options::OPT_emit_ast)) ||
177 (PhaseArg = DAL.getLastArg(options::OPT_S))) {
178 FinalPhase = phases::Compile;
180 // -c only runs up to the assembler.
181 } else if ((PhaseArg = DAL.getLastArg(options::OPT_c))) {
182 FinalPhase = phases::Assemble;
184 // Otherwise do everything.
186 FinalPhase = phases::Link;
189 *FinalPhaseArg = PhaseArg;
194 static Arg* MakeInputArg(const DerivedArgList &Args, OptTable *Opts,
196 Arg *A = new Arg(Opts->getOption(options::OPT_INPUT), Value,
197 Args.getBaseArgs().MakeIndex(Value), Value.data());
202 DerivedArgList *Driver::TranslateInputArgs(const InputArgList &Args) const {
203 DerivedArgList *DAL = new DerivedArgList(Args);
205 bool HasNostdlib = Args.hasArg(options::OPT_nostdlib);
206 for (ArgList::const_iterator it = Args.begin(),
207 ie = Args.end(); it != ie; ++it) {
210 // Unfortunately, we have to parse some forwarding options (-Xassembler,
211 // -Xlinker, -Xpreprocessor) because we either integrate their functionality
212 // (assembler and preprocessor), or bypass a previous driver ('collect2').
214 // Rewrite linker options, to replace --no-demangle with a custom internal
216 if ((A->getOption().matches(options::OPT_Wl_COMMA) ||
217 A->getOption().matches(options::OPT_Xlinker)) &&
218 A->containsValue("--no-demangle")) {
219 // Add the rewritten no-demangle argument.
220 DAL->AddFlagArg(A, Opts->getOption(options::OPT_Z_Xlinker__no_demangle));
222 // Add the remaining values as Xlinker arguments.
223 for (unsigned i = 0, e = A->getNumValues(); i != e; ++i)
224 if (StringRef(A->getValue(i)) != "--no-demangle")
225 DAL->AddSeparateArg(A, Opts->getOption(options::OPT_Xlinker),
231 // Rewrite preprocessor options, to replace -Wp,-MD,FOO which is used by
232 // some build systems. We don't try to be complete here because we don't
233 // care to encourage this usage model.
234 if (A->getOption().matches(options::OPT_Wp_COMMA) &&
235 (A->getValue(0) == StringRef("-MD") ||
236 A->getValue(0) == StringRef("-MMD"))) {
237 // Rewrite to -MD/-MMD along with -MF.
238 if (A->getValue(0) == StringRef("-MD"))
239 DAL->AddFlagArg(A, Opts->getOption(options::OPT_MD));
241 DAL->AddFlagArg(A, Opts->getOption(options::OPT_MMD));
242 if (A->getNumValues() == 2)
243 DAL->AddSeparateArg(A, Opts->getOption(options::OPT_MF),
248 // Rewrite reserved library names.
249 if (A->getOption().matches(options::OPT_l)) {
250 StringRef Value = A->getValue();
252 // Rewrite unless -nostdlib is present.
253 if (!HasNostdlib && Value == "stdc++") {
254 DAL->AddFlagArg(A, Opts->getOption(
255 options::OPT_Z_reserved_lib_stdcxx));
259 // Rewrite unconditionally.
260 if (Value == "cc_kext") {
261 DAL->AddFlagArg(A, Opts->getOption(
262 options::OPT_Z_reserved_lib_cckext));
267 // Pick up inputs via the -- option.
268 if (A->getOption().matches(options::OPT__DASH_DASH)) {
270 for (unsigned i = 0, e = A->getNumValues(); i != e; ++i)
271 DAL->append(MakeInputArg(*DAL, Opts, A->getValue(i)));
278 // Add a default value of -mlinker-version=, if one was given and the user
279 // didn't specify one.
280 #if defined(HOST_LINK_VERSION)
281 if (!Args.hasArg(options::OPT_mlinker_version_EQ)) {
282 DAL->AddJoinedArg(0, Opts->getOption(options::OPT_mlinker_version_EQ),
284 DAL->getLastArg(options::OPT_mlinker_version_EQ)->claim();
291 Compilation *Driver::BuildCompilation(ArrayRef<const char *> ArgList) {
292 llvm::PrettyStackTraceString CrashInfo("Compilation construction");
294 // FIXME: Handle environment options which affect driver behavior, somewhere
295 // (client?). GCC_EXEC_PREFIX, LPATH, CC_PRINT_OPTIONS.
297 if (char *env = ::getenv("COMPILER_PATH")) {
298 StringRef CompilerPath = env;
299 while (!CompilerPath.empty()) {
300 std::pair<StringRef, StringRef> Split
301 = CompilerPath.split(llvm::sys::EnvPathSeparator);
302 PrefixDirs.push_back(Split.first);
303 CompilerPath = Split.second;
307 // We look for the driver mode option early, because the mode can affect
308 // how other options are parsed.
309 ParseDriverMode(ArgList.slice(1));
311 // FIXME: What are we going to do with -V and -b?
313 // FIXME: This stuff needs to go into the Compilation, not the driver.
314 bool CCCPrintActions;
316 InputArgList *Args = ParseArgStrings(ArgList.slice(1));
318 // -no-canonical-prefixes is used very early in main.
319 Args->ClaimAllArgs(options::OPT_no_canonical_prefixes);
322 Args->ClaimAllArgs(options::OPT_pipe);
324 // Extract -ccc args.
326 // FIXME: We need to figure out where this behavior should live. Most of it
327 // should be outside in the client; the parts that aren't should have proper
328 // options, either by introducing new ones or by overloading gcc ones like -V
330 CCCPrintActions = Args->hasArg(options::OPT_ccc_print_phases);
331 CCCPrintBindings = Args->hasArg(options::OPT_ccc_print_bindings);
332 if (const Arg *A = Args->getLastArg(options::OPT_ccc_gcc_name))
333 CCCGenericGCCName = A->getValue();
334 CCCUsePCH = Args->hasFlag(options::OPT_ccc_pch_is_pch,
335 options::OPT_ccc_pch_is_pth);
336 // FIXME: DefaultTargetTriple is used by the target-prefixed calls to as/ld
337 // and getToolChain is const.
339 // clang-cl targets Win32.
340 llvm::Triple T(DefaultTargetTriple);
341 T.setOSName(llvm::Triple::getOSTypeName(llvm::Triple::Win32));
342 DefaultTargetTriple = T.str();
344 if (const Arg *A = Args->getLastArg(options::OPT_target))
345 DefaultTargetTriple = A->getValue();
346 if (const Arg *A = Args->getLastArg(options::OPT_ccc_install_dir))
347 Dir = InstalledDir = A->getValue();
348 for (arg_iterator it = Args->filtered_begin(options::OPT_B),
349 ie = Args->filtered_end(); it != ie; ++it) {
352 PrefixDirs.push_back(A->getValue(0));
354 if (const Arg *A = Args->getLastArg(options::OPT__sysroot_EQ))
355 SysRoot = A->getValue();
356 if (const Arg *A = Args->getLastArg(options::OPT__dyld_prefix_EQ))
357 DyldPrefix = A->getValue();
358 if (Args->hasArg(options::OPT_nostdlib))
361 if (const Arg *A = Args->getLastArg(options::OPT_resource_dir))
362 ResourceDir = A->getValue();
364 // Perform the default argument translations.
365 DerivedArgList *TranslatedArgs = TranslateInputArgs(*Args);
367 // Owned by the host.
368 const ToolChain &TC = getToolChain(*Args);
370 // The compilation takes ownership of Args.
371 Compilation *C = new Compilation(*this, TC, Args, TranslatedArgs);
373 if (!HandleImmediateArgs(*C))
376 // Construct the list of inputs.
378 BuildInputs(C->getDefaultToolChain(), *TranslatedArgs, Inputs);
380 // Construct the list of abstract actions to perform for this compilation. On
381 // Darwin target OSes this uses the driver-driver and universal actions.
382 if (TC.getTriple().isOSDarwin())
383 BuildUniversalActions(C->getDefaultToolChain(), C->getArgs(),
384 Inputs, C->getActions());
386 BuildActions(C->getDefaultToolChain(), C->getArgs(), Inputs,
389 if (CCCPrintActions) {
399 // When clang crashes, produce diagnostic information including the fully
400 // preprocessed source file(s). Request that the developer attach the
401 // diagnostic information to a bug report.
402 void Driver::generateCompilationDiagnostics(Compilation &C,
403 const Command *FailingCommand) {
404 if (C.getArgs().hasArg(options::OPT_fno_crash_diagnostics))
407 // Don't try to generate diagnostics for link or dsymutil jobs.
408 if (FailingCommand && (FailingCommand->getCreator().isLinkJob() ||
409 FailingCommand->getCreator().isDsymutilJob()))
412 // Print the version of the compiler.
413 PrintVersion(C, llvm::errs());
415 Diag(clang::diag::note_drv_command_failed_diag_msg)
416 << "PLEASE submit a bug report to " BUG_REPORT_URL " and include the "
417 "crash backtrace, preprocessed source, and associated run script.";
419 // Suppress driver output and emit preprocessor output to temp file.
421 CCGenDiagnostics = true;
422 C.getArgs().AddFlagArg(0, Opts->getOption(options::OPT_frewrite_includes));
424 // Save the original job command(s).
426 llvm::raw_string_ostream OS(Cmd);
428 FailingCommand->Print(OS, "\n", /*Quote*/ false, /*CrashReport*/ true);
430 // Crash triggered by FORCE_CLANG_DIAGNOSTICS_CRASH, which doesn't have an
431 // associated FailingCommand, so just pass all jobs.
432 C.getJobs().Print(OS, "\n", /*Quote*/ false, /*CrashReport*/ true);
435 // Keep track of whether we produce any errors while trying to produce
436 // preprocessed sources.
437 DiagnosticErrorTrap Trap(Diags);
439 // Suppress tool output.
440 C.initCompilationForDiagnostics();
442 // Construct the list of inputs.
444 BuildInputs(C.getDefaultToolChain(), C.getArgs(), Inputs);
446 for (InputList::iterator it = Inputs.begin(), ie = Inputs.end(); it != ie;) {
447 bool IgnoreInput = false;
449 // Ignore input from stdin or any inputs that cannot be preprocessed.
450 if (!strcmp(it->second->getValue(), "-")) {
451 Diag(clang::diag::note_drv_command_failed_diag_msg)
452 << "Error generating preprocessed source(s) - ignoring input from stdin"
455 } else if (types::getPreprocessedType(it->first) == types::TY_INVALID) {
460 it = Inputs.erase(it);
467 if (Inputs.empty()) {
468 Diag(clang::diag::note_drv_command_failed_diag_msg)
469 << "Error generating preprocessed source(s) - no preprocessable inputs.";
473 // Don't attempt to generate preprocessed files if multiple -arch options are
474 // used, unless they're all duplicates.
475 llvm::StringSet<> ArchNames;
476 for (ArgList::const_iterator it = C.getArgs().begin(), ie = C.getArgs().end();
479 if (A->getOption().matches(options::OPT_arch)) {
480 StringRef ArchName = A->getValue();
481 ArchNames.insert(ArchName);
484 if (ArchNames.size() > 1) {
485 Diag(clang::diag::note_drv_command_failed_diag_msg)
486 << "Error generating preprocessed source(s) - cannot generate "
487 "preprocessed source with multiple -arch options.";
491 // Construct the list of abstract actions to perform for this compilation. On
492 // Darwin OSes this uses the driver-driver and builds universal actions.
493 const ToolChain &TC = C.getDefaultToolChain();
494 if (TC.getTriple().isOSDarwin())
495 BuildUniversalActions(TC, C.getArgs(), Inputs, C.getActions());
497 BuildActions(TC, C.getArgs(), Inputs, C.getActions());
501 // If there were errors building the compilation, quit now.
502 if (Trap.hasErrorOccurred()) {
503 Diag(clang::diag::note_drv_command_failed_diag_msg)
504 << "Error generating preprocessed source(s).";
508 // Generate preprocessed output.
509 SmallVector<std::pair<int, const Command *>, 4> FailingCommands;
510 C.ExecuteJob(C.getJobs(), FailingCommands);
512 // If the command succeeded, we are done.
513 if (FailingCommands.empty()) {
514 Diag(clang::diag::note_drv_command_failed_diag_msg)
515 << "\n********************\n\n"
516 "PLEASE ATTACH THE FOLLOWING FILES TO THE BUG REPORT:\n"
517 "Preprocessed source(s) and associated run script(s) are located at:";
518 ArgStringList Files = C.getTempFiles();
519 for (ArgStringList::const_iterator it = Files.begin(), ie = Files.end();
521 Diag(clang::diag::note_drv_command_failed_diag_msg) << *it;
524 std::string Script = StringRef(*it).rsplit('.').first;
526 llvm::raw_fd_ostream ScriptOS(
527 Script.c_str(), Err, llvm::sys::fs::F_Excl | llvm::sys::fs::F_Binary);
529 Diag(clang::diag::note_drv_command_failed_diag_msg)
530 << "Error generating run script: " + Script + " " + Err;
532 // Append the new filename with correct preprocessed suffix.
534 I = Cmd.find("-main-file-name ");
535 assert (I != std::string::npos && "Expected to find -main-file-name");
537 E = Cmd.find(" ", I);
538 assert (E != std::string::npos && "-main-file-name missing argument?");
539 StringRef OldFilename = StringRef(Cmd).slice(I, E);
540 StringRef NewFilename = llvm::sys::path::filename(*it);
541 I = StringRef(Cmd).rfind(OldFilename);
542 E = I + OldFilename.size();
543 I = Cmd.rfind(" ", I) + 1;
544 Cmd.replace(I, E - I, NewFilename.data(), NewFilename.size());
546 Diag(clang::diag::note_drv_command_failed_diag_msg) << Script;
549 Diag(clang::diag::note_drv_command_failed_diag_msg)
550 << "\n\n********************";
552 // Failure, remove preprocessed files.
553 if (!C.getArgs().hasArg(options::OPT_save_temps))
554 C.CleanupFileList(C.getTempFiles(), true);
556 Diag(clang::diag::note_drv_command_failed_diag_msg)
557 << "Error generating preprocessed source(s).";
561 int Driver::ExecuteCompilation(const Compilation &C,
562 SmallVectorImpl< std::pair<int, const Command *> > &FailingCommands) const {
563 // Just print if -### was present.
564 if (C.getArgs().hasArg(options::OPT__HASH_HASH_HASH)) {
565 C.getJobs().Print(llvm::errs(), "\n", true);
569 // If there were errors building the compilation, quit now.
570 if (Diags.hasErrorOccurred())
573 C.ExecuteJob(C.getJobs(), FailingCommands);
575 // Remove temp files.
576 C.CleanupFileList(C.getTempFiles());
578 // If the command succeeded, we are done.
579 if (FailingCommands.empty())
582 // Otherwise, remove result files and print extra information about abnormal
584 for (SmallVectorImpl< std::pair<int, const Command *> >::iterator it =
585 FailingCommands.begin(), ie = FailingCommands.end(); it != ie; ++it) {
587 const Command *FailingCommand = it->second;
589 // Remove result files if we're not saving temps.
590 if (!C.getArgs().hasArg(options::OPT_save_temps)) {
591 const JobAction *JA = cast<JobAction>(&FailingCommand->getSource());
592 C.CleanupFileMap(C.getResultFiles(), JA, true);
594 // Failure result files are valid unless we crashed.
596 C.CleanupFileMap(C.getFailureResultFiles(), JA, true);
599 // Print extra information about abnormal failures, if possible.
601 // This is ad-hoc, but we don't want to be excessively noisy. If the result
602 // status was 1, assume the command failed normally. In particular, if it
603 // was the compiler then assume it gave a reasonable error code. Failures
604 // in other tools are less common, and they generally have worse
605 // diagnostics, so always print the diagnostic there.
606 const Tool &FailingTool = FailingCommand->getCreator();
608 if (!FailingCommand->getCreator().hasGoodDiagnostics() || Res != 1) {
609 // FIXME: See FIXME above regarding result code interpretation.
611 Diag(clang::diag::err_drv_command_signalled)
612 << FailingTool.getShortName();
614 Diag(clang::diag::err_drv_command_failed)
615 << FailingTool.getShortName() << Res;
621 void Driver::PrintHelp(bool ShowHidden) const {
622 unsigned IncludedFlagsBitmask;
623 unsigned ExcludedFlagsBitmask;
624 llvm::tie(IncludedFlagsBitmask, ExcludedFlagsBitmask) =
625 getIncludeExcludeOptionFlagMasks();
627 ExcludedFlagsBitmask |= options::NoDriverOption;
629 ExcludedFlagsBitmask |= HelpHidden;
631 getOpts().PrintHelp(llvm::outs(), Name.c_str(), DriverTitle.c_str(),
632 IncludedFlagsBitmask, ExcludedFlagsBitmask);
635 void Driver::PrintVersion(const Compilation &C, raw_ostream &OS) const {
636 // FIXME: The following handlers should use a callback mechanism, we don't
637 // know what the client would like to do.
638 OS << getClangFullVersion() << '\n';
639 const ToolChain &TC = C.getDefaultToolChain();
640 OS << "Target: " << TC.getTripleString() << '\n';
642 // Print the threading model.
644 // FIXME: Implement correctly.
645 OS << "Thread model: " << "posix" << '\n';
648 /// PrintDiagnosticCategories - Implement the --print-diagnostic-categories
650 static void PrintDiagnosticCategories(raw_ostream &OS) {
651 // Skip the empty category.
652 for (unsigned i = 1, max = DiagnosticIDs::getNumberOfCategories();
654 OS << i << ',' << DiagnosticIDs::getCategoryNameFromID(i) << '\n';
657 bool Driver::HandleImmediateArgs(const Compilation &C) {
658 // The order these options are handled in gcc is all over the place, but we
659 // don't expect inconsistencies w.r.t. that to matter in practice.
661 if (C.getArgs().hasArg(options::OPT_dumpmachine)) {
662 llvm::outs() << C.getDefaultToolChain().getTripleString() << '\n';
666 if (C.getArgs().hasArg(options::OPT_dumpversion)) {
667 // Since -dumpversion is only implemented for pedantic GCC compatibility, we
668 // return an answer which matches our definition of __VERSION__.
670 // If we want to return a more correct answer some day, then we should
671 // introduce a non-pedantically GCC compatible mode to Clang in which we
672 // provide sensible definitions for -dumpversion, __VERSION__, etc.
673 llvm::outs() << "4.2.1\n";
677 if (C.getArgs().hasArg(options::OPT__print_diagnostic_categories)) {
678 PrintDiagnosticCategories(llvm::outs());
682 if (C.getArgs().hasArg(options::OPT_help) ||
683 C.getArgs().hasArg(options::OPT__help_hidden)) {
684 PrintHelp(C.getArgs().hasArg(options::OPT__help_hidden));
688 if (C.getArgs().hasArg(options::OPT__version)) {
689 // Follow gcc behavior and use stdout for --version and stderr for -v.
690 PrintVersion(C, llvm::outs());
694 if (C.getArgs().hasArg(options::OPT_v) ||
695 C.getArgs().hasArg(options::OPT__HASH_HASH_HASH)) {
696 PrintVersion(C, llvm::errs());
697 SuppressMissingInputWarning = true;
700 const ToolChain &TC = C.getDefaultToolChain();
702 if (C.getArgs().hasArg(options::OPT_v))
703 TC.printVerboseInfo(llvm::errs());
705 if (C.getArgs().hasArg(options::OPT_print_search_dirs)) {
706 llvm::outs() << "programs: =";
707 for (ToolChain::path_list::const_iterator it = TC.getProgramPaths().begin(),
708 ie = TC.getProgramPaths().end(); it != ie; ++it) {
709 if (it != TC.getProgramPaths().begin())
713 llvm::outs() << "\n";
714 llvm::outs() << "libraries: =" << ResourceDir;
716 StringRef sysroot = C.getSysRoot();
718 for (ToolChain::path_list::const_iterator it = TC.getFilePaths().begin(),
719 ie = TC.getFilePaths().end(); it != ie; ++it) {
721 const char *path = it->c_str();
723 llvm::outs() << sysroot << path + 1;
725 llvm::outs() << path;
727 llvm::outs() << "\n";
731 // FIXME: The following handlers should use a callback mechanism, we don't
732 // know what the client would like to do.
733 if (Arg *A = C.getArgs().getLastArg(options::OPT_print_file_name_EQ)) {
734 llvm::outs() << GetFilePath(A->getValue(), TC) << "\n";
738 if (Arg *A = C.getArgs().getLastArg(options::OPT_print_prog_name_EQ)) {
739 llvm::outs() << GetProgramPath(A->getValue(), TC) << "\n";
743 if (C.getArgs().hasArg(options::OPT_print_libgcc_file_name)) {
744 llvm::outs() << GetFilePath("libgcc.a", TC) << "\n";
748 if (C.getArgs().hasArg(options::OPT_print_multi_lib)) {
749 // FIXME: We need tool chain support for this.
750 llvm::outs() << ".;\n";
752 switch (C.getDefaultToolChain().getTriple().getArch()) {
756 case llvm::Triple::x86_64:
757 llvm::outs() << "x86_64;@m64" << "\n";
760 case llvm::Triple::ppc64:
761 llvm::outs() << "ppc64;@m64" << "\n";
764 case llvm::Triple::ppc64le:
765 llvm::outs() << "ppc64le;@m64" << "\n";
771 // FIXME: What is the difference between print-multi-directory and
772 // print-multi-os-directory?
773 if (C.getArgs().hasArg(options::OPT_print_multi_directory) ||
774 C.getArgs().hasArg(options::OPT_print_multi_os_directory)) {
775 switch (C.getDefaultToolChain().getTriple().getArch()) {
777 case llvm::Triple::x86:
778 case llvm::Triple::ppc:
779 llvm::outs() << "." << "\n";
782 case llvm::Triple::x86_64:
783 llvm::outs() << "." << "\n";
786 case llvm::Triple::ppc64:
787 llvm::outs() << "ppc64" << "\n";
790 case llvm::Triple::ppc64le:
791 llvm::outs() << "ppc64le" << "\n";
800 static unsigned PrintActions1(const Compilation &C, Action *A,
801 std::map<Action*, unsigned> &Ids) {
806 llvm::raw_string_ostream os(str);
808 os << Action::getClassName(A->getKind()) << ", ";
809 if (InputAction *IA = dyn_cast<InputAction>(A)) {
810 os << "\"" << IA->getInputArg().getValue() << "\"";
811 } else if (BindArchAction *BIA = dyn_cast<BindArchAction>(A)) {
812 os << '"' << BIA->getArchName() << '"'
813 << ", {" << PrintActions1(C, *BIA->begin(), Ids) << "}";
816 for (Action::iterator it = A->begin(), ie = A->end(); it != ie;) {
817 os << PrintActions1(C, *it, Ids);
825 unsigned Id = Ids.size();
827 llvm::errs() << Id << ": " << os.str() << ", "
828 << types::getTypeName(A->getType()) << "\n";
833 void Driver::PrintActions(const Compilation &C) const {
834 std::map<Action*, unsigned> Ids;
835 for (ActionList::const_iterator it = C.getActions().begin(),
836 ie = C.getActions().end(); it != ie; ++it)
837 PrintActions1(C, *it, Ids);
840 /// \brief Check whether the given input tree contains any compilation or
841 /// assembly actions.
842 static bool ContainsCompileOrAssembleAction(const Action *A) {
843 if (isa<CompileJobAction>(A) || isa<AssembleJobAction>(A))
846 for (Action::const_iterator it = A->begin(), ie = A->end(); it != ie; ++it)
847 if (ContainsCompileOrAssembleAction(*it))
853 void Driver::BuildUniversalActions(const ToolChain &TC,
854 DerivedArgList &Args,
855 const InputList &BAInputs,
856 ActionList &Actions) const {
857 llvm::PrettyStackTraceString CrashInfo("Building universal build actions");
858 // Collect the list of architectures. Duplicates are allowed, but should only
859 // be handled once (in the order seen).
860 llvm::StringSet<> ArchNames;
861 SmallVector<const char *, 4> Archs;
862 for (ArgList::const_iterator it = Args.begin(), ie = Args.end();
866 if (A->getOption().matches(options::OPT_arch)) {
867 // Validate the option here; we don't save the type here because its
868 // particular spelling may participate in other driver choices.
869 llvm::Triple::ArchType Arch =
870 tools::darwin::getArchTypeForDarwinArchName(A->getValue());
871 if (Arch == llvm::Triple::UnknownArch) {
872 Diag(clang::diag::err_drv_invalid_arch_name)
873 << A->getAsString(Args);
878 if (ArchNames.insert(A->getValue()))
879 Archs.push_back(A->getValue());
883 // When there is no explicit arch for this platform, make sure we still bind
884 // the architecture (to the default) so that -Xarch_ is handled correctly.
886 Archs.push_back(Args.MakeArgString(TC.getDefaultUniversalArchName()));
888 ActionList SingleActions;
889 BuildActions(TC, Args, BAInputs, SingleActions);
891 // Add in arch bindings for every top level action, as well as lipo and
892 // dsymutil steps if needed.
893 for (unsigned i = 0, e = SingleActions.size(); i != e; ++i) {
894 Action *Act = SingleActions[i];
896 // Make sure we can lipo this kind of output. If not (and it is an actual
897 // output) then we disallow, since we can't create an output file with the
898 // right name without overwriting it. We could remove this oddity by just
899 // changing the output names to include the arch, which would also fix
900 // -save-temps. Compatibility wins for now.
902 if (Archs.size() > 1 && !types::canLipoType(Act->getType()))
903 Diag(clang::diag::err_drv_invalid_output_with_multiple_archs)
904 << types::getTypeName(Act->getType());
907 for (unsigned i = 0, e = Archs.size(); i != e; ++i) {
908 Inputs.push_back(new BindArchAction(Act, Archs[i]));
910 Inputs.back()->setOwnsInputs(false);
913 // Lipo if necessary, we do it this way because we need to set the arch flag
914 // so that -Xarch_ gets overwritten.
915 if (Inputs.size() == 1 || Act->getType() == types::TY_Nothing)
916 Actions.append(Inputs.begin(), Inputs.end());
918 Actions.push_back(new LipoJobAction(Inputs, Act->getType()));
920 // Handle debug info queries.
921 Arg *A = Args.getLastArg(options::OPT_g_Group);
922 if (A && !A->getOption().matches(options::OPT_g0) &&
923 !A->getOption().matches(options::OPT_gstabs) &&
924 ContainsCompileOrAssembleAction(Actions.back())) {
926 // Add a 'dsymutil' step if necessary, when debug info is enabled and we
927 // have a compile input. We need to run 'dsymutil' ourselves in such cases
928 // because the debug info will refer to a temporary object file which
929 // will be removed at the end of the compilation process.
930 if (Act->getType() == types::TY_Image) {
932 Inputs.push_back(Actions.back());
934 Actions.push_back(new DsymutilJobAction(Inputs, types::TY_dSYM));
937 // Verify the output (debug information only) if we passed '-verify'.
938 if (Args.hasArg(options::OPT_verify)) {
939 ActionList VerifyInputs;
940 VerifyInputs.push_back(Actions.back());
942 Actions.push_back(new VerifyJobAction(VerifyInputs,
949 /// \brief Check that the file referenced by Value exists. If it doesn't,
950 /// issue a diagnostic and return false.
951 static bool DiagnoseInputExistance(const Driver &D, const DerivedArgList &Args,
953 if (!D.getCheckInputsExist())
956 // stdin always exists.
960 SmallString<64> Path(Value);
961 if (Arg *WorkDir = Args.getLastArg(options::OPT_working_directory)) {
962 if (!llvm::sys::path::is_absolute(Path.str())) {
963 SmallString<64> Directory(WorkDir->getValue());
964 llvm::sys::path::append(Directory, Value);
965 Path.assign(Directory);
969 if (llvm::sys::fs::exists(Twine(Path)))
972 D.Diag(clang::diag::err_drv_no_such_file) << Path.str();
976 // Construct a the list of inputs and their types.
977 void Driver::BuildInputs(const ToolChain &TC, const DerivedArgList &Args,
978 InputList &Inputs) const {
979 // Track the current user specified (-x) input. We also explicitly track the
980 // argument used to set the type; we only want to claim the type when we
981 // actually use it, so we warn about unused -x arguments.
982 types::ID InputType = types::TY_Nothing;
983 Arg *InputTypeArg = 0;
985 // The last /TC or /TP option sets the input type to C or C++ globally.
986 if (Arg *TCTP = Args.getLastArg(options::OPT__SLASH_TC,
987 options::OPT__SLASH_TP)) {
989 InputType = TCTP->getOption().matches(options::OPT__SLASH_TC)
990 ? types::TY_C : types::TY_CXX;
992 arg_iterator it = Args.filtered_begin(options::OPT__SLASH_TC,
993 options::OPT__SLASH_TP);
994 const arg_iterator ie = Args.filtered_end();
995 Arg *Previous = *it++;
996 bool ShowNote = false;
998 Diag(clang::diag::warn_drv_overriding_flag_option)
999 << Previous->getSpelling() << (*it)->getSpelling();
1004 Diag(clang::diag::note_drv_t_option_is_global);
1006 // No driver mode exposes -x and /TC or /TP; we don't support mixing them.
1007 assert(!Args.hasArg(options::OPT_x) && "-x and /TC or /TP is not allowed");
1010 for (ArgList::const_iterator it = Args.begin(), ie = Args.end();
1014 if (A->getOption().getKind() == Option::InputClass) {
1015 const char *Value = A->getValue();
1016 types::ID Ty = types::TY_INVALID;
1018 // Infer the input type if necessary.
1019 if (InputType == types::TY_Nothing) {
1020 // If there was an explicit arg for this, claim it.
1022 InputTypeArg->claim();
1024 // stdin must be handled specially.
1025 if (memcmp(Value, "-", 2) == 0) {
1026 // If running with -E, treat as a C input (this changes the builtin
1027 // macros, for example). This may be overridden by -ObjC below.
1029 // Otherwise emit an error but still use a valid type to avoid
1030 // spurious errors (e.g., no inputs).
1031 if (!Args.hasArgNoClaim(options::OPT_E) && !CCCIsCPP())
1032 Diag(clang::diag::err_drv_unknown_stdin_type);
1035 // Otherwise lookup by extension.
1036 // Fallback is C if invoked as C preprocessor or Object otherwise.
1037 // We use a host hook here because Darwin at least has its own
1038 // idea of what .s is.
1039 if (const char *Ext = strrchr(Value, '.'))
1040 Ty = TC.LookupTypeForExtension(Ext + 1);
1042 if (Ty == types::TY_INVALID) {
1046 Ty = types::TY_Object;
1049 // If the driver is invoked as C++ compiler (like clang++ or c++) it
1050 // should autodetect some input files as C++ for g++ compatibility.
1052 types::ID OldTy = Ty;
1053 Ty = types::lookupCXXTypeForCType(Ty);
1056 Diag(clang::diag::warn_drv_treating_input_as_cxx)
1057 << getTypeName(OldTy) << getTypeName(Ty);
1061 // -ObjC and -ObjC++ override the default language, but only for "source
1062 // files". We just treat everything that isn't a linker input as a
1065 // FIXME: Clean this up if we move the phase sequence into the type.
1066 if (Ty != types::TY_Object) {
1067 if (Args.hasArg(options::OPT_ObjC))
1068 Ty = types::TY_ObjC;
1069 else if (Args.hasArg(options::OPT_ObjCXX))
1070 Ty = types::TY_ObjCXX;
1073 assert(InputTypeArg && "InputType set w/o InputTypeArg");
1074 InputTypeArg->claim();
1078 if (DiagnoseInputExistance(*this, Args, Value))
1079 Inputs.push_back(std::make_pair(Ty, A));
1081 } else if (A->getOption().matches(options::OPT__SLASH_Tc)) {
1082 StringRef Value = A->getValue();
1083 if (DiagnoseInputExistance(*this, Args, Value)) {
1084 Arg *InputArg = MakeInputArg(Args, Opts, A->getValue());
1085 Inputs.push_back(std::make_pair(types::TY_C, InputArg));
1088 } else if (A->getOption().matches(options::OPT__SLASH_Tp)) {
1089 StringRef Value = A->getValue();
1090 if (DiagnoseInputExistance(*this, Args, Value)) {
1091 Arg *InputArg = MakeInputArg(Args, Opts, A->getValue());
1092 Inputs.push_back(std::make_pair(types::TY_CXX, InputArg));
1095 } else if (A->getOption().hasFlag(options::LinkerInput)) {
1096 // Just treat as object type, we could make a special type for this if
1098 Inputs.push_back(std::make_pair(types::TY_Object, A));
1100 } else if (A->getOption().matches(options::OPT_x)) {
1102 InputType = types::lookupTypeForTypeSpecifier(A->getValue());
1105 // Follow gcc behavior and treat as linker input for invalid -x
1106 // options. Its not clear why we shouldn't just revert to unknown; but
1107 // this isn't very important, we might as well be bug compatible.
1109 Diag(clang::diag::err_drv_unknown_language) << A->getValue();
1110 InputType = types::TY_Object;
1114 if (CCCIsCPP() && Inputs.empty()) {
1115 // If called as standalone preprocessor, stdin is processed
1116 // if no other input is present.
1117 Arg *A = MakeInputArg(Args, Opts, "-");
1118 Inputs.push_back(std::make_pair(types::TY_C, A));
1122 void Driver::BuildActions(const ToolChain &TC, DerivedArgList &Args,
1123 const InputList &Inputs, ActionList &Actions) const {
1124 llvm::PrettyStackTraceString CrashInfo("Building compilation actions");
1126 if (!SuppressMissingInputWarning && Inputs.empty()) {
1127 Diag(clang::diag::err_drv_no_input_files);
1132 phases::ID FinalPhase = getFinalPhase(Args, &FinalPhaseArg);
1134 if (FinalPhase == phases::Link && Args.hasArg(options::OPT_emit_llvm)) {
1135 Diag(clang::diag::err_drv_emit_llvm_link);
1138 // Reject -Z* at the top level, these options should never have been exposed
1140 if (Arg *A = Args.getLastArg(options::OPT_Z_Joined))
1141 Diag(clang::diag::err_drv_use_of_Z_option) << A->getAsString(Args);
1143 // Diagnose misuse of /Fo.
1144 if (Arg *A = Args.getLastArg(options::OPT__SLASH_Fo)) {
1145 StringRef V = A->getValue();
1147 // It has to have a value.
1148 Diag(clang::diag::err_drv_missing_argument) << A->getSpelling() << 1;
1149 Args.eraseArg(options::OPT__SLASH_Fo);
1150 } else if (Inputs.size() > 1 && !llvm::sys::path::is_separator(V.back())) {
1151 // Check whether /Fo tries to name an output file for multiple inputs.
1152 Diag(clang::diag::err_drv_out_file_argument_with_multiple_sources)
1153 << A->getSpelling() << V;
1154 Args.eraseArg(options::OPT__SLASH_Fo);
1158 // Diagnose misuse of /Fa.
1159 if (Arg *A = Args.getLastArg(options::OPT__SLASH_Fa)) {
1160 StringRef V = A->getValue();
1161 if (Inputs.size() > 1 && !llvm::sys::path::is_separator(V.back())) {
1162 // Check whether /Fa tries to name an asm file for multiple inputs.
1163 Diag(clang::diag::err_drv_out_file_argument_with_multiple_sources)
1164 << A->getSpelling() << V;
1165 Args.eraseArg(options::OPT__SLASH_Fa);
1169 // Diagnose misuse of /Fe.
1170 if (Arg *A = Args.getLastArg(options::OPT__SLASH_Fe)) {
1171 if (A->getValue()[0] == '\0') {
1172 // It has to have a value.
1173 Diag(clang::diag::err_drv_missing_argument) << A->getSpelling() << 1;
1174 Args.eraseArg(options::OPT__SLASH_Fe);
1178 // Construct the actions to perform.
1179 ActionList LinkerInputs;
1180 ActionList SplitInputs;
1181 llvm::SmallVector<phases::ID, phases::MaxNumberOfPhases> PL;
1182 for (unsigned i = 0, e = Inputs.size(); i != e; ++i) {
1183 types::ID InputType = Inputs[i].first;
1184 const Arg *InputArg = Inputs[i].second;
1187 types::getCompilationPhases(InputType, PL);
1189 // If the first step comes after the final phase we are doing as part of
1190 // this compilation, warn the user about it.
1191 phases::ID InitialPhase = PL[0];
1192 if (InitialPhase > FinalPhase) {
1193 // Claim here to avoid the more general unused warning.
1196 // Suppress all unused style warnings with -Qunused-arguments
1197 if (Args.hasArg(options::OPT_Qunused_arguments))
1200 // Special case when final phase determined by binary name, rather than
1201 // by a command-line argument with a corresponding Arg.
1203 Diag(clang::diag::warn_drv_input_file_unused_by_cpp)
1204 << InputArg->getAsString(Args)
1205 << getPhaseName(InitialPhase);
1206 // Special case '-E' warning on a previously preprocessed file to make
1208 else if (InitialPhase == phases::Compile &&
1209 FinalPhase == phases::Preprocess &&
1210 getPreprocessedType(InputType) == types::TY_INVALID)
1211 Diag(clang::diag::warn_drv_preprocessed_input_file_unused)
1212 << InputArg->getAsString(Args)
1214 << FinalPhaseArg ? FinalPhaseArg->getOption().getName() : "";
1216 Diag(clang::diag::warn_drv_input_file_unused)
1217 << InputArg->getAsString(Args)
1218 << getPhaseName(InitialPhase)
1220 << FinalPhaseArg ? FinalPhaseArg->getOption().getName() : "";
1224 // Build the pipeline for this file.
1225 OwningPtr<Action> Current(new InputAction(*InputArg, InputType));
1226 for (SmallVectorImpl<phases::ID>::iterator
1227 i = PL.begin(), e = PL.end(); i != e; ++i) {
1228 phases::ID Phase = *i;
1230 // We are done if this step is past what the user requested.
1231 if (Phase > FinalPhase)
1234 // Queue linker inputs.
1235 if (Phase == phases::Link) {
1236 assert((i + 1) == e && "linking must be final compilation step.");
1237 LinkerInputs.push_back(Current.take());
1241 // Some types skip the assembler phase (e.g., llvm-bc), but we can't
1242 // encode this in the steps because the intermediate type depends on
1243 // arguments. Just special case here.
1244 if (Phase == phases::Assemble && Current->getType() != types::TY_PP_Asm)
1247 // Otherwise construct the appropriate action.
1248 Current.reset(ConstructPhaseAction(Args, Phase, Current.take()));
1249 if (Current->getType() == types::TY_Nothing)
1253 // If we ended with something, add to the output list.
1255 Actions.push_back(Current.take());
1258 // Add a link action if necessary.
1259 if (!LinkerInputs.empty())
1260 Actions.push_back(new LinkJobAction(LinkerInputs, types::TY_Image));
1262 // If we are linking, claim any options which are obviously only used for
1264 if (FinalPhase == phases::Link && PL.size() == 1) {
1265 Args.ClaimAllArgs(options::OPT_CompileOnly_Group);
1266 Args.ClaimAllArgs(options::OPT_cl_compile_Group);
1269 // Claim ignored clang-cl options.
1270 Args.ClaimAllArgs(options::OPT_cl_ignored_Group);
1273 Action *Driver::ConstructPhaseAction(const ArgList &Args, phases::ID Phase,
1274 Action *Input) const {
1275 llvm::PrettyStackTraceString CrashInfo("Constructing phase actions");
1276 // Build the appropriate action.
1278 case phases::Link: llvm_unreachable("link action invalid here.");
1279 case phases::Preprocess: {
1281 // -{M, MM} alter the output type.
1282 if (Args.hasArg(options::OPT_M, options::OPT_MM)) {
1283 OutputTy = types::TY_Dependencies;
1285 OutputTy = Input->getType();
1286 if (!Args.hasFlag(options::OPT_frewrite_includes,
1287 options::OPT_fno_rewrite_includes, false))
1288 OutputTy = types::getPreprocessedType(OutputTy);
1289 assert(OutputTy != types::TY_INVALID &&
1290 "Cannot preprocess this input type!");
1292 return new PreprocessJobAction(Input, OutputTy);
1294 case phases::Precompile: {
1295 types::ID OutputTy = types::TY_PCH;
1296 if (Args.hasArg(options::OPT_fsyntax_only)) {
1297 // Syntax checks should not emit a PCH file
1298 OutputTy = types::TY_Nothing;
1300 return new PrecompileJobAction(Input, OutputTy);
1302 case phases::Compile: {
1303 if (Args.hasArg(options::OPT_fsyntax_only)) {
1304 return new CompileJobAction(Input, types::TY_Nothing);
1305 } else if (Args.hasArg(options::OPT_rewrite_objc)) {
1306 return new CompileJobAction(Input, types::TY_RewrittenObjC);
1307 } else if (Args.hasArg(options::OPT_rewrite_legacy_objc)) {
1308 return new CompileJobAction(Input, types::TY_RewrittenLegacyObjC);
1309 } else if (Args.hasArg(options::OPT__analyze, options::OPT__analyze_auto)) {
1310 return new AnalyzeJobAction(Input, types::TY_Plist);
1311 } else if (Args.hasArg(options::OPT__migrate)) {
1312 return new MigrateJobAction(Input, types::TY_Remap);
1313 } else if (Args.hasArg(options::OPT_emit_ast)) {
1314 return new CompileJobAction(Input, types::TY_AST);
1315 } else if (Args.hasArg(options::OPT_module_file_info)) {
1316 return new CompileJobAction(Input, types::TY_ModuleFile);
1317 } else if (IsUsingLTO(Args)) {
1319 Args.hasArg(options::OPT_S) ? types::TY_LTO_IR : types::TY_LTO_BC;
1320 return new CompileJobAction(Input, Output);
1321 } else if (Args.hasArg(options::OPT_emit_llvm)) {
1323 Args.hasArg(options::OPT_S) ? types::TY_LLVM_IR : types::TY_LLVM_BC;
1324 return new CompileJobAction(Input, Output);
1326 return new CompileJobAction(Input, types::TY_PP_Asm);
1329 case phases::Assemble:
1330 return new AssembleJobAction(Input, types::TY_Object);
1333 llvm_unreachable("invalid phase in ConstructPhaseAction");
1336 bool Driver::IsUsingLTO(const ArgList &Args) const {
1337 if (Args.hasFlag(options::OPT_flto, options::OPT_fno_lto, false))
1343 void Driver::BuildJobs(Compilation &C) const {
1344 llvm::PrettyStackTraceString CrashInfo("Building compilation jobs");
1346 Arg *FinalOutput = C.getArgs().getLastArg(options::OPT_o);
1348 // It is an error to provide a -o option if we are making multiple output
1351 unsigned NumOutputs = 0;
1352 for (ActionList::const_iterator it = C.getActions().begin(),
1353 ie = C.getActions().end(); it != ie; ++it)
1354 if ((*it)->getType() != types::TY_Nothing)
1357 if (NumOutputs > 1) {
1358 Diag(clang::diag::err_drv_output_argument_with_multiple_files);
1363 // Collect the list of architectures.
1364 llvm::StringSet<> ArchNames;
1365 if (C.getDefaultToolChain().getTriple().isOSDarwin()) {
1366 for (ArgList::const_iterator it = C.getArgs().begin(), ie = C.getArgs().end();
1369 if (A->getOption().matches(options::OPT_arch))
1370 ArchNames.insert(A->getValue());
1374 for (ActionList::const_iterator it = C.getActions().begin(),
1375 ie = C.getActions().end(); it != ie; ++it) {
1378 // If we are linking an image for multiple archs then the linker wants
1379 // -arch_multiple and -final_output <final image name>. Unfortunately, this
1380 // doesn't fit in cleanly because we have to pass this information down.
1382 // FIXME: This is a hack; find a cleaner way to integrate this into the
1384 const char *LinkingOutput = 0;
1385 if (isa<LipoJobAction>(A)) {
1387 LinkingOutput = FinalOutput->getValue();
1389 LinkingOutput = DefaultImageName.c_str();
1393 BuildJobsForAction(C, A, &C.getDefaultToolChain(),
1395 /*AtTopLevel*/ true,
1396 /*MultipleArchs*/ ArchNames.size() > 1,
1397 /*LinkingOutput*/ LinkingOutput,
1401 // If the user passed -Qunused-arguments or there were errors, don't warn
1402 // about any unused arguments.
1403 if (Diags.hasErrorOccurred() ||
1404 C.getArgs().hasArg(options::OPT_Qunused_arguments))
1408 (void) C.getArgs().hasArg(options::OPT__HASH_HASH_HASH);
1410 // Claim --driver-mode, it was handled earlier.
1411 (void) C.getArgs().hasArg(options::OPT_driver_mode);
1413 for (ArgList::const_iterator it = C.getArgs().begin(), ie = C.getArgs().end();
1417 // FIXME: It would be nice to be able to send the argument to the
1418 // DiagnosticsEngine, so that extra values, position, and so on could be
1420 if (!A->isClaimed()) {
1421 if (A->getOption().hasFlag(options::NoArgumentUnused))
1424 // Suppress the warning automatically if this is just a flag, and it is an
1425 // instance of an argument we already claimed.
1426 const Option &Opt = A->getOption();
1427 if (Opt.getKind() == Option::FlagClass) {
1428 bool DuplicateClaimed = false;
1430 for (arg_iterator it = C.getArgs().filtered_begin(&Opt),
1431 ie = C.getArgs().filtered_end(); it != ie; ++it) {
1432 if ((*it)->isClaimed()) {
1433 DuplicateClaimed = true;
1438 if (DuplicateClaimed)
1442 Diag(clang::diag::warn_drv_unused_argument)
1443 << A->getAsString(C.getArgs());
1448 static const Tool *SelectToolForJob(Compilation &C, const ToolChain *TC,
1449 const JobAction *JA,
1450 const ActionList *&Inputs) {
1451 const Tool *ToolForJob = 0;
1453 // See if we should look for a compiler with an integrated assembler. We match
1454 // bottom up, so what we are actually looking for is an assembler job with a
1457 if (TC->useIntegratedAs() &&
1458 !C.getArgs().hasArg(options::OPT_save_temps) &&
1459 !C.getArgs().hasArg(options::OPT__SLASH_FA) &&
1460 !C.getArgs().hasArg(options::OPT__SLASH_Fa) &&
1461 isa<AssembleJobAction>(JA) &&
1462 Inputs->size() == 1 && isa<CompileJobAction>(*Inputs->begin())) {
1463 const Tool *Compiler =
1464 TC->SelectTool(cast<JobAction>(**Inputs->begin()));
1467 if (Compiler->hasIntegratedAssembler()) {
1468 Inputs = &(*Inputs)[0]->getInputs();
1469 ToolForJob = Compiler;
1473 // Otherwise use the tool for the current job.
1475 ToolForJob = TC->SelectTool(*JA);
1477 // See if we should use an integrated preprocessor. We do so when we have
1478 // exactly one input, since this is the only use case we care about
1479 // (irrelevant since we don't support combine yet).
1480 if (Inputs->size() == 1 && isa<PreprocessJobAction>(*Inputs->begin()) &&
1481 !C.getArgs().hasArg(options::OPT_no_integrated_cpp) &&
1482 !C.getArgs().hasArg(options::OPT_traditional_cpp) &&
1483 !C.getArgs().hasArg(options::OPT_save_temps) &&
1484 !C.getArgs().hasArg(options::OPT_rewrite_objc) &&
1485 ToolForJob->hasIntegratedCPP())
1486 Inputs = &(*Inputs)[0]->getInputs();
1491 void Driver::BuildJobsForAction(Compilation &C,
1493 const ToolChain *TC,
1494 const char *BoundArch,
1497 const char *LinkingOutput,
1498 InputInfo &Result) const {
1499 llvm::PrettyStackTraceString CrashInfo("Building compilation jobs");
1501 if (const InputAction *IA = dyn_cast<InputAction>(A)) {
1502 // FIXME: It would be nice to not claim this here; maybe the old scheme of
1503 // just using Args was better?
1504 const Arg &Input = IA->getInputArg();
1506 if (Input.getOption().matches(options::OPT_INPUT)) {
1507 const char *Name = Input.getValue();
1508 Result = InputInfo(Name, A->getType(), Name);
1510 Result = InputInfo(&Input, A->getType(), "");
1514 if (const BindArchAction *BAA = dyn_cast<BindArchAction>(A)) {
1515 const ToolChain *TC;
1516 const char *ArchName = BAA->getArchName();
1519 TC = &getToolChain(C.getArgs(), ArchName);
1521 TC = &C.getDefaultToolChain();
1523 BuildJobsForAction(C, *BAA->begin(), TC, BAA->getArchName(),
1524 AtTopLevel, MultipleArchs, LinkingOutput, Result);
1528 const ActionList *Inputs = &A->getInputs();
1530 const JobAction *JA = cast<JobAction>(A);
1531 const Tool *T = SelectToolForJob(C, TC, JA, Inputs);
1535 // Only use pipes when there is exactly one input.
1536 InputInfoList InputInfos;
1537 for (ActionList::const_iterator it = Inputs->begin(), ie = Inputs->end();
1539 // Treat dsymutil and verify sub-jobs as being at the top-level too, they
1540 // shouldn't get temporary output names.
1541 // FIXME: Clean this up.
1542 bool SubJobAtTopLevel = false;
1543 if (AtTopLevel && (isa<DsymutilJobAction>(A) || isa<VerifyJobAction>(A)))
1544 SubJobAtTopLevel = true;
1547 BuildJobsForAction(C, *it, TC, BoundArch, SubJobAtTopLevel, MultipleArchs,
1549 InputInfos.push_back(II);
1552 // Always use the first input as the base input.
1553 const char *BaseInput = InputInfos[0].getBaseInput();
1555 // ... except dsymutil actions, which use their actual input as the base
1557 if (JA->getType() == types::TY_dSYM)
1558 BaseInput = InputInfos[0].getFilename();
1560 // Determine the place to write output to, if any.
1561 if (JA->getType() == types::TY_Nothing)
1562 Result = InputInfo(A->getType(), BaseInput);
1564 Result = InputInfo(GetNamedOutputPath(C, *JA, BaseInput, BoundArch,
1565 AtTopLevel, MultipleArchs),
1566 A->getType(), BaseInput);
1568 if (CCCPrintBindings && !CCGenDiagnostics) {
1569 llvm::errs() << "# \"" << T->getToolChain().getTripleString() << '"'
1570 << " - \"" << T->getName() << "\", inputs: [";
1571 for (unsigned i = 0, e = InputInfos.size(); i != e; ++i) {
1572 llvm::errs() << InputInfos[i].getAsString();
1574 llvm::errs() << ", ";
1576 llvm::errs() << "], output: " << Result.getAsString() << "\n";
1578 T->ConstructJob(C, *JA, Result, InputInfos,
1579 C.getArgsForToolChain(TC, BoundArch), LinkingOutput);
1583 /// \brief Create output filename based on ArgValue, which could either be a
1584 /// full filename, filename without extension, or a directory. If ArgValue
1585 /// does not provide a filename, then use BaseName, and use the extension
1586 /// suitable for FileType.
1587 static const char *MakeCLOutputFilename(const ArgList &Args, StringRef ArgValue,
1588 StringRef BaseName, types::ID FileType) {
1589 SmallString<128> Filename = ArgValue;
1591 if (ArgValue.empty()) {
1592 // If the argument is empty, output to BaseName in the current dir.
1593 Filename = BaseName;
1594 } else if (llvm::sys::path::is_separator(Filename.back())) {
1595 // If the argument is a directory, output to BaseName in that dir.
1596 llvm::sys::path::append(Filename, BaseName);
1599 if (!llvm::sys::path::has_extension(ArgValue)) {
1600 // If the argument didn't provide an extension, then set it.
1601 const char *Extension = types::getTypeTempSuffix(FileType, true);
1603 if (FileType == types::TY_Image &&
1604 Args.hasArg(options::OPT__SLASH_LD, options::OPT__SLASH_LDd)) {
1605 // The output file is a dll.
1609 llvm::sys::path::replace_extension(Filename, Extension);
1612 return Args.MakeArgString(Filename.c_str());
1615 const char *Driver::GetNamedOutputPath(Compilation &C,
1616 const JobAction &JA,
1617 const char *BaseInput,
1618 const char *BoundArch,
1620 bool MultipleArchs) const {
1621 llvm::PrettyStackTraceString CrashInfo("Computing output path");
1622 // Output to a user requested destination?
1623 if (AtTopLevel && !isa<DsymutilJobAction>(JA) &&
1624 !isa<VerifyJobAction>(JA)) {
1625 if (Arg *FinalOutput = C.getArgs().getLastArg(options::OPT_o))
1626 return C.addResultFile(FinalOutput->getValue(), &JA);
1629 // Default to writing to stdout?
1630 if (AtTopLevel && !CCGenDiagnostics &&
1631 (isa<PreprocessJobAction>(JA) || JA.getType() == types::TY_ModuleFile))
1634 // Is this the assembly listing for /FA?
1635 if (JA.getType() == types::TY_PP_Asm &&
1636 (C.getArgs().hasArg(options::OPT__SLASH_FA) ||
1637 C.getArgs().hasArg(options::OPT__SLASH_Fa))) {
1638 // Use /Fa and the input filename to determine the asm file name.
1639 StringRef BaseName = llvm::sys::path::filename(BaseInput);
1640 StringRef FaValue = C.getArgs().getLastArgValue(options::OPT__SLASH_Fa);
1641 return C.addResultFile(MakeCLOutputFilename(C.getArgs(), FaValue, BaseName,
1642 JA.getType()), &JA);
1645 // Output to a temporary file?
1646 if ((!AtTopLevel && !C.getArgs().hasArg(options::OPT_save_temps) &&
1647 !C.getArgs().hasArg(options::OPT__SLASH_Fo)) ||
1649 StringRef Name = llvm::sys::path::filename(BaseInput);
1650 std::pair<StringRef, StringRef> Split = Name.split('.');
1651 std::string TmpName =
1652 GetTemporaryPath(Split.first,
1653 types::getTypeTempSuffix(JA.getType(), IsCLMode()));
1654 return C.addTempFile(C.getArgs().MakeArgString(TmpName.c_str()));
1657 SmallString<128> BasePath(BaseInput);
1660 // Dsymutil actions should use the full path.
1661 if (isa<DsymutilJobAction>(JA) || isa<VerifyJobAction>(JA))
1662 BaseName = BasePath;
1664 BaseName = llvm::sys::path::filename(BasePath);
1666 // Determine what the derived output name should be.
1667 const char *NamedOutput;
1669 if (JA.getType() == types::TY_Object &&
1670 C.getArgs().hasArg(options::OPT__SLASH_Fo)) {
1671 // The /Fo flag decides the object filename.
1672 StringRef Val = C.getArgs().getLastArg(options::OPT__SLASH_Fo)->getValue();
1673 NamedOutput = MakeCLOutputFilename(C.getArgs(), Val, BaseName,
1675 } else if (JA.getType() == types::TY_Image &&
1676 C.getArgs().hasArg(options::OPT__SLASH_Fe)) {
1677 // The /Fe flag names the linked file.
1678 StringRef Val = C.getArgs().getLastArg(options::OPT__SLASH_Fe)->getValue();
1679 NamedOutput = MakeCLOutputFilename(C.getArgs(), Val, BaseName,
1681 } else if (JA.getType() == types::TY_Image) {
1683 // clang-cl uses BaseName for the executable name.
1684 NamedOutput = MakeCLOutputFilename(C.getArgs(), "", BaseName,
1686 } else if (MultipleArchs && BoundArch) {
1687 SmallString<128> Output(DefaultImageName.c_str());
1689 Output.append(BoundArch);
1690 NamedOutput = C.getArgs().MakeArgString(Output.c_str());
1692 NamedOutput = DefaultImageName.c_str();
1694 const char *Suffix = types::getTypeTempSuffix(JA.getType(), IsCLMode());
1695 assert(Suffix && "All types used for output should have a suffix.");
1697 std::string::size_type End = std::string::npos;
1698 if (!types::appendSuffixForType(JA.getType()))
1699 End = BaseName.rfind('.');
1700 SmallString<128> Suffixed(BaseName.substr(0, End));
1701 if (MultipleArchs && BoundArch) {
1703 Suffixed.append(BoundArch);
1707 NamedOutput = C.getArgs().MakeArgString(Suffixed.c_str());
1710 // If we're saving temps and the temp file conflicts with the input file,
1711 // then avoid overwriting input file.
1712 if (!AtTopLevel && C.getArgs().hasArg(options::OPT_save_temps) &&
1713 NamedOutput == BaseName) {
1715 bool SameFile = false;
1716 SmallString<256> Result;
1717 llvm::sys::fs::current_path(Result);
1718 llvm::sys::path::append(Result, BaseName);
1719 llvm::sys::fs::equivalent(BaseInput, Result.c_str(), SameFile);
1720 // Must share the same path to conflict.
1722 StringRef Name = llvm::sys::path::filename(BaseInput);
1723 std::pair<StringRef, StringRef> Split = Name.split('.');
1724 std::string TmpName =
1725 GetTemporaryPath(Split.first,
1726 types::getTypeTempSuffix(JA.getType(), IsCLMode()));
1727 return C.addTempFile(C.getArgs().MakeArgString(TmpName.c_str()));
1731 // As an annoying special case, PCH generation doesn't strip the pathname.
1732 if (JA.getType() == types::TY_PCH) {
1733 llvm::sys::path::remove_filename(BasePath);
1734 if (BasePath.empty())
1735 BasePath = NamedOutput;
1737 llvm::sys::path::append(BasePath, NamedOutput);
1738 return C.addResultFile(C.getArgs().MakeArgString(BasePath.c_str()), &JA);
1740 return C.addResultFile(NamedOutput, &JA);
1744 std::string Driver::GetFilePath(const char *Name, const ToolChain &TC) const {
1745 // Respect a limited subset of the '-Bprefix' functionality in GCC by
1746 // attempting to use this prefix when looking for file paths.
1747 for (Driver::prefix_list::const_iterator it = PrefixDirs.begin(),
1748 ie = PrefixDirs.end(); it != ie; ++it) {
1749 std::string Dir(*it);
1753 Dir = SysRoot + Dir.substr(1);
1754 SmallString<128> P(Dir);
1755 llvm::sys::path::append(P, Name);
1756 if (llvm::sys::fs::exists(Twine(P)))
1760 SmallString<128> P(ResourceDir);
1761 llvm::sys::path::append(P, Name);
1762 if (llvm::sys::fs::exists(Twine(P)))
1765 const ToolChain::path_list &List = TC.getFilePaths();
1766 for (ToolChain::path_list::const_iterator
1767 it = List.begin(), ie = List.end(); it != ie; ++it) {
1768 std::string Dir(*it);
1772 Dir = SysRoot + Dir.substr(1);
1773 SmallString<128> P(Dir);
1774 llvm::sys::path::append(P, Name);
1775 if (llvm::sys::fs::exists(Twine(P)))
1782 std::string Driver::GetProgramPath(const char *Name,
1783 const ToolChain &TC) const {
1784 // FIXME: Needs a better variable than DefaultTargetTriple
1785 std::string TargetSpecificExecutable(DefaultTargetTriple + "-" + Name);
1786 // Respect a limited subset of the '-Bprefix' functionality in GCC by
1787 // attempting to use this prefix when looking for program paths.
1788 for (Driver::prefix_list::const_iterator it = PrefixDirs.begin(),
1789 ie = PrefixDirs.end(); it != ie; ++it) {
1790 if (llvm::sys::fs::is_directory(*it)) {
1791 SmallString<128> P(*it);
1792 llvm::sys::path::append(P, TargetSpecificExecutable);
1793 if (llvm::sys::fs::can_execute(Twine(P)))
1795 llvm::sys::path::remove_filename(P);
1796 llvm::sys::path::append(P, Name);
1797 if (llvm::sys::fs::can_execute(Twine(P)))
1800 SmallString<128> P(*it + Name);
1801 if (llvm::sys::fs::can_execute(Twine(P)))
1806 const ToolChain::path_list &List = TC.getProgramPaths();
1807 for (ToolChain::path_list::const_iterator
1808 it = List.begin(), ie = List.end(); it != ie; ++it) {
1809 SmallString<128> P(*it);
1810 llvm::sys::path::append(P, TargetSpecificExecutable);
1811 if (llvm::sys::fs::can_execute(Twine(P)))
1813 llvm::sys::path::remove_filename(P);
1814 llvm::sys::path::append(P, Name);
1815 if (llvm::sys::fs::can_execute(Twine(P)))
1819 // If all else failed, search the path.
1820 std::string P(llvm::sys::FindProgramByName(TargetSpecificExecutable));
1824 P = llvm::sys::FindProgramByName(Name);
1831 std::string Driver::GetTemporaryPath(StringRef Prefix, const char *Suffix)
1833 SmallString<128> Path;
1834 llvm::error_code EC =
1835 llvm::sys::fs::createTemporaryFile(Prefix, Suffix, Path);
1837 Diag(clang::diag::err_unable_to_make_temp) << EC.message();
1844 /// \brief Compute target triple from args.
1846 /// This routine provides the logic to compute a target triple from various
1847 /// args passed to the driver and the default triple string.
1848 static llvm::Triple computeTargetTriple(StringRef DefaultTargetTriple,
1849 const ArgList &Args,
1850 StringRef DarwinArchName) {
1851 // FIXME: Already done in Compilation *Driver::BuildCompilation
1852 if (const Arg *A = Args.getLastArg(options::OPT_target))
1853 DefaultTargetTriple = A->getValue();
1855 llvm::Triple Target(llvm::Triple::normalize(DefaultTargetTriple));
1857 // Handle Darwin-specific options available here.
1858 if (Target.isOSDarwin()) {
1859 // If an explict Darwin arch name is given, that trumps all.
1860 if (!DarwinArchName.empty()) {
1862 tools::darwin::getArchTypeForDarwinArchName(DarwinArchName));
1866 // Handle the Darwin '-arch' flag.
1867 if (Arg *A = Args.getLastArg(options::OPT_arch)) {
1868 llvm::Triple::ArchType DarwinArch
1869 = tools::darwin::getArchTypeForDarwinArchName(A->getValue());
1870 if (DarwinArch != llvm::Triple::UnknownArch)
1871 Target.setArch(DarwinArch);
1875 // Handle pseudo-target flags '-EL' and '-EB'.
1876 if (Arg *A = Args.getLastArg(options::OPT_EL, options::OPT_EB)) {
1877 if (A->getOption().matches(options::OPT_EL)) {
1878 if (Target.getArch() == llvm::Triple::mips)
1879 Target.setArch(llvm::Triple::mipsel);
1880 else if (Target.getArch() == llvm::Triple::mips64)
1881 Target.setArch(llvm::Triple::mips64el);
1883 if (Target.getArch() == llvm::Triple::mipsel)
1884 Target.setArch(llvm::Triple::mips);
1885 else if (Target.getArch() == llvm::Triple::mips64el)
1886 Target.setArch(llvm::Triple::mips64);
1890 // Skip further flag support on OSes which don't support '-m32' or '-m64'.
1891 if (Target.getArchName() == "tce" ||
1892 Target.getOS() == llvm::Triple::AuroraUX ||
1893 Target.getOS() == llvm::Triple::Minix)
1896 // Handle pseudo-target flags '-m32' and '-m64'.
1897 // FIXME: Should this information be in llvm::Triple?
1898 if (Arg *A = Args.getLastArg(options::OPT_m32, options::OPT_m64)) {
1899 if (A->getOption().matches(options::OPT_m32)) {
1900 if (Target.getArch() == llvm::Triple::x86_64)
1901 Target.setArch(llvm::Triple::x86);
1902 if (Target.getArch() == llvm::Triple::ppc64)
1903 Target.setArch(llvm::Triple::ppc);
1905 if (Target.getArch() == llvm::Triple::x86)
1906 Target.setArch(llvm::Triple::x86_64);
1907 if (Target.getArch() == llvm::Triple::ppc)
1908 Target.setArch(llvm::Triple::ppc64);
1915 const ToolChain &Driver::getToolChain(const ArgList &Args,
1916 StringRef DarwinArchName) const {
1917 llvm::Triple Target = computeTargetTriple(DefaultTargetTriple, Args,
1920 ToolChain *&TC = ToolChains[Target.str()];
1922 switch (Target.getOS()) {
1923 case llvm::Triple::AuroraUX:
1924 TC = new toolchains::AuroraUX(*this, Target, Args);
1926 case llvm::Triple::Darwin:
1927 case llvm::Triple::MacOSX:
1928 case llvm::Triple::IOS:
1929 if (Target.getArch() == llvm::Triple::x86 ||
1930 Target.getArch() == llvm::Triple::x86_64 ||
1931 Target.getArch() == llvm::Triple::arm ||
1932 Target.getArch() == llvm::Triple::thumb)
1933 TC = new toolchains::DarwinClang(*this, Target, Args);
1935 TC = new toolchains::Darwin_Generic_GCC(*this, Target, Args);
1937 case llvm::Triple::DragonFly:
1938 TC = new toolchains::DragonFly(*this, Target, Args);
1940 case llvm::Triple::OpenBSD:
1941 TC = new toolchains::OpenBSD(*this, Target, Args);
1943 case llvm::Triple::Bitrig:
1944 TC = new toolchains::Bitrig(*this, Target, Args);
1946 case llvm::Triple::NetBSD:
1947 TC = new toolchains::NetBSD(*this, Target, Args);
1949 case llvm::Triple::FreeBSD:
1950 TC = new toolchains::FreeBSD(*this, Target, Args);
1952 case llvm::Triple::Minix:
1953 TC = new toolchains::Minix(*this, Target, Args);
1955 case llvm::Triple::Linux:
1956 if (Target.getArch() == llvm::Triple::hexagon)
1957 TC = new toolchains::Hexagon_TC(*this, Target, Args);
1959 TC = new toolchains::Linux(*this, Target, Args);
1961 case llvm::Triple::Solaris:
1962 TC = new toolchains::Solaris(*this, Target, Args);
1964 case llvm::Triple::Win32:
1965 TC = new toolchains::Windows(*this, Target, Args);
1967 case llvm::Triple::MinGW32:
1968 // FIXME: We need a MinGW toolchain. Fallthrough for now.
1970 // TCE is an OSless target
1971 if (Target.getArchName() == "tce") {
1972 TC = new toolchains::TCEToolChain(*this, Target, Args);
1975 // If Hexagon is configured as an OSless target
1976 if (Target.getArch() == llvm::Triple::hexagon) {
1977 TC = new toolchains::Hexagon_TC(*this, Target, Args);
1980 if (Target.getArch() == llvm::Triple::xcore) {
1981 TC = new toolchains::XCore(*this, Target, Args);
1984 TC = new toolchains::Generic_GCC(*this, Target, Args);
1991 bool Driver::ShouldUseClangCompiler(const JobAction &JA) const {
1992 // Check if user requested no clang, or clang doesn't understand this type (we
1993 // only handle single inputs for now).
1994 if (JA.size() != 1 ||
1995 !types::isAcceptedByClang((*JA.begin())->getType()))
1998 // Otherwise make sure this is an action clang understands.
1999 if (!isa<PreprocessJobAction>(JA) && !isa<PrecompileJobAction>(JA) &&
2000 !isa<CompileJobAction>(JA))
2006 /// GetReleaseVersion - Parse (([0-9]+)(.([0-9]+)(.([0-9]+)?))?)? and return the
2007 /// grouped values as integers. Numbers which are not provided are set to 0.
2009 /// \return True if the entire string was parsed (9.2), or all groups were
2010 /// parsed (10.3.5extrastuff).
2011 bool Driver::GetReleaseVersion(const char *Str, unsigned &Major,
2012 unsigned &Minor, unsigned &Micro,
2016 Major = Minor = Micro = 0;
2021 Major = (unsigned) strtol(Str, &End, 10);
2022 if (*Str != '\0' && *End == '\0')
2028 Minor = (unsigned) strtol(Str, &End, 10);
2029 if (*Str != '\0' && *End == '\0')
2035 Micro = (unsigned) strtol(Str, &End, 10);
2036 if (*Str != '\0' && *End == '\0')
2044 std::pair<unsigned, unsigned> Driver::getIncludeExcludeOptionFlagMasks() const {
2045 unsigned IncludedFlagsBitmask = 0;
2046 unsigned ExcludedFlagsBitmask = options::NoDriverOption;
2048 if (Mode == CLMode) {
2049 // Include CL and Core options.
2050 IncludedFlagsBitmask |= options::CLOption;
2051 IncludedFlagsBitmask |= options::CoreOption;
2053 ExcludedFlagsBitmask |= options::CLOption;
2056 return std::make_pair(IncludedFlagsBitmask, ExcludedFlagsBitmask);