1//===--- Driver.cpp - Clang GCC Compatible Driver -------------------------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9 10#include "clang/Driver/Driver.h" 11#include "InputInfo.h" 12#include "ToolChains.h" 13#include "clang/Basic/Version.h" 14#include "clang/Config/config.h" 15#include "clang/Driver/Action.h" 16#include "clang/Driver/Compilation.h" 17#include "clang/Driver/DriverDiagnostic.h" 18#include "clang/Driver/Job.h" 19#include "clang/Driver/Options.h" 20#include "clang/Driver/SanitizerArgs.h" 21#include "clang/Driver/Tool.h" 22#include "clang/Driver/ToolChain.h" 23#include "llvm/ADT/ArrayRef.h" 24#include "llvm/ADT/STLExtras.h" 25#include "llvm/ADT/StringExtras.h" 26#include "llvm/ADT/StringSet.h" 27#include "llvm/ADT/StringSwitch.h" 28#include "llvm/Option/Arg.h" 29#include "llvm/Option/ArgList.h" 30#include "llvm/Option/OptSpecifier.h" 31#include "llvm/Option/OptTable.h" 32#include "llvm/Option/Option.h" 33#include "llvm/Support/Debug.h" 34#include "llvm/Support/ErrorHandling.h" 35#include "llvm/Support/FileSystem.h" 36#include "llvm/Support/Path.h" 37#include "llvm/Support/PrettyStackTrace.h" 38#include "llvm/Support/Process.h" 39#include "llvm/Support/Program.h" 40#include "llvm/Support/raw_ostream.h" 41#include <map> 42#include <memory> 43 44using namespace clang::driver; 45using namespace clang; 46using namespace llvm::opt; 47 48Driver::Driver(StringRef ClangExecutable, StringRef DefaultTargetTriple, 49 DiagnosticsEngine &Diags) 50 : Opts(createDriverOptTable()), Diags(Diags), Mode(GCCMode), 51 SaveTemps(SaveTempsNone), ClangExecutable(ClangExecutable), 52 SysRoot(DEFAULT_SYSROOT), UseStdLib(true), 53 DefaultTargetTriple(DefaultTargetTriple), 54 DriverTitle("clang LLVM compiler"), CCPrintOptionsFilename(nullptr), 55 CCPrintHeadersFilename(nullptr), CCLogDiagnosticsFilename(nullptr), 56 CCCPrintBindings(false), CCPrintHeaders(false), CCLogDiagnostics(false), 57 CCGenDiagnostics(false), CCCGenericGCCName(""), CheckInputsExist(true), 58 CCCUsePCH(true), SuppressMissingInputWarning(false) { 59 60 Name = llvm::sys::path::filename(ClangExecutable); 61 Dir = llvm::sys::path::parent_path(ClangExecutable); 62 63 // Compute the path to the resource directory. 64 StringRef ClangResourceDir(CLANG_RESOURCE_DIR); 65 SmallString<128> P(Dir); 66 if (ClangResourceDir != "") { 67 llvm::sys::path::append(P, ClangResourceDir); 68 } else { 69 StringRef ClangLibdirSuffix(CLANG_LIBDIR_SUFFIX); 70 llvm::sys::path::append(P, "..", Twine("lib") + ClangLibdirSuffix, "clang", 71 CLANG_VERSION_STRING); 72 } 73 ResourceDir = P.str(); 74} 75 76Driver::~Driver() { 77 delete Opts; 78 79 llvm::DeleteContainerSeconds(ToolChains); 80} 81 82void Driver::ParseDriverMode(ArrayRef<const char *> Args) { 83 const std::string OptName = 84 getOpts().getOption(options::OPT_driver_mode).getPrefixedName(); 85 86 for (size_t I = 0, E = Args.size(); I != E; ++I) { 87 // Ingore nullptrs, they are response file's EOL markers 88 if (Args[I] == nullptr) 89 continue; 90 const StringRef Arg = Args[I]; 91 if (!Arg.startswith(OptName)) 92 continue; 93 94 const StringRef Value = Arg.drop_front(OptName.size()); 95 const unsigned M = llvm::StringSwitch<unsigned>(Value) 96 .Case("gcc", GCCMode) 97 .Case("g++", GXXMode) 98 .Case("cpp", CPPMode) 99 .Case("cl", CLMode) 100 .Default(~0U); 101 102 if (M != ~0U) 103 Mode = static_cast<DriverMode>(M); 104 else 105 Diag(diag::err_drv_unsupported_option_argument) << OptName << Value; 106 } 107} 108 109InputArgList *Driver::ParseArgStrings(ArrayRef<const char *> ArgStrings) { 110 llvm::PrettyStackTraceString CrashInfo("Command line argument parsing"); 111 112 unsigned IncludedFlagsBitmask; 113 unsigned ExcludedFlagsBitmask; 114 std::tie(IncludedFlagsBitmask, ExcludedFlagsBitmask) = 115 getIncludeExcludeOptionFlagMasks(); 116 117 unsigned MissingArgIndex, MissingArgCount; 118 InputArgList *Args = getOpts().ParseArgs(ArgStrings.begin(), ArgStrings.end(), 119 MissingArgIndex, MissingArgCount, 120 IncludedFlagsBitmask, 121 ExcludedFlagsBitmask); 122 123 // Check for missing argument error. 124 if (MissingArgCount) 125 Diag(clang::diag::err_drv_missing_argument) 126 << Args->getArgString(MissingArgIndex) << MissingArgCount; 127 128 // Check for unsupported options. 129 for (const Arg *A : *Args) { 130 if (A->getOption().hasFlag(options::Unsupported)) { 131 Diag(clang::diag::err_drv_unsupported_opt) << A->getAsString(*Args); 132 continue; 133 } 134 135 // Warn about -mcpu= without an argument. 136 if (A->getOption().matches(options::OPT_mcpu_EQ) && 137 A->containsValue("")) { 138 Diag(clang::diag::warn_drv_empty_joined_argument) << 139 A->getAsString(*Args); 140 } 141 } 142 143 for (arg_iterator it = Args->filtered_begin(options::OPT_UNKNOWN), 144 ie = Args->filtered_end(); it != ie; ++it) { 145 Diags.Report(diag::err_drv_unknown_argument) << (*it) ->getAsString(*Args); 146 } 147 148 return Args; 149} 150 151// Determine which compilation mode we are in. We look for options which 152// affect the phase, starting with the earliest phases, and record which 153// option we used to determine the final phase. 154phases::ID Driver::getFinalPhase(const DerivedArgList &DAL, Arg **FinalPhaseArg) 155const { 156 Arg *PhaseArg = nullptr; 157 phases::ID FinalPhase; 158 159 // -{E,EP,P,M,MM} only run the preprocessor. 160 if (CCCIsCPP() || 161 (PhaseArg = DAL.getLastArg(options::OPT_E)) || 162 (PhaseArg = DAL.getLastArg(options::OPT__SLASH_EP)) || 163 (PhaseArg = DAL.getLastArg(options::OPT_M, options::OPT_MM)) || 164 (PhaseArg = DAL.getLastArg(options::OPT__SLASH_P))) { 165 FinalPhase = phases::Preprocess; 166 167 // -{fsyntax-only,-analyze,emit-ast} only run up to the compiler. 168 } else if ((PhaseArg = DAL.getLastArg(options::OPT_fsyntax_only)) || 169 (PhaseArg = DAL.getLastArg(options::OPT_module_file_info)) || 170 (PhaseArg = DAL.getLastArg(options::OPT_verify_pch)) || 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 FinalPhase = phases::Compile; 178 179 // -S only runs up to the backend. 180 } else if ((PhaseArg = DAL.getLastArg(options::OPT_S))) { 181 FinalPhase = phases::Backend; 182 183 // -c only runs up to the assembler. 184 } else if ((PhaseArg = DAL.getLastArg(options::OPT_c))) { 185 FinalPhase = phases::Assemble; 186 187 // Otherwise do everything. 188 } else 189 FinalPhase = phases::Link; 190 191 if (FinalPhaseArg) 192 *FinalPhaseArg = PhaseArg; 193 194 return FinalPhase; 195} 196 197static Arg* MakeInputArg(DerivedArgList &Args, OptTable *Opts, 198 StringRef Value) { 199 Arg *A = new Arg(Opts->getOption(options::OPT_INPUT), Value, 200 Args.getBaseArgs().MakeIndex(Value), Value.data()); 201 Args.AddSynthesizedArg(A); 202 A->claim(); 203 return A; 204} 205 206DerivedArgList *Driver::TranslateInputArgs(const InputArgList &Args) const { 207 DerivedArgList *DAL = new DerivedArgList(Args); 208 209 bool HasNostdlib = Args.hasArg(options::OPT_nostdlib); 210 for (Arg *A : Args) { 211 // Unfortunately, we have to parse some forwarding options (-Xassembler, 212 // -Xlinker, -Xpreprocessor) because we either integrate their functionality 213 // (assembler and preprocessor), or bypass a previous driver ('collect2'). 214 215 // Rewrite linker options, to replace --no-demangle with a custom internal 216 // option. 217 if ((A->getOption().matches(options::OPT_Wl_COMMA) || 218 A->getOption().matches(options::OPT_Xlinker)) && 219 A->containsValue("--no-demangle")) { 220 // Add the rewritten no-demangle argument. 221 DAL->AddFlagArg(A, Opts->getOption(options::OPT_Z_Xlinker__no_demangle)); 222 223 // Add the remaining values as Xlinker arguments. 224 for (unsigned i = 0, e = A->getNumValues(); i != e; ++i) 225 if (StringRef(A->getValue(i)) != "--no-demangle") 226 DAL->AddSeparateArg(A, Opts->getOption(options::OPT_Xlinker), 227 A->getValue(i)); 228 229 continue; 230 } 231 232 // Rewrite preprocessor options, to replace -Wp,-MD,FOO which is used by 233 // some build systems. We don't try to be complete here because we don't 234 // care to encourage this usage model. 235 if (A->getOption().matches(options::OPT_Wp_COMMA) && 236 (A->getValue(0) == StringRef("-MD") || 237 A->getValue(0) == StringRef("-MMD"))) { 238 // Rewrite to -MD/-MMD along with -MF. 239 if (A->getValue(0) == StringRef("-MD")) 240 DAL->AddFlagArg(A, Opts->getOption(options::OPT_MD)); 241 else 242 DAL->AddFlagArg(A, Opts->getOption(options::OPT_MMD)); 243 if (A->getNumValues() == 2) 244 DAL->AddSeparateArg(A, Opts->getOption(options::OPT_MF), 245 A->getValue(1)); 246 continue; 247 } 248 249 // Rewrite reserved library names. 250 if (A->getOption().matches(options::OPT_l)) { 251 StringRef Value = A->getValue(); 252 253 // Rewrite unless -nostdlib is present. 254 if (!HasNostdlib && Value == "stdc++") { 255 DAL->AddFlagArg(A, Opts->getOption( 256 options::OPT_Z_reserved_lib_stdcxx)); 257 continue; 258 } 259 260 // Rewrite unconditionally. 261 if (Value == "cc_kext") { 262 DAL->AddFlagArg(A, Opts->getOption( 263 options::OPT_Z_reserved_lib_cckext)); 264 continue; 265 } 266 } 267 268 // Pick up inputs via the -- option. 269 if (A->getOption().matches(options::OPT__DASH_DASH)) { 270 A->claim(); 271 for (unsigned i = 0, e = A->getNumValues(); i != e; ++i) 272 DAL->append(MakeInputArg(*DAL, Opts, A->getValue(i))); 273 continue; 274 } 275 276 DAL->append(A); 277 } 278 279 // Add a default value of -mlinker-version=, if one was given and the user 280 // didn't specify one. 281#if defined(HOST_LINK_VERSION) 282 if (!Args.hasArg(options::OPT_mlinker_version_EQ)) { 283 DAL->AddJoinedArg(0, Opts->getOption(options::OPT_mlinker_version_EQ), 284 HOST_LINK_VERSION); 285 DAL->getLastArg(options::OPT_mlinker_version_EQ)->claim(); 286 } 287#endif 288 289 return DAL; 290} 291 292Compilation *Driver::BuildCompilation(ArrayRef<const char *> ArgList) { 293 llvm::PrettyStackTraceString CrashInfo("Compilation construction"); 294 295 // FIXME: Handle environment options which affect driver behavior, somewhere 296 // (client?). GCC_EXEC_PREFIX, LPATH, CC_PRINT_OPTIONS. 297 298 if (char *env = ::getenv("COMPILER_PATH")) { 299 StringRef CompilerPath = env; 300 while (!CompilerPath.empty()) { 301 std::pair<StringRef, StringRef> Split 302 = CompilerPath.split(llvm::sys::EnvPathSeparator); 303 PrefixDirs.push_back(Split.first); 304 CompilerPath = Split.second; 305 } 306 } 307 308 // We look for the driver mode option early, because the mode can affect 309 // how other options are parsed. 310 ParseDriverMode(ArgList.slice(1)); 311 312 // FIXME: What are we going to do with -V and -b? 313 314 // FIXME: This stuff needs to go into the Compilation, not the driver. 315 bool CCCPrintActions; 316 317 InputArgList *Args = ParseArgStrings(ArgList.slice(1)); 318 319 // -no-canonical-prefixes is used very early in main. 320 Args->ClaimAllArgs(options::OPT_no_canonical_prefixes); 321 322 // Ignore -pipe. 323 Args->ClaimAllArgs(options::OPT_pipe); 324 325 // Extract -ccc args. 326 // 327 // FIXME: We need to figure out where this behavior should live. Most of it 328 // should be outside in the client; the parts that aren't should have proper 329 // options, either by introducing new ones or by overloading gcc ones like -V 330 // or -b. 331 CCCPrintActions = Args->hasArg(options::OPT_ccc_print_phases); 332 CCCPrintBindings = Args->hasArg(options::OPT_ccc_print_bindings); 333 if (const Arg *A = Args->getLastArg(options::OPT_ccc_gcc_name)) 334 CCCGenericGCCName = A->getValue(); 335 CCCUsePCH = Args->hasFlag(options::OPT_ccc_pch_is_pch, 336 options::OPT_ccc_pch_is_pth); 337 // FIXME: DefaultTargetTriple is used by the target-prefixed calls to as/ld 338 // and getToolChain is const. 339 if (IsCLMode()) { 340 // clang-cl targets MSVC-style Win32. 341 llvm::Triple T(DefaultTargetTriple); 342 T.setOS(llvm::Triple::Win32); 343 T.setEnvironment(llvm::Triple::MSVC); 344 DefaultTargetTriple = T.str(); 345 } 346 if (const Arg *A = Args->getLastArg(options::OPT_target)) 347 DefaultTargetTriple = A->getValue(); 348 if (const Arg *A = Args->getLastArg(options::OPT_ccc_install_dir)) 349 Dir = InstalledDir = A->getValue(); 350 for (arg_iterator it = Args->filtered_begin(options::OPT_B), 351 ie = Args->filtered_end(); it != ie; ++it) { 352 const Arg *A = *it; 353 A->claim(); 354 PrefixDirs.push_back(A->getValue(0)); 355 } 356 if (const Arg *A = Args->getLastArg(options::OPT__sysroot_EQ)) 357 SysRoot = A->getValue(); 358 if (const Arg *A = Args->getLastArg(options::OPT__dyld_prefix_EQ)) 359 DyldPrefix = A->getValue(); 360 if (Args->hasArg(options::OPT_nostdlib)) 361 UseStdLib = false; 362 363 if (const Arg *A = Args->getLastArg(options::OPT_resource_dir)) 364 ResourceDir = A->getValue(); 365 366 if (const Arg *A = Args->getLastArg(options::OPT_save_temps_EQ)) { 367 SaveTemps = llvm::StringSwitch<SaveTempsMode>(A->getValue()) 368 .Case("cwd", SaveTempsCwd) 369 .Case("obj", SaveTempsObj) 370 .Default(SaveTempsCwd); 371 } 372 373 // Perform the default argument translations. 374 DerivedArgList *TranslatedArgs = TranslateInputArgs(*Args); 375 376 // Owned by the host. 377 const ToolChain &TC = getToolChain(*Args); 378 379 // The compilation takes ownership of Args. 380 Compilation *C = new Compilation(*this, TC, Args, TranslatedArgs); 381 382 if (!HandleImmediateArgs(*C)) 383 return C; 384 385 // Construct the list of inputs. 386 InputList Inputs; 387 BuildInputs(C->getDefaultToolChain(), *TranslatedArgs, Inputs); 388 389 // Construct the list of abstract actions to perform for this compilation. On 390 // MachO targets this uses the driver-driver and universal actions. 391 if (TC.getTriple().isOSBinFormatMachO()) 392 BuildUniversalActions(C->getDefaultToolChain(), C->getArgs(), 393 Inputs, C->getActions()); 394 else 395 BuildActions(C->getDefaultToolChain(), C->getArgs(), Inputs, 396 C->getActions()); 397 398 if (CCCPrintActions) { 399 PrintActions(*C); 400 return C; 401 } 402 403 BuildJobs(*C); 404 405 return C; 406} 407 408// When clang crashes, produce diagnostic information including the fully 409// preprocessed source file(s). Request that the developer attach the 410// diagnostic information to a bug report. 411void Driver::generateCompilationDiagnostics(Compilation &C, 412 const Command &FailingCommand) { 413 if (C.getArgs().hasArg(options::OPT_fno_crash_diagnostics)) 414 return; 415 416 // Don't try to generate diagnostics for link or dsymutil jobs. 417 if (FailingCommand.getCreator().isLinkJob() || 418 FailingCommand.getCreator().isDsymutilJob()) 419 return; 420 421 // Print the version of the compiler. 422 PrintVersion(C, llvm::errs()); 423 424 Diag(clang::diag::note_drv_command_failed_diag_msg) 425 << "PLEASE submit a bug report to " BUG_REPORT_URL " and include the " 426 "crash backtrace, preprocessed source, and associated run script."; 427 428 // Suppress driver output and emit preprocessor output to temp file. 429 Mode = CPPMode; 430 CCGenDiagnostics = true; 431 432 // Save the original job command(s). 433 Command Cmd = FailingCommand; 434 435 // Keep track of whether we produce any errors while trying to produce 436 // preprocessed sources. 437 DiagnosticErrorTrap Trap(Diags); 438 439 // Suppress tool output. 440 C.initCompilationForDiagnostics(); 441 442 // Construct the list of inputs. 443 InputList Inputs; 444 BuildInputs(C.getDefaultToolChain(), C.getArgs(), Inputs); 445 446 for (InputList::iterator it = Inputs.begin(), ie = Inputs.end(); it != ie;) { 447 bool IgnoreInput = false; 448 449 // Ignore input from stdin or any inputs that cannot be preprocessed. 450 // Check type first as not all linker inputs have a value. 451 if (types::getPreprocessedType(it->first) == types::TY_INVALID) { 452 IgnoreInput = true; 453 } else if (!strcmp(it->second->getValue(), "-")) { 454 Diag(clang::diag::note_drv_command_failed_diag_msg) 455 << "Error generating preprocessed source(s) - ignoring input from stdin" 456 "."; 457 IgnoreInput = true; 458 } 459 460 if (IgnoreInput) { 461 it = Inputs.erase(it); 462 ie = Inputs.end(); 463 } else { 464 ++it; 465 } 466 } 467 468 if (Inputs.empty()) { 469 Diag(clang::diag::note_drv_command_failed_diag_msg) 470 << "Error generating preprocessed source(s) - no preprocessable inputs."; 471 return; 472 } 473 474 // Don't attempt to generate preprocessed files if multiple -arch options are 475 // used, unless they're all duplicates. 476 llvm::StringSet<> ArchNames; 477 for (const Arg *A : C.getArgs()) { 478 if (A->getOption().matches(options::OPT_arch)) { 479 StringRef ArchName = A->getValue(); 480 ArchNames.insert(ArchName); 481 } 482 } 483 if (ArchNames.size() > 1) { 484 Diag(clang::diag::note_drv_command_failed_diag_msg) 485 << "Error generating preprocessed source(s) - cannot generate " 486 "preprocessed source with multiple -arch options."; 487 return; 488 } 489 490 // Construct the list of abstract actions to perform for this compilation. On 491 // Darwin OSes this uses the driver-driver and builds universal actions. 492 const ToolChain &TC = C.getDefaultToolChain(); 493 if (TC.getTriple().isOSBinFormatMachO()) 494 BuildUniversalActions(TC, C.getArgs(), Inputs, C.getActions()); 495 else 496 BuildActions(TC, C.getArgs(), Inputs, C.getActions()); 497 498 BuildJobs(C); 499 500 // If there were errors building the compilation, quit now. 501 if (Trap.hasErrorOccurred()) { 502 Diag(clang::diag::note_drv_command_failed_diag_msg) 503 << "Error generating preprocessed source(s)."; 504 return; 505 } 506 507 // Generate preprocessed output. 508 SmallVector<std::pair<int, const Command *>, 4> FailingCommands; 509 C.ExecuteJob(C.getJobs(), FailingCommands); 510 511 // If any of the preprocessing commands failed, clean up and exit. 512 if (!FailingCommands.empty()) { 513 if (!isSaveTempsEnabled()) 514 C.CleanupFileList(C.getTempFiles(), true); 515 516 Diag(clang::diag::note_drv_command_failed_diag_msg) 517 << "Error generating preprocessed source(s)."; 518 return; 519 } 520 521 const ArgStringList &TempFiles = C.getTempFiles(); 522 if (TempFiles.empty()) { 523 Diag(clang::diag::note_drv_command_failed_diag_msg) 524 << "Error generating preprocessed source(s)."; 525 return; 526 } 527 528 Diag(clang::diag::note_drv_command_failed_diag_msg) 529 << "\n********************\n\n" 530 "PLEASE ATTACH THE FOLLOWING FILES TO THE BUG REPORT:\n" 531 "Preprocessed source(s) and associated run script(s) are located at:"; 532 533 SmallString<128> VFS; 534 for (const char *TempFile : TempFiles) { 535 Diag(clang::diag::note_drv_command_failed_diag_msg) << TempFile; 536 if (StringRef(TempFile).endswith(".cache")) { 537 // In some cases (modules) we'll dump extra data to help with reproducing 538 // the crash into a directory next to the output. 539 VFS = llvm::sys::path::filename(TempFile); 540 llvm::sys::path::append(VFS, "vfs", "vfs.yaml"); 541 } 542 } 543 544 // Assume associated files are based off of the first temporary file. 545 CrashReportInfo CrashInfo(TempFiles[0], VFS); 546 547 std::string Script = CrashInfo.Filename.rsplit('.').first.str() + ".sh"; 548 std::error_code EC; 549 llvm::raw_fd_ostream ScriptOS(Script, EC, llvm::sys::fs::F_Excl); 550 if (EC) { 551 Diag(clang::diag::note_drv_command_failed_diag_msg) 552 << "Error generating run script: " + Script + " " + EC.message(); 553 } else { 554 ScriptOS << "# Crash reproducer for " << getClangFullVersion() << "\n" 555 << "# Original command: "; 556 Cmd.Print(ScriptOS, "\n", /*Quote=*/true); 557 Cmd.Print(ScriptOS, "\n", /*Quote=*/true, &CrashInfo); 558 Diag(clang::diag::note_drv_command_failed_diag_msg) << Script; 559 } 560 561 for (const auto &A : C.getArgs().filtered(options::OPT_frewrite_map_file, 562 options::OPT_frewrite_map_file_EQ)) 563 Diag(clang::diag::note_drv_command_failed_diag_msg) << A->getValue(); 564 565 Diag(clang::diag::note_drv_command_failed_diag_msg) 566 << "\n\n********************"; 567} 568 569void Driver::setUpResponseFiles(Compilation &C, Job &J) { 570 if (JobList *Jobs = dyn_cast<JobList>(&J)) { 571 for (auto &Job : *Jobs) 572 setUpResponseFiles(C, Job); 573 return; 574 } 575 576 Command *CurCommand = dyn_cast<Command>(&J); 577 if (!CurCommand) 578 return; 579 580 // Since argumentsFitWithinSystemLimits() may underestimate system's capacity 581 // if the tool does not support response files, there is a chance/ that things 582 // will just work without a response file, so we silently just skip it. 583 if (CurCommand->getCreator().getResponseFilesSupport() == Tool::RF_None || 584 llvm::sys::argumentsFitWithinSystemLimits(CurCommand->getArguments())) 585 return; 586 587 std::string TmpName = GetTemporaryPath("response", "txt"); 588 CurCommand->setResponseFile(C.addTempFile(C.getArgs().MakeArgString( 589 TmpName.c_str()))); 590} 591 592int Driver::ExecuteCompilation(Compilation &C, 593 SmallVectorImpl< std::pair<int, const Command *> > &FailingCommands) { 594 // Just print if -### was present. 595 if (C.getArgs().hasArg(options::OPT__HASH_HASH_HASH)) { 596 C.getJobs().Print(llvm::errs(), "\n", true); 597 return 0; 598 } 599 600 // If there were errors building the compilation, quit now. 601 if (Diags.hasErrorOccurred()) 602 return 1; 603 604 // Set up response file names for each command, if necessary 605 setUpResponseFiles(C, C.getJobs()); 606 607 C.ExecuteJob(C.getJobs(), FailingCommands); 608 609 // Remove temp files. 610 C.CleanupFileList(C.getTempFiles()); 611 612 // If the command succeeded, we are done. 613 if (FailingCommands.empty()) 614 return 0; 615 616 // Otherwise, remove result files and print extra information about abnormal 617 // failures. 618 for (SmallVectorImpl< std::pair<int, const Command *> >::iterator it = 619 FailingCommands.begin(), ie = FailingCommands.end(); it != ie; ++it) { 620 int Res = it->first; 621 const Command *FailingCommand = it->second; 622 623 // Remove result files if we're not saving temps. 624 if (!isSaveTempsEnabled()) { 625 const JobAction *JA = cast<JobAction>(&FailingCommand->getSource()); 626 C.CleanupFileMap(C.getResultFiles(), JA, true); 627 628 // Failure result files are valid unless we crashed. 629 if (Res < 0) 630 C.CleanupFileMap(C.getFailureResultFiles(), JA, true); 631 } 632 633 // Print extra information about abnormal failures, if possible. 634 // 635 // This is ad-hoc, but we don't want to be excessively noisy. If the result 636 // status was 1, assume the command failed normally. In particular, if it 637 // was the compiler then assume it gave a reasonable error code. Failures 638 // in other tools are less common, and they generally have worse 639 // diagnostics, so always print the diagnostic there. 640 const Tool &FailingTool = FailingCommand->getCreator(); 641 642 if (!FailingCommand->getCreator().hasGoodDiagnostics() || Res != 1) { 643 // FIXME: See FIXME above regarding result code interpretation. 644 if (Res < 0) 645 Diag(clang::diag::err_drv_command_signalled) 646 << FailingTool.getShortName(); 647 else 648 Diag(clang::diag::err_drv_command_failed) 649 << FailingTool.getShortName() << Res; 650 } 651 } 652 return 0; 653} 654 655void Driver::PrintHelp(bool ShowHidden) const { 656 unsigned IncludedFlagsBitmask; 657 unsigned ExcludedFlagsBitmask; 658 std::tie(IncludedFlagsBitmask, ExcludedFlagsBitmask) = 659 getIncludeExcludeOptionFlagMasks(); 660 661 ExcludedFlagsBitmask |= options::NoDriverOption; 662 if (!ShowHidden) 663 ExcludedFlagsBitmask |= HelpHidden; 664 665 getOpts().PrintHelp(llvm::outs(), Name.c_str(), DriverTitle.c_str(), 666 IncludedFlagsBitmask, ExcludedFlagsBitmask); 667} 668 669void Driver::PrintVersion(const Compilation &C, raw_ostream &OS) const { 670 // FIXME: The following handlers should use a callback mechanism, we don't 671 // know what the client would like to do. 672 OS << getClangFullVersion() << '\n'; 673 const ToolChain &TC = C.getDefaultToolChain(); 674 OS << "Target: " << TC.getTripleString() << '\n'; 675 676 // Print the threading model. 677 if (Arg *A = C.getArgs().getLastArg(options::OPT_mthread_model)) { 678 // Don't print if the ToolChain would have barfed on it already 679 if (TC.isThreadModelSupported(A->getValue())) 680 OS << "Thread model: " << A->getValue(); 681 } else 682 OS << "Thread model: " << TC.getThreadModel(); 683 OS << '\n'; 684} 685 686/// PrintDiagnosticCategories - Implement the --print-diagnostic-categories 687/// option. 688static void PrintDiagnosticCategories(raw_ostream &OS) { 689 // Skip the empty category. 690 for (unsigned i = 1, max = DiagnosticIDs::getNumberOfCategories(); 691 i != max; ++i) 692 OS << i << ',' << DiagnosticIDs::getCategoryNameFromID(i) << '\n'; 693} 694 695bool Driver::HandleImmediateArgs(const Compilation &C) { 696 // The order these options are handled in gcc is all over the place, but we 697 // don't expect inconsistencies w.r.t. that to matter in practice. 698 699 if (C.getArgs().hasArg(options::OPT_dumpmachine)) { 700 llvm::outs() << C.getDefaultToolChain().getTripleString() << '\n'; 701 return false; 702 } 703 704 if (C.getArgs().hasArg(options::OPT_dumpversion)) { 705 // Since -dumpversion is only implemented for pedantic GCC compatibility, we 706 // return an answer which matches our definition of __VERSION__. 707 // 708 // If we want to return a more correct answer some day, then we should 709 // introduce a non-pedantically GCC compatible mode to Clang in which we 710 // provide sensible definitions for -dumpversion, __VERSION__, etc. 711 llvm::outs() << "4.2.1\n"; 712 return false; 713 } 714 715 if (C.getArgs().hasArg(options::OPT__print_diagnostic_categories)) { 716 PrintDiagnosticCategories(llvm::outs()); 717 return false; 718 } 719 720 if (C.getArgs().hasArg(options::OPT_help) || 721 C.getArgs().hasArg(options::OPT__help_hidden)) { 722 PrintHelp(C.getArgs().hasArg(options::OPT__help_hidden)); 723 return false; 724 } 725 726 if (C.getArgs().hasArg(options::OPT__version)) { 727 // Follow gcc behavior and use stdout for --version and stderr for -v. 728 PrintVersion(C, llvm::outs()); 729 return false; 730 } 731 732 if (C.getArgs().hasArg(options::OPT_v) || 733 C.getArgs().hasArg(options::OPT__HASH_HASH_HASH)) { 734 PrintVersion(C, llvm::errs()); 735 SuppressMissingInputWarning = true; 736 } 737 738 const ToolChain &TC = C.getDefaultToolChain(); 739 740 if (C.getArgs().hasArg(options::OPT_v)) 741 TC.printVerboseInfo(llvm::errs()); 742 743 if (C.getArgs().hasArg(options::OPT_print_search_dirs)) { 744 llvm::outs() << "programs: ="; 745 for (ToolChain::path_list::const_iterator it = TC.getProgramPaths().begin(), 746 ie = TC.getProgramPaths().end(); it != ie; ++it) { 747 if (it != TC.getProgramPaths().begin()) 748 llvm::outs() << ':'; 749 llvm::outs() << *it; 750 } 751 llvm::outs() << "\n"; 752 llvm::outs() << "libraries: =" << ResourceDir; 753 754 StringRef sysroot = C.getSysRoot(); 755 756 for (ToolChain::path_list::const_iterator it = TC.getFilePaths().begin(), 757 ie = TC.getFilePaths().end(); it != ie; ++it) { 758 llvm::outs() << ':'; 759 const char *path = it->c_str(); 760 if (path[0] == '=') 761 llvm::outs() << sysroot << path + 1; 762 else 763 llvm::outs() << path; 764 } 765 llvm::outs() << "\n"; 766 return false; 767 } 768 769 // FIXME: The following handlers should use a callback mechanism, we don't 770 // know what the client would like to do. 771 if (Arg *A = C.getArgs().getLastArg(options::OPT_print_file_name_EQ)) { 772 llvm::outs() << GetFilePath(A->getValue(), TC) << "\n"; 773 return false; 774 } 775 776 if (Arg *A = C.getArgs().getLastArg(options::OPT_print_prog_name_EQ)) { 777 llvm::outs() << GetProgramPath(A->getValue(), TC) << "\n"; 778 return false; 779 } 780 781 if (C.getArgs().hasArg(options::OPT_print_libgcc_file_name)) { 782 llvm::outs() << GetFilePath("libgcc.a", TC) << "\n"; 783 return false; 784 } 785 786 if (C.getArgs().hasArg(options::OPT_print_multi_lib)) { 787 const MultilibSet &Multilibs = TC.getMultilibs(); 788 789 for (MultilibSet::const_iterator I = Multilibs.begin(), E = Multilibs.end(); 790 I != E; ++I) { 791 llvm::outs() << *I << "\n"; 792 } 793 return false; 794 } 795 796 if (C.getArgs().hasArg(options::OPT_print_multi_directory)) { 797 const MultilibSet &Multilibs = TC.getMultilibs(); 798 for (MultilibSet::const_iterator I = Multilibs.begin(), E = Multilibs.end(); 799 I != E; ++I) { 800 if (I->gccSuffix().empty()) 801 llvm::outs() << ".\n"; 802 else { 803 StringRef Suffix(I->gccSuffix()); 804 assert(Suffix.front() == '/'); 805 llvm::outs() << Suffix.substr(1) << "\n"; 806 } 807 } 808 return false; 809 } 810 811 if (C.getArgs().hasArg(options::OPT_print_multi_os_directory)) { 812 // FIXME: This should print out "lib/../lib", "lib/../lib64", or 813 // "lib/../lib32" as appropriate for the toolchain. For now, print 814 // nothing because it's not supported yet. 815 return false; 816 } 817 818 return true; 819} 820 821static unsigned PrintActions1(const Compilation &C, Action *A, 822 std::map<Action*, unsigned> &Ids) { 823 if (Ids.count(A)) 824 return Ids[A]; 825 826 std::string str; 827 llvm::raw_string_ostream os(str); 828 829 os << Action::getClassName(A->getKind()) << ", "; 830 if (InputAction *IA = dyn_cast<InputAction>(A)) { 831 os << "\"" << IA->getInputArg().getValue() << "\""; 832 } else if (BindArchAction *BIA = dyn_cast<BindArchAction>(A)) { 833 os << '"' << BIA->getArchName() << '"' 834 << ", {" << PrintActions1(C, *BIA->begin(), Ids) << "}"; 835 } else { 836 os << "{"; 837 for (Action::iterator it = A->begin(), ie = A->end(); it != ie;) { 838 os << PrintActions1(C, *it, Ids); 839 ++it; 840 if (it != ie) 841 os << ", "; 842 } 843 os << "}"; 844 } 845 846 unsigned Id = Ids.size(); 847 Ids[A] = Id; 848 llvm::errs() << Id << ": " << os.str() << ", " 849 << types::getTypeName(A->getType()) << "\n"; 850 851 return Id; 852} 853 854void Driver::PrintActions(const Compilation &C) const { 855 std::map<Action*, unsigned> Ids; 856 for (ActionList::const_iterator it = C.getActions().begin(), 857 ie = C.getActions().end(); it != ie; ++it) 858 PrintActions1(C, *it, Ids); 859} 860 861/// \brief Check whether the given input tree contains any compilation or 862/// assembly actions. 863static bool ContainsCompileOrAssembleAction(const Action *A) { 864 if (isa<CompileJobAction>(A) || 865 isa<BackendJobAction>(A) || 866 isa<AssembleJobAction>(A)) 867 return true; 868 869 for (Action::const_iterator it = A->begin(), ie = A->end(); it != ie; ++it) 870 if (ContainsCompileOrAssembleAction(*it)) 871 return true; 872 873 return false; 874} 875 876void Driver::BuildUniversalActions(const ToolChain &TC, 877 DerivedArgList &Args, 878 const InputList &BAInputs, 879 ActionList &Actions) const { 880 llvm::PrettyStackTraceString CrashInfo("Building universal build actions"); 881 // Collect the list of architectures. Duplicates are allowed, but should only 882 // be handled once (in the order seen). 883 llvm::StringSet<> ArchNames; 884 SmallVector<const char *, 4> Archs; 885 for (Arg *A : Args) { 886 if (A->getOption().matches(options::OPT_arch)) { 887 // Validate the option here; we don't save the type here because its 888 // particular spelling may participate in other driver choices. 889 llvm::Triple::ArchType Arch = 890 tools::darwin::getArchTypeForMachOArchName(A->getValue()); 891 if (Arch == llvm::Triple::UnknownArch) { 892 Diag(clang::diag::err_drv_invalid_arch_name) 893 << A->getAsString(Args); 894 continue; 895 } 896 897 A->claim(); 898 if (ArchNames.insert(A->getValue()).second) 899 Archs.push_back(A->getValue()); 900 } 901 } 902 903 // When there is no explicit arch for this platform, make sure we still bind 904 // the architecture (to the default) so that -Xarch_ is handled correctly. 905 if (!Archs.size()) 906 Archs.push_back(Args.MakeArgString(TC.getDefaultUniversalArchName())); 907 908 ActionList SingleActions; 909 BuildActions(TC, Args, BAInputs, SingleActions); 910 911 // Add in arch bindings for every top level action, as well as lipo and 912 // dsymutil steps if needed. 913 for (unsigned i = 0, e = SingleActions.size(); i != e; ++i) { 914 Action *Act = SingleActions[i]; 915 916 // Make sure we can lipo this kind of output. If not (and it is an actual 917 // output) then we disallow, since we can't create an output file with the 918 // right name without overwriting it. We could remove this oddity by just 919 // changing the output names to include the arch, which would also fix 920 // -save-temps. Compatibility wins for now. 921 922 if (Archs.size() > 1 && !types::canLipoType(Act->getType())) 923 Diag(clang::diag::err_drv_invalid_output_with_multiple_archs) 924 << types::getTypeName(Act->getType()); 925 926 ActionList Inputs; 927 for (unsigned i = 0, e = Archs.size(); i != e; ++i) { 928 Inputs.push_back( 929 new BindArchAction(std::unique_ptr<Action>(Act), Archs[i])); 930 if (i != 0) 931 Inputs.back()->setOwnsInputs(false); 932 } 933 934 // Lipo if necessary, we do it this way because we need to set the arch flag 935 // so that -Xarch_ gets overwritten. 936 if (Inputs.size() == 1 || Act->getType() == types::TY_Nothing) 937 Actions.append(Inputs.begin(), Inputs.end()); 938 else 939 Actions.push_back(new LipoJobAction(Inputs, Act->getType())); 940 941 // Handle debug info queries. 942 Arg *A = Args.getLastArg(options::OPT_g_Group); 943 if (A && !A->getOption().matches(options::OPT_g0) && 944 !A->getOption().matches(options::OPT_gstabs) && 945 ContainsCompileOrAssembleAction(Actions.back())) { 946 947 // Add a 'dsymutil' step if necessary, when debug info is enabled and we 948 // have a compile input. We need to run 'dsymutil' ourselves in such cases 949 // because the debug info will refer to a temporary object file which 950 // will be removed at the end of the compilation process. 951 if (Act->getType() == types::TY_Image) { 952 ActionList Inputs; 953 Inputs.push_back(Actions.back()); 954 Actions.pop_back(); 955 Actions.push_back(new DsymutilJobAction(Inputs, types::TY_dSYM)); 956 } 957 958 // Verify the debug info output. 959 if (Args.hasArg(options::OPT_verify_debug_info)) { 960 std::unique_ptr<Action> VerifyInput(Actions.back()); 961 Actions.pop_back(); 962 Actions.push_back(new VerifyDebugInfoJobAction(std::move(VerifyInput), 963 types::TY_Nothing)); 964 } 965 } 966 } 967} 968 969/// \brief Check that the file referenced by Value exists. If it doesn't, 970/// issue a diagnostic and return false. 971static bool DiagnoseInputExistence(const Driver &D, const DerivedArgList &Args, 972 StringRef Value) { 973 if (!D.getCheckInputsExist()) 974 return true; 975 976 // stdin always exists. 977 if (Value == "-") 978 return true; 979 980 SmallString<64> Path(Value); 981 if (Arg *WorkDir = Args.getLastArg(options::OPT_working_directory)) { 982 if (!llvm::sys::path::is_absolute(Path)) { 983 SmallString<64> Directory(WorkDir->getValue()); 984 llvm::sys::path::append(Directory, Value); 985 Path.assign(Directory); 986 } 987 } 988 989 if (llvm::sys::fs::exists(Twine(Path))) 990 return true; 991 992 if (D.IsCLMode() && llvm::sys::Process::FindInEnvPath("LIB", Value)) 993 return true; 994 995 D.Diag(clang::diag::err_drv_no_such_file) << Path; 996 return false; 997} 998 999// Construct a the list of inputs and their types. 1000void Driver::BuildInputs(const ToolChain &TC, DerivedArgList &Args, 1001 InputList &Inputs) const { 1002 // Track the current user specified (-x) input. We also explicitly track the 1003 // argument used to set the type; we only want to claim the type when we 1004 // actually use it, so we warn about unused -x arguments. 1005 types::ID InputType = types::TY_Nothing; 1006 Arg *InputTypeArg = nullptr; 1007 1008 // The last /TC or /TP option sets the input type to C or C++ globally. 1009 if (Arg *TCTP = Args.getLastArgNoClaim(options::OPT__SLASH_TC, 1010 options::OPT__SLASH_TP)) { 1011 InputTypeArg = TCTP; 1012 InputType = TCTP->getOption().matches(options::OPT__SLASH_TC) 1013 ? types::TY_C : types::TY_CXX; 1014 1015 arg_iterator it = Args.filtered_begin(options::OPT__SLASH_TC, 1016 options::OPT__SLASH_TP); 1017 const arg_iterator ie = Args.filtered_end(); 1018 Arg *Previous = *it++; 1019 bool ShowNote = false; 1020 while (it != ie) { 1021 Diag(clang::diag::warn_drv_overriding_flag_option) 1022 << Previous->getSpelling() << (*it)->getSpelling(); 1023 Previous = *it++; 1024 ShowNote = true; 1025 } 1026 if (ShowNote) 1027 Diag(clang::diag::note_drv_t_option_is_global); 1028 1029 // No driver mode exposes -x and /TC or /TP; we don't support mixing them. 1030 assert(!Args.hasArg(options::OPT_x) && "-x and /TC or /TP is not allowed"); 1031 } 1032 1033 for (Arg *A : Args) { 1034 if (A->getOption().getKind() == Option::InputClass) { 1035 const char *Value = A->getValue(); 1036 types::ID Ty = types::TY_INVALID; 1037 1038 // Infer the input type if necessary. 1039 if (InputType == types::TY_Nothing) { 1040 // If there was an explicit arg for this, claim it. 1041 if (InputTypeArg) 1042 InputTypeArg->claim(); 1043 1044 // stdin must be handled specially. 1045 if (memcmp(Value, "-", 2) == 0) { 1046 // If running with -E, treat as a C input (this changes the builtin 1047 // macros, for example). This may be overridden by -ObjC below. 1048 // 1049 // Otherwise emit an error but still use a valid type to avoid 1050 // spurious errors (e.g., no inputs). 1051 if (!Args.hasArgNoClaim(options::OPT_E) && !CCCIsCPP()) 1052 Diag(IsCLMode() ? clang::diag::err_drv_unknown_stdin_type_clang_cl 1053 : clang::diag::err_drv_unknown_stdin_type); 1054 Ty = types::TY_C; 1055 } else { 1056 // Otherwise lookup by extension. 1057 // Fallback is C if invoked as C preprocessor or Object otherwise. 1058 // We use a host hook here because Darwin at least has its own 1059 // idea of what .s is. 1060 if (const char *Ext = strrchr(Value, '.')) 1061 Ty = TC.LookupTypeForExtension(Ext + 1); 1062 1063 if (Ty == types::TY_INVALID) { 1064 if (CCCIsCPP()) 1065 Ty = types::TY_C; 1066 else 1067 Ty = types::TY_Object; 1068 } 1069 1070 // If the driver is invoked as C++ compiler (like clang++ or c++) it 1071 // should autodetect some input files as C++ for g++ compatibility. 1072 if (CCCIsCXX()) { 1073 types::ID OldTy = Ty; 1074 Ty = types::lookupCXXTypeForCType(Ty); 1075 1076 if (Ty != OldTy) 1077 Diag(clang::diag::warn_drv_treating_input_as_cxx) 1078 << getTypeName(OldTy) << getTypeName(Ty); 1079 } 1080 } 1081 1082 // -ObjC and -ObjC++ override the default language, but only for "source 1083 // files". We just treat everything that isn't a linker input as a 1084 // source file. 1085 // 1086 // FIXME: Clean this up if we move the phase sequence into the type. 1087 if (Ty != types::TY_Object) { 1088 if (Args.hasArg(options::OPT_ObjC)) 1089 Ty = types::TY_ObjC; 1090 else if (Args.hasArg(options::OPT_ObjCXX)) 1091 Ty = types::TY_ObjCXX; 1092 } 1093 } else { 1094 assert(InputTypeArg && "InputType set w/o InputTypeArg"); 1095 if (!InputTypeArg->getOption().matches(options::OPT_x)) { 1096 // If emulating cl.exe, make sure that /TC and /TP don't affect input 1097 // object files. 1098 const char *Ext = strrchr(Value, '.'); 1099 if (Ext && TC.LookupTypeForExtension(Ext + 1) == types::TY_Object) 1100 Ty = types::TY_Object; 1101 } 1102 if (Ty == types::TY_INVALID) { 1103 Ty = InputType; 1104 InputTypeArg->claim(); 1105 } 1106 } 1107 1108 if (DiagnoseInputExistence(*this, Args, Value)) 1109 Inputs.push_back(std::make_pair(Ty, A)); 1110 1111 } else if (A->getOption().matches(options::OPT__SLASH_Tc)) { 1112 StringRef Value = A->getValue(); 1113 if (DiagnoseInputExistence(*this, Args, Value)) { 1114 Arg *InputArg = MakeInputArg(Args, Opts, A->getValue()); 1115 Inputs.push_back(std::make_pair(types::TY_C, InputArg)); 1116 } 1117 A->claim(); 1118 } else if (A->getOption().matches(options::OPT__SLASH_Tp)) { 1119 StringRef Value = A->getValue(); 1120 if (DiagnoseInputExistence(*this, Args, Value)) { 1121 Arg *InputArg = MakeInputArg(Args, Opts, A->getValue()); 1122 Inputs.push_back(std::make_pair(types::TY_CXX, InputArg)); 1123 } 1124 A->claim(); 1125 } else if (A->getOption().hasFlag(options::LinkerInput)) { 1126 // Just treat as object type, we could make a special type for this if 1127 // necessary. 1128 Inputs.push_back(std::make_pair(types::TY_Object, A)); 1129 1130 } else if (A->getOption().matches(options::OPT_x)) { 1131 InputTypeArg = A; 1132 InputType = types::lookupTypeForTypeSpecifier(A->getValue()); 1133 A->claim(); 1134 1135 // Follow gcc behavior and treat as linker input for invalid -x 1136 // options. Its not clear why we shouldn't just revert to unknown; but 1137 // this isn't very important, we might as well be bug compatible. 1138 if (!InputType) { 1139 Diag(clang::diag::err_drv_unknown_language) << A->getValue(); 1140 InputType = types::TY_Object; 1141 } 1142 } 1143 } 1144 if (CCCIsCPP() && Inputs.empty()) { 1145 // If called as standalone preprocessor, stdin is processed 1146 // if no other input is present. 1147 Arg *A = MakeInputArg(Args, Opts, "-"); 1148 Inputs.push_back(std::make_pair(types::TY_C, A)); 1149 } 1150} 1151 1152void Driver::BuildActions(const ToolChain &TC, DerivedArgList &Args, 1153 const InputList &Inputs, ActionList &Actions) const { 1154 llvm::PrettyStackTraceString CrashInfo("Building compilation actions"); 1155 1156 if (!SuppressMissingInputWarning && Inputs.empty()) { 1157 Diag(clang::diag::err_drv_no_input_files); 1158 return; 1159 } 1160 1161 Arg *FinalPhaseArg; 1162 phases::ID FinalPhase = getFinalPhase(Args, &FinalPhaseArg); 1163 1164 if (FinalPhase == phases::Link && Args.hasArg(options::OPT_emit_llvm)) { 1165 Diag(clang::diag::err_drv_emit_llvm_link); 1166 } 1167 1168 // Reject -Z* at the top level, these options should never have been exposed 1169 // by gcc. 1170 if (Arg *A = Args.getLastArg(options::OPT_Z_Joined)) 1171 Diag(clang::diag::err_drv_use_of_Z_option) << A->getAsString(Args); 1172 1173 // Diagnose misuse of /Fo. 1174 if (Arg *A = Args.getLastArg(options::OPT__SLASH_Fo)) { 1175 StringRef V = A->getValue(); 1176 if (Inputs.size() > 1 && !V.empty() && 1177 !llvm::sys::path::is_separator(V.back())) { 1178 // Check whether /Fo tries to name an output file for multiple inputs. 1179 Diag(clang::diag::err_drv_out_file_argument_with_multiple_sources) 1180 << A->getSpelling() << V; 1181 Args.eraseArg(options::OPT__SLASH_Fo); 1182 } 1183 } 1184 1185 // Diagnose misuse of /Fa. 1186 if (Arg *A = Args.getLastArg(options::OPT__SLASH_Fa)) { 1187 StringRef V = A->getValue(); 1188 if (Inputs.size() > 1 && !V.empty() && 1189 !llvm::sys::path::is_separator(V.back())) { 1190 // Check whether /Fa tries to name an asm file for multiple inputs. 1191 Diag(clang::diag::err_drv_out_file_argument_with_multiple_sources) 1192 << A->getSpelling() << V; 1193 Args.eraseArg(options::OPT__SLASH_Fa); 1194 } 1195 } 1196 1197 // Diagnose misuse of /o. 1198 if (Arg *A = Args.getLastArg(options::OPT__SLASH_o)) { 1199 if (A->getValue()[0] == '\0') { 1200 // It has to have a value. 1201 Diag(clang::diag::err_drv_missing_argument) << A->getSpelling() << 1; 1202 Args.eraseArg(options::OPT__SLASH_o); 1203 } 1204 } 1205 1206 // Construct the actions to perform. 1207 ActionList LinkerInputs; 1208 1209 llvm::SmallVector<phases::ID, phases::MaxNumberOfPhases> PL; 1210 for (unsigned i = 0, e = Inputs.size(); i != e; ++i) { 1211 types::ID InputType = Inputs[i].first; 1212 const Arg *InputArg = Inputs[i].second; 1213 1214 PL.clear(); 1215 types::getCompilationPhases(InputType, PL); 1216 1217 // If the first step comes after the final phase we are doing as part of 1218 // this compilation, warn the user about it. 1219 phases::ID InitialPhase = PL[0]; 1220 if (InitialPhase > FinalPhase) { 1221 // Claim here to avoid the more general unused warning. 1222 InputArg->claim(); 1223 1224 // Suppress all unused style warnings with -Qunused-arguments 1225 if (Args.hasArg(options::OPT_Qunused_arguments)) 1226 continue; 1227 1228 // Special case when final phase determined by binary name, rather than 1229 // by a command-line argument with a corresponding Arg. 1230 if (CCCIsCPP()) 1231 Diag(clang::diag::warn_drv_input_file_unused_by_cpp) 1232 << InputArg->getAsString(Args) 1233 << getPhaseName(InitialPhase); 1234 // Special case '-E' warning on a previously preprocessed file to make 1235 // more sense. 1236 else if (InitialPhase == phases::Compile && 1237 FinalPhase == phases::Preprocess && 1238 getPreprocessedType(InputType) == types::TY_INVALID) 1239 Diag(clang::diag::warn_drv_preprocessed_input_file_unused) 1240 << InputArg->getAsString(Args) 1241 << !!FinalPhaseArg 1242 << (FinalPhaseArg ? FinalPhaseArg->getOption().getName() : ""); 1243 else 1244 Diag(clang::diag::warn_drv_input_file_unused) 1245 << InputArg->getAsString(Args) 1246 << getPhaseName(InitialPhase) 1247 << !!FinalPhaseArg 1248 << (FinalPhaseArg ? FinalPhaseArg->getOption().getName() : ""); 1249 continue; 1250 } 1251 1252 // Build the pipeline for this file. 1253 std::unique_ptr<Action> Current(new InputAction(*InputArg, InputType)); 1254 for (SmallVectorImpl<phases::ID>::iterator 1255 i = PL.begin(), e = PL.end(); i != e; ++i) { 1256 phases::ID Phase = *i; 1257 1258 // We are done if this step is past what the user requested. 1259 if (Phase > FinalPhase) 1260 break; 1261 1262 // Queue linker inputs. 1263 if (Phase == phases::Link) { 1264 assert((i + 1) == e && "linking must be final compilation step."); 1265 LinkerInputs.push_back(Current.release()); 1266 break; 1267 } 1268 1269 // Some types skip the assembler phase (e.g., llvm-bc), but we can't 1270 // encode this in the steps because the intermediate type depends on 1271 // arguments. Just special case here. 1272 if (Phase == phases::Assemble && Current->getType() != types::TY_PP_Asm) 1273 continue; 1274 1275 // Otherwise construct the appropriate action. 1276 Current = ConstructPhaseAction(TC, Args, Phase, std::move(Current)); 1277 if (Current->getType() == types::TY_Nothing) 1278 break; 1279 } 1280 1281 // If we ended with something, add to the output list. 1282 if (Current) 1283 Actions.push_back(Current.release()); 1284 } 1285 1286 // Add a link action if necessary. 1287 if (!LinkerInputs.empty()) 1288 Actions.push_back(new LinkJobAction(LinkerInputs, types::TY_Image)); 1289 1290 // If we are linking, claim any options which are obviously only used for 1291 // compilation. 1292 if (FinalPhase == phases::Link && PL.size() == 1) { 1293 Args.ClaimAllArgs(options::OPT_CompileOnly_Group); 1294 Args.ClaimAllArgs(options::OPT_cl_compile_Group); 1295 } 1296 1297 // Claim ignored clang-cl options. 1298 Args.ClaimAllArgs(options::OPT_cl_ignored_Group); 1299} 1300 1301std::unique_ptr<Action> 1302Driver::ConstructPhaseAction(const ToolChain &TC, const ArgList &Args, 1303 phases::ID Phase, 1304 std::unique_ptr<Action> Input) const { 1305 llvm::PrettyStackTraceString CrashInfo("Constructing phase actions"); 1306 // Build the appropriate action. 1307 switch (Phase) { 1308 case phases::Link: llvm_unreachable("link action invalid here."); 1309 case phases::Preprocess: { 1310 types::ID OutputTy; 1311 // -{M, MM} alter the output type. 1312 if (Args.hasArg(options::OPT_M, options::OPT_MM)) { 1313 OutputTy = types::TY_Dependencies; 1314 } else { 1315 OutputTy = Input->getType(); 1316 if (!Args.hasFlag(options::OPT_frewrite_includes, 1317 options::OPT_fno_rewrite_includes, false) && 1318 !CCGenDiagnostics) 1319 OutputTy = types::getPreprocessedType(OutputTy); 1320 assert(OutputTy != types::TY_INVALID && 1321 "Cannot preprocess this input type!"); 1322 } 1323 return llvm::make_unique<PreprocessJobAction>(std::move(Input), OutputTy); 1324 } 1325 case phases::Precompile: { 1326 types::ID OutputTy = types::TY_PCH; 1327 if (Args.hasArg(options::OPT_fsyntax_only)) { 1328 // Syntax checks should not emit a PCH file 1329 OutputTy = types::TY_Nothing; 1330 } 1331 return llvm::make_unique<PrecompileJobAction>(std::move(Input), OutputTy); 1332 } 1333 case phases::Compile: { 1334 if (Args.hasArg(options::OPT_fsyntax_only)) 1335 return llvm::make_unique<CompileJobAction>(std::move(Input), 1336 types::TY_Nothing); 1337 if (Args.hasArg(options::OPT_rewrite_objc)) 1338 return llvm::make_unique<CompileJobAction>(std::move(Input), 1339 types::TY_RewrittenObjC); 1340 if (Args.hasArg(options::OPT_rewrite_legacy_objc)) 1341 return llvm::make_unique<CompileJobAction>(std::move(Input), 1342 types::TY_RewrittenLegacyObjC); 1343 if (Args.hasArg(options::OPT__analyze, options::OPT__analyze_auto)) 1344 return llvm::make_unique<AnalyzeJobAction>(std::move(Input), 1345 types::TY_Plist); 1346 if (Args.hasArg(options::OPT__migrate)) 1347 return llvm::make_unique<MigrateJobAction>(std::move(Input), 1348 types::TY_Remap); 1349 if (Args.hasArg(options::OPT_emit_ast)) 1350 return llvm::make_unique<CompileJobAction>(std::move(Input), 1351 types::TY_AST); 1352 if (Args.hasArg(options::OPT_module_file_info)) 1353 return llvm::make_unique<CompileJobAction>(std::move(Input), 1354 types::TY_ModuleFile); 1355 if (Args.hasArg(options::OPT_verify_pch)) 1356 return llvm::make_unique<VerifyPCHJobAction>(std::move(Input), 1357 types::TY_Nothing); 1358 return llvm::make_unique<CompileJobAction>(std::move(Input), 1359 types::TY_LLVM_BC); 1360 } 1361 case phases::Backend: { 1362 if (IsUsingLTO(TC, Args)) { 1363 types::ID Output = 1364 Args.hasArg(options::OPT_S) ? types::TY_LTO_IR : types::TY_LTO_BC; 1365 return llvm::make_unique<BackendJobAction>(std::move(Input), Output); 1366 } 1367 if (Args.hasArg(options::OPT_emit_llvm)) { 1368 types::ID Output = 1369 Args.hasArg(options::OPT_S) ? types::TY_LLVM_IR : types::TY_LLVM_BC; 1370 return llvm::make_unique<BackendJobAction>(std::move(Input), Output); 1371 } 1372 return llvm::make_unique<BackendJobAction>(std::move(Input), 1373 types::TY_PP_Asm); 1374 } 1375 case phases::Assemble: 1376 return llvm::make_unique<AssembleJobAction>(std::move(Input), 1377 types::TY_Object); 1378 } 1379 1380 llvm_unreachable("invalid phase in ConstructPhaseAction"); 1381} 1382 1383bool Driver::IsUsingLTO(const ToolChain &TC, const ArgList &Args) const { 1384 if (TC.getSanitizerArgs().needsLTO()) 1385 return true; 1386 1387 if (Args.hasFlag(options::OPT_flto, options::OPT_fno_lto, false)) 1388 return true; 1389 1390 return false; 1391} 1392 1393void Driver::BuildJobs(Compilation &C) const { 1394 llvm::PrettyStackTraceString CrashInfo("Building compilation jobs"); 1395 1396 Arg *FinalOutput = C.getArgs().getLastArg(options::OPT_o); 1397 1398 // It is an error to provide a -o option if we are making multiple output 1399 // files. 1400 if (FinalOutput) { 1401 unsigned NumOutputs = 0; 1402 for (const Action *A : C.getActions()) 1403 if (A->getType() != types::TY_Nothing) 1404 ++NumOutputs; 1405 1406 if (NumOutputs > 1) { 1407 Diag(clang::diag::err_drv_output_argument_with_multiple_files); 1408 FinalOutput = nullptr; 1409 } 1410 } 1411 1412 // Collect the list of architectures. 1413 llvm::StringSet<> ArchNames; 1414 if (C.getDefaultToolChain().getTriple().isOSBinFormatMachO()) 1415 for (const Arg *A : C.getArgs()) 1416 if (A->getOption().matches(options::OPT_arch)) 1417 ArchNames.insert(A->getValue()); 1418 1419 for (Action *A : C.getActions()) { 1420 // If we are linking an image for multiple archs then the linker wants 1421 // -arch_multiple and -final_output <final image name>. Unfortunately, this 1422 // doesn't fit in cleanly because we have to pass this information down. 1423 // 1424 // FIXME: This is a hack; find a cleaner way to integrate this into the 1425 // process. 1426 const char *LinkingOutput = nullptr; 1427 if (isa<LipoJobAction>(A)) { 1428 if (FinalOutput) 1429 LinkingOutput = FinalOutput->getValue(); 1430 else 1431 LinkingOutput = getDefaultImageName(); 1432 } 1433 1434 InputInfo II; 1435 BuildJobsForAction(C, A, &C.getDefaultToolChain(), 1436 /*BoundArch*/nullptr, 1437 /*AtTopLevel*/ true, 1438 /*MultipleArchs*/ ArchNames.size() > 1, 1439 /*LinkingOutput*/ LinkingOutput, 1440 II); 1441 } 1442 1443 // If the user passed -Qunused-arguments or there were errors, don't warn 1444 // about any unused arguments. 1445 if (Diags.hasErrorOccurred() || 1446 C.getArgs().hasArg(options::OPT_Qunused_arguments)) 1447 return; 1448 1449 // Claim -### here. 1450 (void) C.getArgs().hasArg(options::OPT__HASH_HASH_HASH); 1451 1452 // Claim --driver-mode, it was handled earlier. 1453 (void) C.getArgs().hasArg(options::OPT_driver_mode); 1454 1455 for (Arg *A : C.getArgs()) { 1456 // FIXME: It would be nice to be able to send the argument to the 1457 // DiagnosticsEngine, so that extra values, position, and so on could be 1458 // printed. 1459 if (!A->isClaimed()) { 1460 if (A->getOption().hasFlag(options::NoArgumentUnused)) 1461 continue; 1462 1463 // Suppress the warning automatically if this is just a flag, and it is an 1464 // instance of an argument we already claimed. 1465 const Option &Opt = A->getOption(); 1466 if (Opt.getKind() == Option::FlagClass) { 1467 bool DuplicateClaimed = false; 1468 1469 for (arg_iterator it = C.getArgs().filtered_begin(&Opt), 1470 ie = C.getArgs().filtered_end(); it != ie; ++it) { 1471 if ((*it)->isClaimed()) { 1472 DuplicateClaimed = true; 1473 break; 1474 } 1475 } 1476 1477 if (DuplicateClaimed) 1478 continue; 1479 } 1480 1481 Diag(clang::diag::warn_drv_unused_argument) 1482 << A->getAsString(C.getArgs()); 1483 } 1484 } 1485} 1486 1487static const Tool *SelectToolForJob(Compilation &C, bool SaveTemps, 1488 const ToolChain *TC, const JobAction *JA, 1489 const ActionList *&Inputs) { 1490 const Tool *ToolForJob = nullptr; 1491 1492 // See if we should look for a compiler with an integrated assembler. We match 1493 // bottom up, so what we are actually looking for is an assembler job with a 1494 // compiler input. 1495 1496 if (TC->useIntegratedAs() && 1497 !SaveTemps && 1498 !C.getArgs().hasArg(options::OPT_via_file_asm) && 1499 !C.getArgs().hasArg(options::OPT__SLASH_FA) && 1500 !C.getArgs().hasArg(options::OPT__SLASH_Fa) && 1501 isa<AssembleJobAction>(JA) && 1502 Inputs->size() == 1 && isa<BackendJobAction>(*Inputs->begin())) { 1503 // A BackendJob is always preceded by a CompileJob, and without 1504 // -save-temps they will always get combined together, so instead of 1505 // checking the backend tool, check if the tool for the CompileJob 1506 // has an integrated assembler. 1507 const ActionList *BackendInputs = &(*Inputs)[0]->getInputs(); 1508 JobAction *CompileJA = cast<CompileJobAction>(*BackendInputs->begin()); 1509 const Tool *Compiler = TC->SelectTool(*CompileJA); 1510 if (!Compiler) 1511 return nullptr; 1512 if (Compiler->hasIntegratedAssembler()) { 1513 Inputs = &(*BackendInputs)[0]->getInputs(); 1514 ToolForJob = Compiler; 1515 } 1516 } 1517 1518 // A backend job should always be combined with the preceding compile job 1519 // unless OPT_save_temps is enabled and the compiler is capable of emitting 1520 // LLVM IR as an intermediate output. 1521 if (isa<BackendJobAction>(JA)) { 1522 // Check if the compiler supports emitting LLVM IR. 1523 assert(Inputs->size() == 1); 1524 JobAction *CompileJA = cast<CompileJobAction>(*Inputs->begin()); 1525 const Tool *Compiler = TC->SelectTool(*CompileJA); 1526 if (!Compiler) 1527 return nullptr; 1528 if (!Compiler->canEmitIR() || !SaveTemps) { 1529 Inputs = &(*Inputs)[0]->getInputs(); 1530 ToolForJob = Compiler; 1531 } 1532 } 1533 1534 // Otherwise use the tool for the current job. 1535 if (!ToolForJob) 1536 ToolForJob = TC->SelectTool(*JA); 1537 1538 // See if we should use an integrated preprocessor. We do so when we have 1539 // exactly one input, since this is the only use case we care about 1540 // (irrelevant since we don't support combine yet). 1541 if (Inputs->size() == 1 && isa<PreprocessJobAction>(*Inputs->begin()) && 1542 !C.getArgs().hasArg(options::OPT_no_integrated_cpp) && 1543 !C.getArgs().hasArg(options::OPT_traditional_cpp) && 1544 !SaveTemps && 1545 !C.getArgs().hasArg(options::OPT_rewrite_objc) && 1546 ToolForJob->hasIntegratedCPP()) 1547 Inputs = &(*Inputs)[0]->getInputs(); 1548 1549 return ToolForJob; 1550} 1551 1552void Driver::BuildJobsForAction(Compilation &C, 1553 const Action *A, 1554 const ToolChain *TC, 1555 const char *BoundArch, 1556 bool AtTopLevel, 1557 bool MultipleArchs, 1558 const char *LinkingOutput, 1559 InputInfo &Result) const { 1560 llvm::PrettyStackTraceString CrashInfo("Building compilation jobs"); 1561 1562 if (const InputAction *IA = dyn_cast<InputAction>(A)) { 1563 // FIXME: It would be nice to not claim this here; maybe the old scheme of 1564 // just using Args was better? 1565 const Arg &Input = IA->getInputArg(); 1566 Input.claim(); 1567 if (Input.getOption().matches(options::OPT_INPUT)) { 1568 const char *Name = Input.getValue(); 1569 Result = InputInfo(Name, A->getType(), Name); 1570 } else 1571 Result = InputInfo(&Input, A->getType(), ""); 1572 return; 1573 } 1574 1575 if (const BindArchAction *BAA = dyn_cast<BindArchAction>(A)) { 1576 const ToolChain *TC; 1577 const char *ArchName = BAA->getArchName(); 1578 1579 if (ArchName) 1580 TC = &getToolChain(C.getArgs(), ArchName); 1581 else 1582 TC = &C.getDefaultToolChain(); 1583 1584 BuildJobsForAction(C, *BAA->begin(), TC, BAA->getArchName(), 1585 AtTopLevel, MultipleArchs, LinkingOutput, Result); 1586 return; 1587 } 1588 1589 const ActionList *Inputs = &A->getInputs(); 1590 1591 const JobAction *JA = cast<JobAction>(A); 1592 const Tool *T = SelectToolForJob(C, isSaveTempsEnabled(), TC, JA, Inputs); 1593 if (!T) 1594 return; 1595 1596 // Only use pipes when there is exactly one input. 1597 InputInfoList InputInfos; 1598 for (const Action *Input : *Inputs) { 1599 // Treat dsymutil and verify sub-jobs as being at the top-level too, they 1600 // shouldn't get temporary output names. 1601 // FIXME: Clean this up. 1602 bool SubJobAtTopLevel = false; 1603 if (AtTopLevel && (isa<DsymutilJobAction>(A) || isa<VerifyJobAction>(A))) 1604 SubJobAtTopLevel = true; 1605 1606 InputInfo II; 1607 BuildJobsForAction(C, Input, TC, BoundArch, SubJobAtTopLevel, MultipleArchs, 1608 LinkingOutput, II); 1609 InputInfos.push_back(II); 1610 } 1611 1612 // Always use the first input as the base input. 1613 const char *BaseInput = InputInfos[0].getBaseInput(); 1614 1615 // ... except dsymutil actions, which use their actual input as the base 1616 // input. 1617 if (JA->getType() == types::TY_dSYM) 1618 BaseInput = InputInfos[0].getFilename(); 1619 1620 // Determine the place to write output to, if any. 1621 if (JA->getType() == types::TY_Nothing) 1622 Result = InputInfo(A->getType(), BaseInput); 1623 else 1624 Result = InputInfo(GetNamedOutputPath(C, *JA, BaseInput, BoundArch, 1625 AtTopLevel, MultipleArchs), 1626 A->getType(), BaseInput); 1627 1628 if (CCCPrintBindings && !CCGenDiagnostics) { 1629 llvm::errs() << "# \"" << T->getToolChain().getTripleString() << '"' 1630 << " - \"" << T->getName() << "\", inputs: ["; 1631 for (unsigned i = 0, e = InputInfos.size(); i != e; ++i) { 1632 llvm::errs() << InputInfos[i].getAsString(); 1633 if (i + 1 != e) 1634 llvm::errs() << ", "; 1635 } 1636 llvm::errs() << "], output: " << Result.getAsString() << "\n"; 1637 } else { 1638 T->ConstructJob(C, *JA, Result, InputInfos, 1639 C.getArgsForToolChain(TC, BoundArch), LinkingOutput); 1640 } 1641} 1642 1643const char *Driver::getDefaultImageName() const { 1644 llvm::Triple Target(llvm::Triple::normalize(DefaultTargetTriple)); 1645 return Target.isOSWindows() ? "a.exe" : "a.out"; 1646} 1647 1648/// \brief Create output filename based on ArgValue, which could either be a 1649/// full filename, filename without extension, or a directory. If ArgValue 1650/// does not provide a filename, then use BaseName, and use the extension 1651/// suitable for FileType. 1652static const char *MakeCLOutputFilename(const ArgList &Args, StringRef ArgValue, 1653 StringRef BaseName, types::ID FileType) { 1654 SmallString<128> Filename = ArgValue; 1655 1656 if (ArgValue.empty()) { 1657 // If the argument is empty, output to BaseName in the current dir. 1658 Filename = BaseName; 1659 } else if (llvm::sys::path::is_separator(Filename.back())) { 1660 // If the argument is a directory, output to BaseName in that dir. 1661 llvm::sys::path::append(Filename, BaseName); 1662 } 1663 1664 if (!llvm::sys::path::has_extension(ArgValue)) { 1665 // If the argument didn't provide an extension, then set it. 1666 const char *Extension = types::getTypeTempSuffix(FileType, true); 1667 1668 if (FileType == types::TY_Image && 1669 Args.hasArg(options::OPT__SLASH_LD, options::OPT__SLASH_LDd)) { 1670 // The output file is a dll. 1671 Extension = "dll"; 1672 } 1673 1674 llvm::sys::path::replace_extension(Filename, Extension); 1675 } 1676 1677 return Args.MakeArgString(Filename.c_str()); 1678} 1679 1680const char *Driver::GetNamedOutputPath(Compilation &C, 1681 const JobAction &JA, 1682 const char *BaseInput, 1683 const char *BoundArch, 1684 bool AtTopLevel, 1685 bool MultipleArchs) const { 1686 llvm::PrettyStackTraceString CrashInfo("Computing output path"); 1687 // Output to a user requested destination? 1688 if (AtTopLevel && !isa<DsymutilJobAction>(JA) && 1689 !isa<VerifyJobAction>(JA)) { 1690 if (Arg *FinalOutput = C.getArgs().getLastArg(options::OPT_o)) 1691 return C.addResultFile(FinalOutput->getValue(), &JA); 1692 } 1693 1694 // For /P, preprocess to file named after BaseInput. 1695 if (C.getArgs().hasArg(options::OPT__SLASH_P)) { 1696 assert(AtTopLevel && isa<PreprocessJobAction>(JA)); 1697 StringRef BaseName = llvm::sys::path::filename(BaseInput); 1698 StringRef NameArg; 1699 if (Arg *A = C.getArgs().getLastArg(options::OPT__SLASH_Fi, 1700 options::OPT__SLASH_o)) 1701 NameArg = A->getValue(); 1702 return C.addResultFile(MakeCLOutputFilename(C.getArgs(), NameArg, BaseName, 1703 types::TY_PP_C), &JA); 1704 } 1705 1706 // Default to writing to stdout? 1707 if (AtTopLevel && !CCGenDiagnostics && 1708 (isa<PreprocessJobAction>(JA) || JA.getType() == types::TY_ModuleFile)) 1709 return "-"; 1710 1711 // Is this the assembly listing for /FA? 1712 if (JA.getType() == types::TY_PP_Asm && 1713 (C.getArgs().hasArg(options::OPT__SLASH_FA) || 1714 C.getArgs().hasArg(options::OPT__SLASH_Fa))) { 1715 // Use /Fa and the input filename to determine the asm file name. 1716 StringRef BaseName = llvm::sys::path::filename(BaseInput); 1717 StringRef FaValue = C.getArgs().getLastArgValue(options::OPT__SLASH_Fa); 1718 return C.addResultFile(MakeCLOutputFilename(C.getArgs(), FaValue, BaseName, 1719 JA.getType()), &JA); 1720 } 1721 1722 // Output to a temporary file? 1723 if ((!AtTopLevel && !isSaveTempsEnabled() && 1724 !C.getArgs().hasArg(options::OPT__SLASH_Fo)) || 1725 CCGenDiagnostics) { 1726 StringRef Name = llvm::sys::path::filename(BaseInput); 1727 std::pair<StringRef, StringRef> Split = Name.split('.'); 1728 std::string TmpName = 1729 GetTemporaryPath(Split.first, 1730 types::getTypeTempSuffix(JA.getType(), IsCLMode())); 1731 return C.addTempFile(C.getArgs().MakeArgString(TmpName.c_str())); 1732 } 1733 1734 SmallString<128> BasePath(BaseInput); 1735 StringRef BaseName; 1736 1737 // Dsymutil actions should use the full path. 1738 if (isa<DsymutilJobAction>(JA) || isa<VerifyJobAction>(JA)) 1739 BaseName = BasePath; 1740 else 1741 BaseName = llvm::sys::path::filename(BasePath); 1742 1743 // Determine what the derived output name should be. 1744 const char *NamedOutput; 1745 1746 if (JA.getType() == types::TY_Object && 1747 C.getArgs().hasArg(options::OPT__SLASH_Fo, options::OPT__SLASH_o)) { 1748 // The /Fo or /o flag decides the object filename. 1749 StringRef Val = C.getArgs().getLastArg(options::OPT__SLASH_Fo, 1750 options::OPT__SLASH_o)->getValue(); 1751 NamedOutput = MakeCLOutputFilename(C.getArgs(), Val, BaseName, 1752 types::TY_Object); 1753 } else if (JA.getType() == types::TY_Image && 1754 C.getArgs().hasArg(options::OPT__SLASH_Fe, options::OPT__SLASH_o)) { 1755 // The /Fe or /o flag names the linked file. 1756 StringRef Val = C.getArgs().getLastArg(options::OPT__SLASH_Fe, 1757 options::OPT__SLASH_o)->getValue(); 1758 NamedOutput = MakeCLOutputFilename(C.getArgs(), Val, BaseName, 1759 types::TY_Image); 1760 } else if (JA.getType() == types::TY_Image) { 1761 if (IsCLMode()) { 1762 // clang-cl uses BaseName for the executable name. 1763 NamedOutput = MakeCLOutputFilename(C.getArgs(), "", BaseName, 1764 types::TY_Image); 1765 } else if (MultipleArchs && BoundArch) { 1766 SmallString<128> Output(getDefaultImageName()); 1767 Output += "-"; 1768 Output.append(BoundArch); 1769 NamedOutput = C.getArgs().MakeArgString(Output.c_str()); 1770 } else 1771 NamedOutput = getDefaultImageName(); 1772 } else { 1773 const char *Suffix = types::getTypeTempSuffix(JA.getType(), IsCLMode()); 1774 assert(Suffix && "All types used for output should have a suffix."); 1775 1776 std::string::size_type End = std::string::npos; 1777 if (!types::appendSuffixForType(JA.getType())) 1778 End = BaseName.rfind('.'); 1779 SmallString<128> Suffixed(BaseName.substr(0, End)); 1780 if (MultipleArchs && BoundArch) { 1781 Suffixed += "-"; 1782 Suffixed.append(BoundArch); 1783 } 1784 // When using both -save-temps and -emit-llvm, use a ".tmp.bc" suffix for 1785 // the unoptimized bitcode so that it does not get overwritten by the ".bc" 1786 // optimized bitcode output. 1787 if (!AtTopLevel && C.getArgs().hasArg(options::OPT_emit_llvm) && 1788 JA.getType() == types::TY_LLVM_BC) 1789 Suffixed += ".tmp"; 1790 Suffixed += '.'; 1791 Suffixed += Suffix; 1792 NamedOutput = C.getArgs().MakeArgString(Suffixed.c_str()); 1793 } 1794 1795 // Prepend object file path if -save-temps=obj 1796 if (!AtTopLevel && isSaveTempsObj() && C.getArgs().hasArg(options::OPT_o) && 1797 JA.getType() != types::TY_PCH) { 1798 Arg *FinalOutput = C.getArgs().getLastArg(options::OPT_o); 1799 SmallString<128> TempPath(FinalOutput->getValue()); 1800 llvm::sys::path::remove_filename(TempPath); 1801 StringRef OutputFileName = llvm::sys::path::filename(NamedOutput); 1802 llvm::sys::path::append(TempPath, OutputFileName); 1803 NamedOutput = C.getArgs().MakeArgString(TempPath.c_str()); 1804 } 1805 1806 // If we're saving temps and the temp file conflicts with the input file, 1807 // then avoid overwriting input file. 1808 if (!AtTopLevel && isSaveTempsEnabled() && NamedOutput == BaseName) { 1809 bool SameFile = false; 1810 SmallString<256> Result; 1811 llvm::sys::fs::current_path(Result); 1812 llvm::sys::path::append(Result, BaseName); 1813 llvm::sys::fs::equivalent(BaseInput, Result.c_str(), SameFile); 1814 // Must share the same path to conflict. 1815 if (SameFile) { 1816 StringRef Name = llvm::sys::path::filename(BaseInput); 1817 std::pair<StringRef, StringRef> Split = Name.split('.'); 1818 std::string TmpName = 1819 GetTemporaryPath(Split.first, 1820 types::getTypeTempSuffix(JA.getType(), IsCLMode())); 1821 return C.addTempFile(C.getArgs().MakeArgString(TmpName.c_str())); 1822 } 1823 } 1824 1825 // As an annoying special case, PCH generation doesn't strip the pathname. 1826 if (JA.getType() == types::TY_PCH) { 1827 llvm::sys::path::remove_filename(BasePath); 1828 if (BasePath.empty()) 1829 BasePath = NamedOutput; 1830 else 1831 llvm::sys::path::append(BasePath, NamedOutput); 1832 return C.addResultFile(C.getArgs().MakeArgString(BasePath.c_str()), &JA); 1833 } else { 1834 return C.addResultFile(NamedOutput, &JA); 1835 } 1836} 1837 1838std::string Driver::GetFilePath(const char *Name, const ToolChain &TC) const { 1839 // Respect a limited subset of the '-Bprefix' functionality in GCC by 1840 // attempting to use this prefix when looking for file paths. 1841 for (Driver::prefix_list::const_iterator it = PrefixDirs.begin(), 1842 ie = PrefixDirs.end(); it != ie; ++it) { 1843 std::string Dir(*it); 1844 if (Dir.empty()) 1845 continue; 1846 if (Dir[0] == '=') 1847 Dir = SysRoot + Dir.substr(1); 1848 SmallString<128> P(Dir); 1849 llvm::sys::path::append(P, Name); 1850 if (llvm::sys::fs::exists(Twine(P))) 1851 return P.str(); 1852 } 1853 1854 SmallString<128> P(ResourceDir); 1855 llvm::sys::path::append(P, Name); 1856 if (llvm::sys::fs::exists(Twine(P))) 1857 return P.str(); 1858 1859 const ToolChain::path_list &List = TC.getFilePaths(); 1860 for (ToolChain::path_list::const_iterator 1861 it = List.begin(), ie = List.end(); it != ie; ++it) { 1862 std::string Dir(*it); 1863 if (Dir.empty()) 1864 continue; 1865 if (Dir[0] == '=') 1866 Dir = SysRoot + Dir.substr(1); 1867 SmallString<128> P(Dir); 1868 llvm::sys::path::append(P, Name); 1869 if (llvm::sys::fs::exists(Twine(P))) 1870 return P.str(); 1871 } 1872 1873 return Name; 1874} 1875 1876void 1877Driver::generatePrefixedToolNames(const char *Tool, const ToolChain &TC, 1878 SmallVectorImpl<std::string> &Names) const { 1879 // FIXME: Needs a better variable than DefaultTargetTriple 1880 Names.push_back(DefaultTargetTriple + "-" + Tool); 1881 Names.push_back(Tool); 1882} 1883 1884static bool ScanDirForExecutable(SmallString<128> &Dir, 1885 ArrayRef<std::string> Names) { 1886 for (const auto &Name : Names) { 1887 llvm::sys::path::append(Dir, Name); 1888 if (llvm::sys::fs::can_execute(Twine(Dir))) 1889 return true; 1890 llvm::sys::path::remove_filename(Dir); 1891 } 1892 return false; 1893} 1894 1895std::string Driver::GetProgramPath(const char *Name, 1896 const ToolChain &TC) const { 1897 SmallVector<std::string, 2> TargetSpecificExecutables; 1898 generatePrefixedToolNames(Name, TC, TargetSpecificExecutables); 1899 1900 // Respect a limited subset of the '-Bprefix' functionality in GCC by 1901 // attempting to use this prefix when looking for program paths. 1902 for (const auto &PrefixDir : PrefixDirs) { 1903 if (llvm::sys::fs::is_directory(PrefixDir)) { 1904 SmallString<128> P(PrefixDir); 1905 if (ScanDirForExecutable(P, TargetSpecificExecutables)) 1906 return P.str(); 1907 } else { 1908 SmallString<128> P(PrefixDir + Name); 1909 if (llvm::sys::fs::can_execute(Twine(P))) 1910 return P.str(); 1911 } 1912 } 1913 1914 const ToolChain::path_list &List = TC.getProgramPaths(); 1915 for (const auto &Path : List) { 1916 SmallString<128> P(Path); 1917 if (ScanDirForExecutable(P, TargetSpecificExecutables)) 1918 return P.str(); 1919 } 1920 1921 // If all else failed, search the path. 1922 for (const auto &TargetSpecificExecutable : TargetSpecificExecutables) 1923 if (llvm::ErrorOr<std::string> P = 1924 llvm::sys::findProgramByName(TargetSpecificExecutable)) 1925 return *P; 1926 1927 return Name; 1928} 1929 1930std::string Driver::GetTemporaryPath(StringRef Prefix, const char *Suffix) 1931 const { 1932 SmallString<128> Path; 1933 std::error_code EC = llvm::sys::fs::createTemporaryFile(Prefix, Suffix, Path); 1934 if (EC) { 1935 Diag(clang::diag::err_unable_to_make_temp) << EC.message(); 1936 return ""; 1937 } 1938 1939 return Path.str(); 1940} 1941 1942/// \brief Compute target triple from args. 1943/// 1944/// This routine provides the logic to compute a target triple from various 1945/// args passed to the driver and the default triple string. 1946static llvm::Triple computeTargetTriple(StringRef DefaultTargetTriple, 1947 const ArgList &Args, 1948 StringRef DarwinArchName) { 1949 // FIXME: Already done in Compilation *Driver::BuildCompilation 1950 if (const Arg *A = Args.getLastArg(options::OPT_target)) 1951 DefaultTargetTriple = A->getValue(); 1952 1953 llvm::Triple Target(llvm::Triple::normalize(DefaultTargetTriple)); 1954 1955 // Handle Apple-specific options available here. 1956 if (Target.isOSBinFormatMachO()) { 1957 // If an explict Darwin arch name is given, that trumps all. 1958 if (!DarwinArchName.empty()) { 1959 tools::darwin::setTripleTypeForMachOArchName(Target, DarwinArchName); 1960 return Target; 1961 } 1962 1963 // Handle the Darwin '-arch' flag. 1964 if (Arg *A = Args.getLastArg(options::OPT_arch)) { 1965 StringRef ArchName = A->getValue(); 1966 tools::darwin::setTripleTypeForMachOArchName(Target, ArchName); 1967 } 1968 } 1969 1970 // Handle pseudo-target flags '-mlittle-endian'/'-EL' and 1971 // '-mbig-endian'/'-EB'. 1972 if (Arg *A = Args.getLastArg(options::OPT_mlittle_endian, 1973 options::OPT_mbig_endian)) { 1974 if (A->getOption().matches(options::OPT_mlittle_endian)) { 1975 if (Target.getArch() == llvm::Triple::mips) 1976 Target.setArch(llvm::Triple::mipsel); 1977 else if (Target.getArch() == llvm::Triple::mips64) 1978 Target.setArch(llvm::Triple::mips64el); 1979 else if (Target.getArch() == llvm::Triple::aarch64_be) 1980 Target.setArch(llvm::Triple::aarch64); 1981 } else { 1982 if (Target.getArch() == llvm::Triple::mipsel) 1983 Target.setArch(llvm::Triple::mips); 1984 else if (Target.getArch() == llvm::Triple::mips64el) 1985 Target.setArch(llvm::Triple::mips64); 1986 else if (Target.getArch() == llvm::Triple::aarch64) 1987 Target.setArch(llvm::Triple::aarch64_be); 1988 } 1989 } 1990 1991 // Skip further flag support on OSes which don't support '-m32' or '-m64'. 1992 if (Target.getArchName() == "tce" || Target.getOS() == llvm::Triple::Minix) 1993 return Target; 1994 1995 // Handle pseudo-target flags '-m64', '-mx32', '-m32' and '-m16'. 1996 if (Arg *A = Args.getLastArg(options::OPT_m64, options::OPT_mx32, 1997 options::OPT_m32, options::OPT_m16)) { 1998 llvm::Triple::ArchType AT = llvm::Triple::UnknownArch; 1999 2000 if (A->getOption().matches(options::OPT_m64)) { 2001 AT = Target.get64BitArchVariant().getArch(); 2002 if (Target.getEnvironment() == llvm::Triple::GNUX32) 2003 Target.setEnvironment(llvm::Triple::GNU); 2004 } else if (A->getOption().matches(options::OPT_mx32) && 2005 Target.get64BitArchVariant().getArch() == llvm::Triple::x86_64) { 2006 AT = llvm::Triple::x86_64; 2007 Target.setEnvironment(llvm::Triple::GNUX32); 2008 } else if (A->getOption().matches(options::OPT_m32)) { 2009 AT = Target.get32BitArchVariant().getArch(); 2010 if (Target.getEnvironment() == llvm::Triple::GNUX32) 2011 Target.setEnvironment(llvm::Triple::GNU); 2012 } else if (A->getOption().matches(options::OPT_m16) && 2013 Target.get32BitArchVariant().getArch() == llvm::Triple::x86) { 2014 AT = llvm::Triple::x86; 2015 Target.setEnvironment(llvm::Triple::CODE16); 2016 } 2017 2018 if (AT != llvm::Triple::UnknownArch && AT != Target.getArch()) 2019 Target.setArch(AT); 2020 } 2021 2022 return Target; 2023} 2024 2025const ToolChain &Driver::getToolChain(const ArgList &Args, 2026 StringRef DarwinArchName) const { 2027 llvm::Triple Target = computeTargetTriple(DefaultTargetTriple, Args, 2028 DarwinArchName); 2029 2030 ToolChain *&TC = ToolChains[Target.str()]; 2031 if (!TC) { 2032 switch (Target.getOS()) { 2033 case llvm::Triple::CloudABI: 2034 TC = new toolchains::CloudABI(*this, Target, Args); 2035 break; 2036 case llvm::Triple::Darwin: 2037 case llvm::Triple::MacOSX: 2038 case llvm::Triple::IOS: 2039 TC = new toolchains::DarwinClang(*this, Target, Args); 2040 break; 2041 case llvm::Triple::DragonFly: 2042 TC = new toolchains::DragonFly(*this, Target, Args); 2043 break; 2044 case llvm::Triple::OpenBSD: 2045 TC = new toolchains::OpenBSD(*this, Target, Args); 2046 break; 2047 case llvm::Triple::Bitrig: 2048 TC = new toolchains::Bitrig(*this, Target, Args); 2049 break; 2050 case llvm::Triple::NetBSD: 2051 TC = new toolchains::NetBSD(*this, Target, Args); 2052 break; 2053 case llvm::Triple::FreeBSD: 2054 TC = new toolchains::FreeBSD(*this, Target, Args); 2055 break; 2056 case llvm::Triple::Minix: 2057 TC = new toolchains::Minix(*this, Target, Args); 2058 break; 2059 case llvm::Triple::Linux: 2060 if (Target.getArch() == llvm::Triple::hexagon) 2061 TC = new toolchains::Hexagon_TC(*this, Target, Args); 2062 else 2063 TC = new toolchains::Linux(*this, Target, Args); 2064 break; 2065 case llvm::Triple::NaCl: 2066 TC = new toolchains::NaCl_TC(*this, Target, Args); 2067 break; 2068 case llvm::Triple::Solaris: 2069 TC = new toolchains::Solaris(*this, Target, Args); 2070 break; 2071 case llvm::Triple::Win32: 2072 switch (Target.getEnvironment()) { 2073 default: 2074 if (Target.isOSBinFormatELF()) 2075 TC = new toolchains::Generic_ELF(*this, Target, Args); 2076 else if (Target.isOSBinFormatMachO()) 2077 TC = new toolchains::MachO(*this, Target, Args); 2078 else 2079 TC = new toolchains::Generic_GCC(*this, Target, Args); 2080 break; 2081 case llvm::Triple::GNU: 2082 // FIXME: We need a MinGW toolchain. Use the default Generic_GCC 2083 // toolchain for now as the default case would below otherwise. 2084 if (Target.isOSBinFormatELF()) 2085 TC = new toolchains::Generic_ELF(*this, Target, Args); 2086 else 2087 TC = new toolchains::Generic_GCC(*this, Target, Args); 2088 break; 2089 case llvm::Triple::Itanium: 2090 TC = new toolchains::CrossWindowsToolChain(*this, Target, Args); 2091 break; 2092 case llvm::Triple::MSVC: 2093 case llvm::Triple::UnknownEnvironment: 2094 TC = new toolchains::MSVCToolChain(*this, Target, Args); 2095 break; 2096 } 2097 break; 2098 default: 2099 // TCE is an OSless target 2100 if (Target.getArchName() == "tce") { 2101 TC = new toolchains::TCEToolChain(*this, Target, Args); 2102 break; 2103 } 2104 // If Hexagon is configured as an OSless target 2105 if (Target.getArch() == llvm::Triple::hexagon) { 2106 TC = new toolchains::Hexagon_TC(*this, Target, Args); 2107 break; 2108 } 2109 if (Target.getArch() == llvm::Triple::xcore) { 2110 TC = new toolchains::XCore(*this, Target, Args); 2111 break; 2112 } 2113 if (Target.isOSBinFormatELF()) { 2114 TC = new toolchains::Generic_ELF(*this, Target, Args); 2115 break; 2116 } 2117 if (Target.isOSBinFormatMachO()) { 2118 TC = new toolchains::MachO(*this, Target, Args); 2119 break; 2120 } 2121 TC = new toolchains::Generic_GCC(*this, Target, Args); 2122 break; 2123 } 2124 } 2125 return *TC; 2126} 2127 2128bool Driver::ShouldUseClangCompiler(const JobAction &JA) const { 2129 // Check if user requested no clang, or clang doesn't understand this type (we 2130 // only handle single inputs for now). 2131 if (JA.size() != 1 || 2132 !types::isAcceptedByClang((*JA.begin())->getType())) 2133 return false; 2134 2135 // Otherwise make sure this is an action clang understands. 2136 if (!isa<PreprocessJobAction>(JA) && !isa<PrecompileJobAction>(JA) && 2137 !isa<CompileJobAction>(JA) && !isa<BackendJobAction>(JA)) 2138 return false; 2139 2140 return true; 2141} 2142 2143/// GetReleaseVersion - Parse (([0-9]+)(.([0-9]+)(.([0-9]+)?))?)? and return the 2144/// grouped values as integers. Numbers which are not provided are set to 0. 2145/// 2146/// \return True if the entire string was parsed (9.2), or all groups were 2147/// parsed (10.3.5extrastuff). 2148bool Driver::GetReleaseVersion(const char *Str, unsigned &Major, 2149 unsigned &Minor, unsigned &Micro, 2150 bool &HadExtra) { 2151 HadExtra = false; 2152 2153 Major = Minor = Micro = 0; 2154 if (*Str == '\0') 2155 return false; 2156 2157 char *End; 2158 Major = (unsigned) strtol(Str, &End, 10); 2159 if (*Str != '\0' && *End == '\0') 2160 return true; 2161 if (*End != '.') 2162 return false; 2163 2164 Str = End+1; 2165 Minor = (unsigned) strtol(Str, &End, 10); 2166 if (*Str != '\0' && *End == '\0') 2167 return true; 2168 if (*End != '.') 2169 return false; 2170 2171 Str = End+1; 2172 Micro = (unsigned) strtol(Str, &End, 10); 2173 if (*Str != '\0' && *End == '\0') 2174 return true; 2175 if (Str == End) 2176 return false; 2177 HadExtra = true; 2178 return true; 2179} 2180 2181std::pair<unsigned, unsigned> Driver::getIncludeExcludeOptionFlagMasks() const { 2182 unsigned IncludedFlagsBitmask = 0; 2183 unsigned ExcludedFlagsBitmask = options::NoDriverOption; 2184 2185 if (Mode == CLMode) { 2186 // Include CL and Core options. 2187 IncludedFlagsBitmask |= options::CLOption; 2188 IncludedFlagsBitmask |= options::CoreOption; 2189 } else { 2190 ExcludedFlagsBitmask |= options::CLOption; 2191 } 2192 2193 return std::make_pair(IncludedFlagsBitmask, ExcludedFlagsBitmask); 2194} 2195 2196bool clang::driver::isOptimizationLevelFast(const llvm::opt::ArgList &Args) { 2197 return Args.hasFlag(options::OPT_Ofast, options::OPT_O_Group, false); 2198} 2199