Driver.cpp revision d2a527eae6df377b326e8d764782bc34f1e64189
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 12#include "clang/Driver/Action.h" 13#include "clang/Driver/Arg.h" 14#include "clang/Driver/ArgList.h" 15#include "clang/Driver/Compilation.h" 16#include "clang/Driver/DriverDiagnostic.h" 17#include "clang/Driver/Job.h" 18#include "clang/Driver/OptTable.h" 19#include "clang/Driver/Option.h" 20#include "clang/Driver/Options.h" 21#include "clang/Driver/Tool.h" 22#include "clang/Driver/ToolChain.h" 23 24#include "clang/Basic/Version.h" 25 26#include "llvm/ADT/ArrayRef.h" 27#include "llvm/ADT/StringSet.h" 28#include "llvm/ADT/OwningPtr.h" 29#include "llvm/Support/ErrorHandling.h" 30#include "llvm/Support/PrettyStackTrace.h" 31#include "llvm/Support/raw_ostream.h" 32#include "llvm/Support/FileSystem.h" 33#include "llvm/Support/Path.h" 34#include "llvm/Support/Program.h" 35 36#include "InputInfo.h" 37#include "ToolChains.h" 38 39#include <map> 40 41#include "clang/Config/config.h" 42 43using namespace clang::driver; 44using namespace clang; 45 46Driver::Driver(StringRef ClangExecutable, 47 StringRef DefaultTargetTriple, 48 StringRef DefaultImageName, 49 bool IsProduction, 50 DiagnosticsEngine &Diags) 51 : Opts(createDriverOptTable()), Diags(Diags), 52 ClangExecutable(ClangExecutable), SysRoot(DEFAULT_SYSROOT), 53 UseStdLib(true), DefaultTargetTriple(DefaultTargetTriple), 54 DefaultImageName(DefaultImageName), 55 DriverTitle("clang LLVM compiler"), 56 CCPrintOptionsFilename(0), CCPrintHeadersFilename(0), 57 CCLogDiagnosticsFilename(0), CCCIsCXX(false), 58 CCCIsCPP(false),CCCEcho(false), CCCPrintBindings(false), 59 CCPrintOptions(false), CCPrintHeaders(false), CCLogDiagnostics(false), 60 CCGenDiagnostics(false), CCCGenericGCCName(""), CheckInputsExist(true), 61 CCCUsePCH(true), SuppressMissingInputWarning(false) { 62 63 Name = llvm::sys::path::stem(ClangExecutable); 64 Dir = llvm::sys::path::parent_path(ClangExecutable); 65 66 // Compute the path to the resource directory. 67 StringRef ClangResourceDir(CLANG_RESOURCE_DIR); 68 SmallString<128> P(Dir); 69 if (ClangResourceDir != "") 70 llvm::sys::path::append(P, ClangResourceDir); 71 else 72 llvm::sys::path::append(P, "..", "lib", "clang", CLANG_VERSION_STRING); 73 ResourceDir = P.str(); 74} 75 76Driver::~Driver() { 77 delete Opts; 78 79 for (llvm::StringMap<ToolChain *>::iterator I = ToolChains.begin(), 80 E = ToolChains.end(); 81 I != E; ++I) 82 delete I->second; 83} 84 85InputArgList *Driver::ParseArgStrings(ArrayRef<const char *> ArgList) { 86 llvm::PrettyStackTraceString CrashInfo("Command line argument parsing"); 87 unsigned MissingArgIndex, MissingArgCount; 88 InputArgList *Args = getOpts().ParseArgs(ArgList.begin(), ArgList.end(), 89 MissingArgIndex, MissingArgCount); 90 91 // Check for missing argument error. 92 if (MissingArgCount) 93 Diag(clang::diag::err_drv_missing_argument) 94 << Args->getArgString(MissingArgIndex) << MissingArgCount; 95 96 // Check for unsupported options. 97 for (ArgList::const_iterator it = Args->begin(), ie = Args->end(); 98 it != ie; ++it) { 99 Arg *A = *it; 100 if (A->getOption().hasFlag(options::Unsupported)) { 101 Diag(clang::diag::err_drv_unsupported_opt) << A->getAsString(*Args); 102 continue; 103 } 104 105 // Warn about -mcpu= without an argument. 106 if (A->getOption().matches(options::OPT_mcpu_EQ) && 107 A->containsValue("")) { 108 Diag(clang::diag::warn_drv_empty_joined_argument) << 109 A->getAsString(*Args); 110 } 111 } 112 113 return Args; 114} 115 116// Determine which compilation mode we are in. We look for options which 117// affect the phase, starting with the earliest phases, and record which 118// option we used to determine the final phase. 119phases::ID Driver::getFinalPhase(const DerivedArgList &DAL, Arg **FinalPhaseArg) 120const { 121 Arg *PhaseArg = 0; 122 phases::ID FinalPhase; 123 124 // -{E,M,MM} only run the preprocessor. 125 if (CCCIsCPP || 126 (PhaseArg = DAL.getLastArg(options::OPT_E)) || 127 (PhaseArg = DAL.getLastArg(options::OPT_M, options::OPT_MM))) { 128 FinalPhase = phases::Preprocess; 129 130 // -{fsyntax-only,-analyze,emit-ast,S} only run up to the compiler. 131 } else if ((PhaseArg = DAL.getLastArg(options::OPT_fsyntax_only)) || 132 (PhaseArg = DAL.getLastArg(options::OPT_rewrite_objc)) || 133 (PhaseArg = DAL.getLastArg(options::OPT_rewrite_legacy_objc)) || 134 (PhaseArg = DAL.getLastArg(options::OPT__migrate)) || 135 (PhaseArg = DAL.getLastArg(options::OPT__analyze, 136 options::OPT__analyze_auto)) || 137 (PhaseArg = DAL.getLastArg(options::OPT_emit_ast)) || 138 (PhaseArg = DAL.getLastArg(options::OPT_S))) { 139 FinalPhase = phases::Compile; 140 141 // -c only runs up to the assembler. 142 } else if ((PhaseArg = DAL.getLastArg(options::OPT_c))) { 143 FinalPhase = phases::Assemble; 144 145 // Otherwise do everything. 146 } else 147 FinalPhase = phases::Link; 148 149 if (FinalPhaseArg) 150 *FinalPhaseArg = PhaseArg; 151 152 return FinalPhase; 153} 154 155DerivedArgList *Driver::TranslateInputArgs(const InputArgList &Args) const { 156 DerivedArgList *DAL = new DerivedArgList(Args); 157 158 bool HasNostdlib = Args.hasArg(options::OPT_nostdlib); 159 for (ArgList::const_iterator it = Args.begin(), 160 ie = Args.end(); it != ie; ++it) { 161 const Arg *A = *it; 162 163 // Unfortunately, we have to parse some forwarding options (-Xassembler, 164 // -Xlinker, -Xpreprocessor) because we either integrate their functionality 165 // (assembler and preprocessor), or bypass a previous driver ('collect2'). 166 167 // Rewrite linker options, to replace --no-demangle with a custom internal 168 // option. 169 if ((A->getOption().matches(options::OPT_Wl_COMMA) || 170 A->getOption().matches(options::OPT_Xlinker)) && 171 A->containsValue("--no-demangle")) { 172 // Add the rewritten no-demangle argument. 173 DAL->AddFlagArg(A, Opts->getOption(options::OPT_Z_Xlinker__no_demangle)); 174 175 // Add the remaining values as Xlinker arguments. 176 for (unsigned i = 0, e = A->getNumValues(); i != e; ++i) 177 if (StringRef(A->getValue(i)) != "--no-demangle") 178 DAL->AddSeparateArg(A, Opts->getOption(options::OPT_Xlinker), 179 A->getValue(i)); 180 181 continue; 182 } 183 184 // Rewrite preprocessor options, to replace -Wp,-MD,FOO which is used by 185 // some build systems. We don't try to be complete here because we don't 186 // care to encourage this usage model. 187 if (A->getOption().matches(options::OPT_Wp_COMMA) && 188 (A->getValue(0) == StringRef("-MD") || 189 A->getValue(0) == StringRef("-MMD"))) { 190 // Rewrite to -MD/-MMD along with -MF. 191 if (A->getValue(0) == StringRef("-MD")) 192 DAL->AddFlagArg(A, Opts->getOption(options::OPT_MD)); 193 else 194 DAL->AddFlagArg(A, Opts->getOption(options::OPT_MMD)); 195 if (A->getNumValues() == 2) 196 DAL->AddSeparateArg(A, Opts->getOption(options::OPT_MF), 197 A->getValue(1)); 198 continue; 199 } 200 201 // Rewrite reserved library names. 202 if (A->getOption().matches(options::OPT_l)) { 203 StringRef Value = A->getValue(); 204 205 // Rewrite unless -nostdlib is present. 206 if (!HasNostdlib && Value == "stdc++") { 207 DAL->AddFlagArg(A, Opts->getOption( 208 options::OPT_Z_reserved_lib_stdcxx)); 209 continue; 210 } 211 212 // Rewrite unconditionally. 213 if (Value == "cc_kext") { 214 DAL->AddFlagArg(A, Opts->getOption( 215 options::OPT_Z_reserved_lib_cckext)); 216 continue; 217 } 218 } 219 220 DAL->append(*it); 221 } 222 223 // Add a default value of -mlinker-version=, if one was given and the user 224 // didn't specify one. 225#if defined(HOST_LINK_VERSION) 226 if (!Args.hasArg(options::OPT_mlinker_version_EQ)) { 227 DAL->AddJoinedArg(0, Opts->getOption(options::OPT_mlinker_version_EQ), 228 HOST_LINK_VERSION); 229 DAL->getLastArg(options::OPT_mlinker_version_EQ)->claim(); 230 } 231#endif 232 233 return DAL; 234} 235 236Compilation *Driver::BuildCompilation(ArrayRef<const char *> ArgList) { 237 llvm::PrettyStackTraceString CrashInfo("Compilation construction"); 238 239 // FIXME: Handle environment options which affect driver behavior, somewhere 240 // (client?). GCC_EXEC_PREFIX, LPATH, CC_PRINT_OPTIONS. 241 242 if (char *env = ::getenv("COMPILER_PATH")) { 243 StringRef CompilerPath = env; 244 while (!CompilerPath.empty()) { 245 std::pair<StringRef, StringRef> Split = CompilerPath.split(':'); 246 PrefixDirs.push_back(Split.first); 247 CompilerPath = Split.second; 248 } 249 } 250 251 // FIXME: What are we going to do with -V and -b? 252 253 // FIXME: This stuff needs to go into the Compilation, not the driver. 254 bool CCCPrintOptions = false, CCCPrintActions = false; 255 256 InputArgList *Args = ParseArgStrings(ArgList.slice(1)); 257 258 // -no-canonical-prefixes is used very early in main. 259 Args->ClaimAllArgs(options::OPT_no_canonical_prefixes); 260 261 // Ignore -pipe. 262 Args->ClaimAllArgs(options::OPT_pipe); 263 264 // Extract -ccc args. 265 // 266 // FIXME: We need to figure out where this behavior should live. Most of it 267 // should be outside in the client; the parts that aren't should have proper 268 // options, either by introducing new ones or by overloading gcc ones like -V 269 // or -b. 270 CCCPrintOptions = Args->hasArg(options::OPT_ccc_print_options); 271 CCCPrintActions = Args->hasArg(options::OPT_ccc_print_phases); 272 CCCPrintBindings = Args->hasArg(options::OPT_ccc_print_bindings); 273 CCCIsCXX = Args->hasArg(options::OPT_ccc_cxx) || CCCIsCXX; 274 CCCEcho = Args->hasArg(options::OPT_ccc_echo); 275 if (const Arg *A = Args->getLastArg(options::OPT_ccc_gcc_name)) 276 CCCGenericGCCName = A->getValue(); 277 CCCUsePCH = Args->hasFlag(options::OPT_ccc_pch_is_pch, 278 options::OPT_ccc_pch_is_pth); 279 // FIXME: DefaultTargetTriple is used by the target-prefixed calls to as/ld 280 // and getToolChain is const. 281 if (const Arg *A = Args->getLastArg(options::OPT_target)) 282 DefaultTargetTriple = A->getValue(); 283 if (const Arg *A = Args->getLastArg(options::OPT_ccc_install_dir)) 284 Dir = InstalledDir = A->getValue(); 285 for (arg_iterator it = Args->filtered_begin(options::OPT_B), 286 ie = Args->filtered_end(); it != ie; ++it) { 287 const Arg *A = *it; 288 A->claim(); 289 PrefixDirs.push_back(A->getValue(0)); 290 } 291 if (const Arg *A = Args->getLastArg(options::OPT__sysroot_EQ)) 292 SysRoot = A->getValue(); 293 if (Args->hasArg(options::OPT_nostdlib)) 294 UseStdLib = false; 295 296 // Perform the default argument translations. 297 DerivedArgList *TranslatedArgs = TranslateInputArgs(*Args); 298 299 // Owned by the host. 300 const ToolChain &TC = getToolChain(*Args); 301 302 // The compilation takes ownership of Args. 303 Compilation *C = new Compilation(*this, TC, Args, TranslatedArgs); 304 305 // FIXME: This behavior shouldn't be here. 306 if (CCCPrintOptions) { 307 PrintOptions(C->getInputArgs()); 308 return C; 309 } 310 311 if (!HandleImmediateArgs(*C)) 312 return C; 313 314 // Construct the list of inputs. 315 InputList Inputs; 316 BuildInputs(C->getDefaultToolChain(), C->getArgs(), Inputs); 317 318 // Construct the list of abstract actions to perform for this compilation. On 319 // Darwin target OSes this uses the driver-driver and universal actions. 320 if (TC.getTriple().isOSDarwin()) 321 BuildUniversalActions(C->getDefaultToolChain(), C->getArgs(), 322 Inputs, C->getActions()); 323 else 324 BuildActions(C->getDefaultToolChain(), C->getArgs(), Inputs, 325 C->getActions()); 326 327 if (CCCPrintActions) { 328 PrintActions(*C); 329 return C; 330 } 331 332 BuildJobs(*C); 333 334 return C; 335} 336 337// When clang crashes, produce diagnostic information including the fully 338// preprocessed source file(s). Request that the developer attach the 339// diagnostic information to a bug report. 340void Driver::generateCompilationDiagnostics(Compilation &C, 341 const Command *FailingCommand) { 342 if (C.getArgs().hasArg(options::OPT_fno_crash_diagnostics)) 343 return; 344 345 // Don't try to generate diagnostics for link jobs. 346 if (FailingCommand && FailingCommand->getCreator().isLinkJob()) 347 return; 348 349 // Print the version of the compiler. 350 PrintVersion(C, llvm::errs()); 351 352 Diag(clang::diag::note_drv_command_failed_diag_msg) 353 << "PLEASE submit a bug report to " BUG_REPORT_URL " and include the " 354 "crash backtrace, preprocessed source, and associated run script."; 355 356 // Suppress driver output and emit preprocessor output to temp file. 357 CCCIsCPP = true; 358 CCGenDiagnostics = true; 359 C.getArgs().AddFlagArg(0, Opts->getOption(options::OPT_frewrite_includes)); 360 361 // Save the original job command(s). 362 std::string Cmd; 363 llvm::raw_string_ostream OS(Cmd); 364 if (FailingCommand) 365 C.PrintDiagnosticJob(OS, *FailingCommand); 366 else 367 // Crash triggered by FORCE_CLANG_DIAGNOSTICS_CRASH, which doesn't have an 368 // associated FailingCommand, so just pass all jobs. 369 C.PrintDiagnosticJob(OS, C.getJobs()); 370 OS.flush(); 371 372 // Clear stale state and suppress tool output. 373 C.initCompilationForDiagnostics(); 374 Diags.Reset(); 375 376 // Construct the list of inputs. 377 InputList Inputs; 378 BuildInputs(C.getDefaultToolChain(), C.getArgs(), Inputs); 379 380 for (InputList::iterator it = Inputs.begin(), ie = Inputs.end(); it != ie;) { 381 bool IgnoreInput = false; 382 383 // Ignore input from stdin or any inputs that cannot be preprocessed. 384 if (!strcmp(it->second->getValue(), "-")) { 385 Diag(clang::diag::note_drv_command_failed_diag_msg) 386 << "Error generating preprocessed source(s) - ignoring input from stdin" 387 "."; 388 IgnoreInput = true; 389 } else if (types::getPreprocessedType(it->first) == types::TY_INVALID) { 390 IgnoreInput = true; 391 } 392 393 if (IgnoreInput) { 394 it = Inputs.erase(it); 395 ie = Inputs.end(); 396 } else { 397 ++it; 398 } 399 } 400 401 // Don't attempt to generate preprocessed files if multiple -arch options are 402 // used, unless they're all duplicates. 403 llvm::StringSet<> ArchNames; 404 for (ArgList::const_iterator it = C.getArgs().begin(), ie = C.getArgs().end(); 405 it != ie; ++it) { 406 Arg *A = *it; 407 if (A->getOption().matches(options::OPT_arch)) { 408 StringRef ArchName = A->getValue(); 409 ArchNames.insert(ArchName); 410 } 411 } 412 if (ArchNames.size() > 1) { 413 Diag(clang::diag::note_drv_command_failed_diag_msg) 414 << "Error generating preprocessed source(s) - cannot generate " 415 "preprocessed source with multiple -arch options."; 416 return; 417 } 418 419 if (Inputs.empty()) { 420 Diag(clang::diag::note_drv_command_failed_diag_msg) 421 << "Error generating preprocessed source(s) - no preprocessable inputs."; 422 return; 423 } 424 425 // Construct the list of abstract actions to perform for this compilation. On 426 // Darwin OSes this uses the driver-driver and builds universal actions. 427 const ToolChain &TC = C.getDefaultToolChain(); 428 if (TC.getTriple().isOSDarwin()) 429 BuildUniversalActions(TC, C.getArgs(), Inputs, C.getActions()); 430 else 431 BuildActions(TC, C.getArgs(), Inputs, C.getActions()); 432 433 BuildJobs(C); 434 435 // If there were errors building the compilation, quit now. 436 if (Diags.hasErrorOccurred()) { 437 Diag(clang::diag::note_drv_command_failed_diag_msg) 438 << "Error generating preprocessed source(s)."; 439 return; 440 } 441 442 // Generate preprocessed output. 443 FailingCommand = 0; 444 int Res = C.ExecuteJob(C.getJobs(), FailingCommand); 445 446 // If the command succeeded, we are done. 447 if (Res == 0) { 448 Diag(clang::diag::note_drv_command_failed_diag_msg) 449 << "\n********************\n\n" 450 "PLEASE ATTACH THE FOLLOWING FILES TO THE BUG REPORT:\n" 451 "Preprocessed source(s) and associated run script(s) are located at:"; 452 ArgStringList Files = C.getTempFiles(); 453 for (ArgStringList::const_iterator it = Files.begin(), ie = Files.end(); 454 it != ie; ++it) { 455 Diag(clang::diag::note_drv_command_failed_diag_msg) << *it; 456 457 std::string Err; 458 std::string Script = StringRef(*it).rsplit('.').first; 459 Script += ".sh"; 460 llvm::raw_fd_ostream ScriptOS(Script.c_str(), Err, 461 llvm::raw_fd_ostream::F_Excl | 462 llvm::raw_fd_ostream::F_Binary); 463 if (!Err.empty()) { 464 Diag(clang::diag::note_drv_command_failed_diag_msg) 465 << "Error generating run script: " + Script + " " + Err; 466 } else { 467 // Append the new filename with correct preprocessed suffix. 468 size_t I, E; 469 I = Cmd.find("-main-file-name "); 470 assert (I != std::string::npos && "Expected to find -main-file-name"); 471 I += 16; 472 E = Cmd.find(" ", I); 473 assert (E != std::string::npos && "-main-file-name missing argument?"); 474 StringRef OldFilename = StringRef(Cmd).slice(I, E); 475 StringRef NewFilename = llvm::sys::path::filename(*it); 476 I = StringRef(Cmd).rfind(OldFilename); 477 E = I + OldFilename.size(); 478 I = Cmd.rfind(" ", I) + 1; 479 Cmd.replace(I, E - I, NewFilename.data(), NewFilename.size()); 480 ScriptOS << Cmd; 481 Diag(clang::diag::note_drv_command_failed_diag_msg) << Script; 482 } 483 } 484 Diag(clang::diag::note_drv_command_failed_diag_msg) 485 << "\n\n********************"; 486 } else { 487 // Failure, remove preprocessed files. 488 if (!C.getArgs().hasArg(options::OPT_save_temps)) 489 C.CleanupFileList(C.getTempFiles(), true); 490 491 Diag(clang::diag::note_drv_command_failed_diag_msg) 492 << "Error generating preprocessed source(s)."; 493 } 494} 495 496int Driver::ExecuteCompilation(const Compilation &C, 497 const Command *&FailingCommand) const { 498 // Just print if -### was present. 499 if (C.getArgs().hasArg(options::OPT__HASH_HASH_HASH)) { 500 C.PrintJob(llvm::errs(), C.getJobs(), "\n", true); 501 return 0; 502 } 503 504 // If there were errors building the compilation, quit now. 505 if (Diags.hasErrorOccurred()) 506 return 1; 507 508 int Res = C.ExecuteJob(C.getJobs(), FailingCommand); 509 510 // Remove temp files. 511 C.CleanupFileList(C.getTempFiles()); 512 513 // If the command succeeded, we are done. 514 if (Res == 0) 515 return Res; 516 517 // Otherwise, remove result files as well. 518 if (!C.getArgs().hasArg(options::OPT_save_temps)) { 519 C.CleanupFileList(C.getResultFiles(), true); 520 521 // Failure result files are valid unless we crashed. 522 if (Res < 0) 523 C.CleanupFileList(C.getFailureResultFiles(), true); 524 } 525 526 // Print extra information about abnormal failures, if possible. 527 // 528 // This is ad-hoc, but we don't want to be excessively noisy. If the result 529 // status was 1, assume the command failed normally. In particular, if it was 530 // the compiler then assume it gave a reasonable error code. Failures in other 531 // tools are less common, and they generally have worse diagnostics, so always 532 // print the diagnostic there. 533 const Tool &FailingTool = FailingCommand->getCreator(); 534 535 if (!FailingCommand->getCreator().hasGoodDiagnostics() || Res != 1) { 536 // FIXME: See FIXME above regarding result code interpretation. 537 if (Res < 0) 538 Diag(clang::diag::err_drv_command_signalled) 539 << FailingTool.getShortName(); 540 else 541 Diag(clang::diag::err_drv_command_failed) 542 << FailingTool.getShortName() << Res; 543 } 544 545 return Res; 546} 547 548void Driver::PrintOptions(const ArgList &Args) const { 549 unsigned i = 0; 550 for (ArgList::const_iterator it = Args.begin(), ie = Args.end(); 551 it != ie; ++it, ++i) { 552 Arg *A = *it; 553 llvm::errs() << "Option " << i << " - " 554 << "Name: \"" << A->getOption().getPrefixedName() << "\", " 555 << "Values: {"; 556 for (unsigned j = 0; j < A->getNumValues(); ++j) { 557 if (j) 558 llvm::errs() << ", "; 559 llvm::errs() << '"' << A->getValue(j) << '"'; 560 } 561 llvm::errs() << "}\n"; 562 } 563} 564 565void Driver::PrintHelp(bool ShowHidden) const { 566 getOpts().PrintHelp(llvm::outs(), Name.c_str(), DriverTitle.c_str(), 567 ShowHidden); 568} 569 570void Driver::PrintVersion(const Compilation &C, raw_ostream &OS) const { 571 // FIXME: The following handlers should use a callback mechanism, we don't 572 // know what the client would like to do. 573 OS << getClangFullVersion() << '\n'; 574 const ToolChain &TC = C.getDefaultToolChain(); 575 OS << "Target: " << TC.getTripleString() << '\n'; 576 577 // Print the threading model. 578 // 579 // FIXME: Implement correctly. 580 OS << "Thread model: " << "posix" << '\n'; 581} 582 583/// PrintDiagnosticCategories - Implement the --print-diagnostic-categories 584/// option. 585static void PrintDiagnosticCategories(raw_ostream &OS) { 586 // Skip the empty category. 587 for (unsigned i = 1, max = DiagnosticIDs::getNumberOfCategories(); 588 i != max; ++i) 589 OS << i << ',' << DiagnosticIDs::getCategoryNameFromID(i) << '\n'; 590} 591 592bool Driver::HandleImmediateArgs(const Compilation &C) { 593 // The order these options are handled in gcc is all over the place, but we 594 // don't expect inconsistencies w.r.t. that to matter in practice. 595 596 if (C.getArgs().hasArg(options::OPT_dumpmachine)) { 597 llvm::outs() << C.getDefaultToolChain().getTripleString() << '\n'; 598 return false; 599 } 600 601 if (C.getArgs().hasArg(options::OPT_dumpversion)) { 602 // Since -dumpversion is only implemented for pedantic GCC compatibility, we 603 // return an answer which matches our definition of __VERSION__. 604 // 605 // If we want to return a more correct answer some day, then we should 606 // introduce a non-pedantically GCC compatible mode to Clang in which we 607 // provide sensible definitions for -dumpversion, __VERSION__, etc. 608 llvm::outs() << "4.2.1\n"; 609 return false; 610 } 611 612 if (C.getArgs().hasArg(options::OPT__print_diagnostic_categories)) { 613 PrintDiagnosticCategories(llvm::outs()); 614 return false; 615 } 616 617 if (C.getArgs().hasArg(options::OPT_help) || 618 C.getArgs().hasArg(options::OPT__help_hidden)) { 619 PrintHelp(C.getArgs().hasArg(options::OPT__help_hidden)); 620 return false; 621 } 622 623 if (C.getArgs().hasArg(options::OPT__version)) { 624 // Follow gcc behavior and use stdout for --version and stderr for -v. 625 PrintVersion(C, llvm::outs()); 626 return false; 627 } 628 629 if (C.getArgs().hasArg(options::OPT_v) || 630 C.getArgs().hasArg(options::OPT__HASH_HASH_HASH)) { 631 PrintVersion(C, llvm::errs()); 632 SuppressMissingInputWarning = true; 633 } 634 635 const ToolChain &TC = C.getDefaultToolChain(); 636 if (C.getArgs().hasArg(options::OPT_print_search_dirs)) { 637 llvm::outs() << "programs: ="; 638 for (ToolChain::path_list::const_iterator it = TC.getProgramPaths().begin(), 639 ie = TC.getProgramPaths().end(); it != ie; ++it) { 640 if (it != TC.getProgramPaths().begin()) 641 llvm::outs() << ':'; 642 llvm::outs() << *it; 643 } 644 llvm::outs() << "\n"; 645 llvm::outs() << "libraries: =" << ResourceDir; 646 647 StringRef sysroot = C.getSysRoot(); 648 649 for (ToolChain::path_list::const_iterator it = TC.getFilePaths().begin(), 650 ie = TC.getFilePaths().end(); it != ie; ++it) { 651 llvm::outs() << ':'; 652 const char *path = it->c_str(); 653 if (path[0] == '=') 654 llvm::outs() << sysroot << path + 1; 655 else 656 llvm::outs() << path; 657 } 658 llvm::outs() << "\n"; 659 return false; 660 } 661 662 // FIXME: The following handlers should use a callback mechanism, we don't 663 // know what the client would like to do. 664 if (Arg *A = C.getArgs().getLastArg(options::OPT_print_file_name_EQ)) { 665 llvm::outs() << GetFilePath(A->getValue(), TC) << "\n"; 666 return false; 667 } 668 669 if (Arg *A = C.getArgs().getLastArg(options::OPT_print_prog_name_EQ)) { 670 llvm::outs() << GetProgramPath(A->getValue(), TC) << "\n"; 671 return false; 672 } 673 674 if (C.getArgs().hasArg(options::OPT_print_libgcc_file_name)) { 675 llvm::outs() << GetFilePath("libgcc.a", TC) << "\n"; 676 return false; 677 } 678 679 if (C.getArgs().hasArg(options::OPT_print_multi_lib)) { 680 // FIXME: We need tool chain support for this. 681 llvm::outs() << ".;\n"; 682 683 switch (C.getDefaultToolChain().getTriple().getArch()) { 684 default: 685 break; 686 687 case llvm::Triple::x86_64: 688 llvm::outs() << "x86_64;@m64" << "\n"; 689 break; 690 691 case llvm::Triple::ppc64: 692 llvm::outs() << "ppc64;@m64" << "\n"; 693 break; 694 } 695 return false; 696 } 697 698 // FIXME: What is the difference between print-multi-directory and 699 // print-multi-os-directory? 700 if (C.getArgs().hasArg(options::OPT_print_multi_directory) || 701 C.getArgs().hasArg(options::OPT_print_multi_os_directory)) { 702 switch (C.getDefaultToolChain().getTriple().getArch()) { 703 default: 704 case llvm::Triple::x86: 705 case llvm::Triple::ppc: 706 llvm::outs() << "." << "\n"; 707 break; 708 709 case llvm::Triple::x86_64: 710 llvm::outs() << "x86_64" << "\n"; 711 break; 712 713 case llvm::Triple::ppc64: 714 llvm::outs() << "ppc64" << "\n"; 715 break; 716 } 717 return false; 718 } 719 720 return true; 721} 722 723static unsigned PrintActions1(const Compilation &C, Action *A, 724 std::map<Action*, unsigned> &Ids) { 725 if (Ids.count(A)) 726 return Ids[A]; 727 728 std::string str; 729 llvm::raw_string_ostream os(str); 730 731 os << Action::getClassName(A->getKind()) << ", "; 732 if (InputAction *IA = dyn_cast<InputAction>(A)) { 733 os << "\"" << IA->getInputArg().getValue() << "\""; 734 } else if (BindArchAction *BIA = dyn_cast<BindArchAction>(A)) { 735 os << '"' << BIA->getArchName() << '"' 736 << ", {" << PrintActions1(C, *BIA->begin(), Ids) << "}"; 737 } else { 738 os << "{"; 739 for (Action::iterator it = A->begin(), ie = A->end(); it != ie;) { 740 os << PrintActions1(C, *it, Ids); 741 ++it; 742 if (it != ie) 743 os << ", "; 744 } 745 os << "}"; 746 } 747 748 unsigned Id = Ids.size(); 749 Ids[A] = Id; 750 llvm::errs() << Id << ": " << os.str() << ", " 751 << types::getTypeName(A->getType()) << "\n"; 752 753 return Id; 754} 755 756void Driver::PrintActions(const Compilation &C) const { 757 std::map<Action*, unsigned> Ids; 758 for (ActionList::const_iterator it = C.getActions().begin(), 759 ie = C.getActions().end(); it != ie; ++it) 760 PrintActions1(C, *it, Ids); 761} 762 763/// \brief Check whether the given input tree contains any compilation or 764/// assembly actions. 765static bool ContainsCompileOrAssembleAction(const Action *A) { 766 if (isa<CompileJobAction>(A) || isa<AssembleJobAction>(A)) 767 return true; 768 769 for (Action::const_iterator it = A->begin(), ie = A->end(); it != ie; ++it) 770 if (ContainsCompileOrAssembleAction(*it)) 771 return true; 772 773 return false; 774} 775 776void Driver::BuildUniversalActions(const ToolChain &TC, 777 const DerivedArgList &Args, 778 const InputList &BAInputs, 779 ActionList &Actions) const { 780 llvm::PrettyStackTraceString CrashInfo("Building universal build actions"); 781 // Collect the list of architectures. Duplicates are allowed, but should only 782 // be handled once (in the order seen). 783 llvm::StringSet<> ArchNames; 784 SmallVector<const char *, 4> Archs; 785 for (ArgList::const_iterator it = Args.begin(), ie = Args.end(); 786 it != ie; ++it) { 787 Arg *A = *it; 788 789 if (A->getOption().matches(options::OPT_arch)) { 790 // Validate the option here; we don't save the type here because its 791 // particular spelling may participate in other driver choices. 792 llvm::Triple::ArchType Arch = 793 tools::darwin::getArchTypeForDarwinArchName(A->getValue()); 794 if (Arch == llvm::Triple::UnknownArch) { 795 Diag(clang::diag::err_drv_invalid_arch_name) 796 << A->getAsString(Args); 797 continue; 798 } 799 800 A->claim(); 801 if (ArchNames.insert(A->getValue())) 802 Archs.push_back(A->getValue()); 803 } 804 } 805 806 // When there is no explicit arch for this platform, make sure we still bind 807 // the architecture (to the default) so that -Xarch_ is handled correctly. 808 if (!Archs.size()) 809 Archs.push_back(Args.MakeArgString(TC.getDefaultUniversalArchName())); 810 811 // FIXME: We killed off some others but these aren't yet detected in a 812 // functional manner. If we added information to jobs about which "auxiliary" 813 // files they wrote then we could detect the conflict these cause downstream. 814 if (Archs.size() > 1) { 815 // No recovery needed, the point of this is just to prevent 816 // overwriting the same files. 817 if (const Arg *A = Args.getLastArg(options::OPT_save_temps)) 818 Diag(clang::diag::err_drv_invalid_opt_with_multiple_archs) 819 << A->getAsString(Args); 820 } 821 822 ActionList SingleActions; 823 BuildActions(TC, Args, BAInputs, SingleActions); 824 825 // Add in arch bindings for every top level action, as well as lipo and 826 // dsymutil steps if needed. 827 for (unsigned i = 0, e = SingleActions.size(); i != e; ++i) { 828 Action *Act = SingleActions[i]; 829 830 // Make sure we can lipo this kind of output. If not (and it is an actual 831 // output) then we disallow, since we can't create an output file with the 832 // right name without overwriting it. We could remove this oddity by just 833 // changing the output names to include the arch, which would also fix 834 // -save-temps. Compatibility wins for now. 835 836 if (Archs.size() > 1 && !types::canLipoType(Act->getType())) 837 Diag(clang::diag::err_drv_invalid_output_with_multiple_archs) 838 << types::getTypeName(Act->getType()); 839 840 ActionList Inputs; 841 for (unsigned i = 0, e = Archs.size(); i != e; ++i) { 842 Inputs.push_back(new BindArchAction(Act, Archs[i])); 843 if (i != 0) 844 Inputs.back()->setOwnsInputs(false); 845 } 846 847 // Lipo if necessary, we do it this way because we need to set the arch flag 848 // so that -Xarch_ gets overwritten. 849 if (Inputs.size() == 1 || Act->getType() == types::TY_Nothing) 850 Actions.append(Inputs.begin(), Inputs.end()); 851 else 852 Actions.push_back(new LipoJobAction(Inputs, Act->getType())); 853 854 // Handle debug info queries. 855 Arg *A = Args.getLastArg(options::OPT_g_Group); 856 if (A && !A->getOption().matches(options::OPT_g0) && 857 !A->getOption().matches(options::OPT_gstabs) && 858 ContainsCompileOrAssembleAction(Actions.back())) { 859 860 // Add a 'dsymutil' step if necessary, when debug info is enabled and we 861 // have a compile input. We need to run 'dsymutil' ourselves in such cases 862 // because the debug info will refer to a temporary object file which is 863 // will be removed at the end of the compilation process. 864 if (Act->getType() == types::TY_Image) { 865 ActionList Inputs; 866 Inputs.push_back(Actions.back()); 867 Actions.pop_back(); 868 Actions.push_back(new DsymutilJobAction(Inputs, types::TY_dSYM)); 869 } 870 871 // Verify the output (debug information only) if we passed '-verify'. 872 if (Args.hasArg(options::OPT_verify)) { 873 ActionList VerifyInputs; 874 VerifyInputs.push_back(Actions.back()); 875 Actions.pop_back(); 876 Actions.push_back(new VerifyJobAction(VerifyInputs, 877 types::TY_Nothing)); 878 } 879 } 880 } 881} 882 883// Construct a the list of inputs and their types. 884void Driver::BuildInputs(const ToolChain &TC, const DerivedArgList &Args, 885 InputList &Inputs) const { 886 // Track the current user specified (-x) input. We also explicitly track the 887 // argument used to set the type; we only want to claim the type when we 888 // actually use it, so we warn about unused -x arguments. 889 types::ID InputType = types::TY_Nothing; 890 Arg *InputTypeArg = 0; 891 892 for (ArgList::const_iterator it = Args.begin(), ie = Args.end(); 893 it != ie; ++it) { 894 Arg *A = *it; 895 896 if (A->getOption().getKind() == Option::InputClass) { 897 const char *Value = A->getValue(); 898 types::ID Ty = types::TY_INVALID; 899 900 // Infer the input type if necessary. 901 if (InputType == types::TY_Nothing) { 902 // If there was an explicit arg for this, claim it. 903 if (InputTypeArg) 904 InputTypeArg->claim(); 905 906 // stdin must be handled specially. 907 if (memcmp(Value, "-", 2) == 0) { 908 // If running with -E, treat as a C input (this changes the builtin 909 // macros, for example). This may be overridden by -ObjC below. 910 // 911 // Otherwise emit an error but still use a valid type to avoid 912 // spurious errors (e.g., no inputs). 913 if (!Args.hasArgNoClaim(options::OPT_E) && !CCCIsCPP) 914 Diag(clang::diag::err_drv_unknown_stdin_type); 915 Ty = types::TY_C; 916 } else { 917 // Otherwise lookup by extension. 918 // Fallback is C if invoked as C preprocessor or Object otherwise. 919 // We use a host hook here because Darwin at least has its own 920 // idea of what .s is. 921 if (const char *Ext = strrchr(Value, '.')) 922 Ty = TC.LookupTypeForExtension(Ext + 1); 923 924 if (Ty == types::TY_INVALID) { 925 if (CCCIsCPP) 926 Ty = types::TY_C; 927 else 928 Ty = types::TY_Object; 929 } 930 931 // If the driver is invoked as C++ compiler (like clang++ or c++) it 932 // should autodetect some input files as C++ for g++ compatibility. 933 if (CCCIsCXX) { 934 types::ID OldTy = Ty; 935 Ty = types::lookupCXXTypeForCType(Ty); 936 937 if (Ty != OldTy) 938 Diag(clang::diag::warn_drv_treating_input_as_cxx) 939 << getTypeName(OldTy) << getTypeName(Ty); 940 } 941 } 942 943 // -ObjC and -ObjC++ override the default language, but only for "source 944 // files". We just treat everything that isn't a linker input as a 945 // source file. 946 // 947 // FIXME: Clean this up if we move the phase sequence into the type. 948 if (Ty != types::TY_Object) { 949 if (Args.hasArg(options::OPT_ObjC)) 950 Ty = types::TY_ObjC; 951 else if (Args.hasArg(options::OPT_ObjCXX)) 952 Ty = types::TY_ObjCXX; 953 } 954 } else { 955 assert(InputTypeArg && "InputType set w/o InputTypeArg"); 956 InputTypeArg->claim(); 957 Ty = InputType; 958 } 959 960 // Check that the file exists, if enabled. 961 if (CheckInputsExist && memcmp(Value, "-", 2) != 0) { 962 SmallString<64> Path(Value); 963 if (Arg *WorkDir = Args.getLastArg(options::OPT_working_directory)) { 964 if (!llvm::sys::path::is_absolute(Path.str())) { 965 SmallString<64> Directory(WorkDir->getValue()); 966 llvm::sys::path::append(Directory, Value); 967 Path.assign(Directory); 968 } 969 } 970 971 bool exists = false; 972 if (llvm::sys::fs::exists(Path.c_str(), exists) || !exists) 973 Diag(clang::diag::err_drv_no_such_file) << Path.str(); 974 else 975 Inputs.push_back(std::make_pair(Ty, A)); 976 } else 977 Inputs.push_back(std::make_pair(Ty, A)); 978 979 } else if (A->getOption().hasFlag(options::LinkerInput)) { 980 // Just treat as object type, we could make a special type for this if 981 // necessary. 982 Inputs.push_back(std::make_pair(types::TY_Object, A)); 983 984 } else if (A->getOption().matches(options::OPT_x)) { 985 InputTypeArg = A; 986 InputType = types::lookupTypeForTypeSpecifier(A->getValue()); 987 A->claim(); 988 989 // Follow gcc behavior and treat as linker input for invalid -x 990 // options. Its not clear why we shouldn't just revert to unknown; but 991 // this isn't very important, we might as well be bug compatible. 992 if (!InputType) { 993 Diag(clang::diag::err_drv_unknown_language) << A->getValue(); 994 InputType = types::TY_Object; 995 } 996 } 997 } 998 if (CCCIsCPP && Inputs.empty()) { 999 // If called as standalone preprocessor, stdin is processed 1000 // if no other input is present. 1001 unsigned Index = Args.getBaseArgs().MakeIndex("-"); 1002 Arg *A = Opts->ParseOneArg(Args, Index); 1003 A->claim(); 1004 Inputs.push_back(std::make_pair(types::TY_C, A)); 1005 } 1006} 1007 1008void Driver::BuildActions(const ToolChain &TC, const DerivedArgList &Args, 1009 const InputList &Inputs, ActionList &Actions) const { 1010 llvm::PrettyStackTraceString CrashInfo("Building compilation actions"); 1011 1012 if (!SuppressMissingInputWarning && Inputs.empty()) { 1013 Diag(clang::diag::err_drv_no_input_files); 1014 return; 1015 } 1016 1017 Arg *FinalPhaseArg; 1018 phases::ID FinalPhase = getFinalPhase(Args, &FinalPhaseArg); 1019 1020 // Reject -Z* at the top level, these options should never have been exposed 1021 // by gcc. 1022 if (Arg *A = Args.getLastArg(options::OPT_Z_Joined)) 1023 Diag(clang::diag::err_drv_use_of_Z_option) << A->getAsString(Args); 1024 1025 // Construct the actions to perform. 1026 ActionList LinkerInputs; 1027 unsigned NumSteps = 0; 1028 for (unsigned i = 0, e = Inputs.size(); i != e; ++i) { 1029 types::ID InputType = Inputs[i].first; 1030 const Arg *InputArg = Inputs[i].second; 1031 1032 NumSteps = types::getNumCompilationPhases(InputType); 1033 assert(NumSteps && "Invalid number of steps!"); 1034 1035 // If the first step comes after the final phase we are doing as part of 1036 // this compilation, warn the user about it. 1037 phases::ID InitialPhase = types::getCompilationPhase(InputType, 0); 1038 if (InitialPhase > FinalPhase) { 1039 // Claim here to avoid the more general unused warning. 1040 InputArg->claim(); 1041 1042 // Suppress all unused style warnings with -Qunused-arguments 1043 if (Args.hasArg(options::OPT_Qunused_arguments)) 1044 continue; 1045 1046 // Special case when final phase determined by binary name, rather than 1047 // by a command-line argument with a corresponding Arg. 1048 if (CCCIsCPP) 1049 Diag(clang::diag::warn_drv_input_file_unused_by_cpp) 1050 << InputArg->getAsString(Args) 1051 << getPhaseName(InitialPhase); 1052 // Special case '-E' warning on a previously preprocessed file to make 1053 // more sense. 1054 else if (InitialPhase == phases::Compile && 1055 FinalPhase == phases::Preprocess && 1056 getPreprocessedType(InputType) == types::TY_INVALID) 1057 Diag(clang::diag::warn_drv_preprocessed_input_file_unused) 1058 << InputArg->getAsString(Args) 1059 << !!FinalPhaseArg 1060 << FinalPhaseArg ? FinalPhaseArg->getOption().getName() : ""; 1061 else 1062 Diag(clang::diag::warn_drv_input_file_unused) 1063 << InputArg->getAsString(Args) 1064 << getPhaseName(InitialPhase) 1065 << !!FinalPhaseArg 1066 << FinalPhaseArg ? FinalPhaseArg->getOption().getName() : ""; 1067 continue; 1068 } 1069 1070 // Build the pipeline for this file. 1071 OwningPtr<Action> Current(new InputAction(*InputArg, InputType)); 1072 for (unsigned i = 0; i != NumSteps; ++i) { 1073 phases::ID Phase = types::getCompilationPhase(InputType, i); 1074 1075 // We are done if this step is past what the user requested. 1076 if (Phase > FinalPhase) 1077 break; 1078 1079 // Queue linker inputs. 1080 if (Phase == phases::Link) { 1081 assert(i + 1 == NumSteps && "linking must be final compilation step."); 1082 LinkerInputs.push_back(Current.take()); 1083 break; 1084 } 1085 1086 // Some types skip the assembler phase (e.g., llvm-bc), but we can't 1087 // encode this in the steps because the intermediate type depends on 1088 // arguments. Just special case here. 1089 if (Phase == phases::Assemble && Current->getType() != types::TY_PP_Asm) 1090 continue; 1091 1092 // Otherwise construct the appropriate action. 1093 Current.reset(ConstructPhaseAction(Args, Phase, Current.take())); 1094 if (Current->getType() == types::TY_Nothing) 1095 break; 1096 } 1097 1098 // If we ended with something, add to the output list. 1099 if (Current) 1100 Actions.push_back(Current.take()); 1101 } 1102 1103 // Add a link action if necessary. 1104 if (!LinkerInputs.empty()) 1105 Actions.push_back(new LinkJobAction(LinkerInputs, types::TY_Image)); 1106 1107 // If we are linking, claim any options which are obviously only used for 1108 // compilation. 1109 if (FinalPhase == phases::Link && (NumSteps == 1)) 1110 Args.ClaimAllArgs(options::OPT_CompileOnly_Group); 1111} 1112 1113Action *Driver::ConstructPhaseAction(const ArgList &Args, phases::ID Phase, 1114 Action *Input) const { 1115 llvm::PrettyStackTraceString CrashInfo("Constructing phase actions"); 1116 // Build the appropriate action. 1117 switch (Phase) { 1118 case phases::Link: llvm_unreachable("link action invalid here."); 1119 case phases::Preprocess: { 1120 types::ID OutputTy; 1121 // -{M, MM} alter the output type. 1122 if (Args.hasArg(options::OPT_M, options::OPT_MM)) { 1123 OutputTy = types::TY_Dependencies; 1124 } else { 1125 OutputTy = Input->getType(); 1126 if (!Args.hasFlag(options::OPT_frewrite_includes, 1127 options::OPT_fno_rewrite_includes, false)) 1128 OutputTy = types::getPreprocessedType(OutputTy); 1129 assert(OutputTy != types::TY_INVALID && 1130 "Cannot preprocess this input type!"); 1131 } 1132 return new PreprocessJobAction(Input, OutputTy); 1133 } 1134 case phases::Precompile: { 1135 types::ID OutputTy = types::TY_PCH; 1136 if (Args.hasArg(options::OPT_fsyntax_only)) { 1137 // Syntax checks should not emit a PCH file 1138 OutputTy = types::TY_Nothing; 1139 } 1140 return new PrecompileJobAction(Input, OutputTy); 1141 } 1142 case phases::Compile: { 1143 if (Args.hasArg(options::OPT_fsyntax_only)) { 1144 return new CompileJobAction(Input, types::TY_Nothing); 1145 } else if (Args.hasArg(options::OPT_rewrite_objc)) { 1146 return new CompileJobAction(Input, types::TY_RewrittenObjC); 1147 } else if (Args.hasArg(options::OPT_rewrite_legacy_objc)) { 1148 return new CompileJobAction(Input, types::TY_RewrittenLegacyObjC); 1149 } else if (Args.hasArg(options::OPT__analyze, options::OPT__analyze_auto)) { 1150 return new AnalyzeJobAction(Input, types::TY_Plist); 1151 } else if (Args.hasArg(options::OPT__migrate)) { 1152 return new MigrateJobAction(Input, types::TY_Remap); 1153 } else if (Args.hasArg(options::OPT_emit_ast)) { 1154 return new CompileJobAction(Input, types::TY_AST); 1155 } else if (IsUsingLTO(Args)) { 1156 types::ID Output = 1157 Args.hasArg(options::OPT_S) ? types::TY_LTO_IR : types::TY_LTO_BC; 1158 return new CompileJobAction(Input, Output); 1159 } else { 1160 return new CompileJobAction(Input, types::TY_PP_Asm); 1161 } 1162 } 1163 case phases::Assemble: 1164 return new AssembleJobAction(Input, types::TY_Object); 1165 } 1166 1167 llvm_unreachable("invalid phase in ConstructPhaseAction"); 1168} 1169 1170bool Driver::IsUsingLTO(const ArgList &Args) const { 1171 // Check for -emit-llvm or -flto. 1172 if (Args.hasArg(options::OPT_emit_llvm) || 1173 Args.hasFlag(options::OPT_flto, options::OPT_fno_lto, false)) 1174 return true; 1175 1176 // Check for -O4. 1177 if (const Arg *A = Args.getLastArg(options::OPT_O_Group)) 1178 return A->getOption().matches(options::OPT_O4); 1179 1180 return false; 1181} 1182 1183void Driver::BuildJobs(Compilation &C) const { 1184 llvm::PrettyStackTraceString CrashInfo("Building compilation jobs"); 1185 1186 Arg *FinalOutput = C.getArgs().getLastArg(options::OPT_o); 1187 1188 // It is an error to provide a -o option if we are making multiple output 1189 // files. 1190 if (FinalOutput) { 1191 unsigned NumOutputs = 0; 1192 for (ActionList::const_iterator it = C.getActions().begin(), 1193 ie = C.getActions().end(); it != ie; ++it) 1194 if ((*it)->getType() != types::TY_Nothing) 1195 ++NumOutputs; 1196 1197 if (NumOutputs > 1) { 1198 Diag(clang::diag::err_drv_output_argument_with_multiple_files); 1199 FinalOutput = 0; 1200 } 1201 } 1202 1203 for (ActionList::const_iterator it = C.getActions().begin(), 1204 ie = C.getActions().end(); it != ie; ++it) { 1205 Action *A = *it; 1206 1207 // If we are linking an image for multiple archs then the linker wants 1208 // -arch_multiple and -final_output <final image name>. Unfortunately, this 1209 // doesn't fit in cleanly because we have to pass this information down. 1210 // 1211 // FIXME: This is a hack; find a cleaner way to integrate this into the 1212 // process. 1213 const char *LinkingOutput = 0; 1214 if (isa<LipoJobAction>(A)) { 1215 if (FinalOutput) 1216 LinkingOutput = FinalOutput->getValue(); 1217 else 1218 LinkingOutput = DefaultImageName.c_str(); 1219 } 1220 1221 InputInfo II; 1222 BuildJobsForAction(C, A, &C.getDefaultToolChain(), 1223 /*BoundArch*/0, 1224 /*AtTopLevel*/ true, 1225 /*LinkingOutput*/ LinkingOutput, 1226 II); 1227 } 1228 1229 // If the user passed -Qunused-arguments or there were errors, don't warn 1230 // about any unused arguments. 1231 if (Diags.hasErrorOccurred() || 1232 C.getArgs().hasArg(options::OPT_Qunused_arguments)) 1233 return; 1234 1235 // Claim -### here. 1236 (void) C.getArgs().hasArg(options::OPT__HASH_HASH_HASH); 1237 1238 for (ArgList::const_iterator it = C.getArgs().begin(), ie = C.getArgs().end(); 1239 it != ie; ++it) { 1240 Arg *A = *it; 1241 1242 // FIXME: It would be nice to be able to send the argument to the 1243 // DiagnosticsEngine, so that extra values, position, and so on could be 1244 // printed. 1245 if (!A->isClaimed()) { 1246 if (A->getOption().hasFlag(options::NoArgumentUnused)) 1247 continue; 1248 1249 // Suppress the warning automatically if this is just a flag, and it is an 1250 // instance of an argument we already claimed. 1251 const Option &Opt = A->getOption(); 1252 if (Opt.getKind() == Option::FlagClass) { 1253 bool DuplicateClaimed = false; 1254 1255 for (arg_iterator it = C.getArgs().filtered_begin(&Opt), 1256 ie = C.getArgs().filtered_end(); it != ie; ++it) { 1257 if ((*it)->isClaimed()) { 1258 DuplicateClaimed = true; 1259 break; 1260 } 1261 } 1262 1263 if (DuplicateClaimed) 1264 continue; 1265 } 1266 1267 Diag(clang::diag::warn_drv_unused_argument) 1268 << A->getAsString(C.getArgs()); 1269 } 1270 } 1271} 1272 1273static const Tool &SelectToolForJob(Compilation &C, const ToolChain *TC, 1274 const JobAction *JA, 1275 const ActionList *&Inputs) { 1276 const Tool *ToolForJob = 0; 1277 1278 // See if we should look for a compiler with an integrated assembler. We match 1279 // bottom up, so what we are actually looking for is an assembler job with a 1280 // compiler input. 1281 1282 if (C.getArgs().hasFlag(options::OPT_integrated_as, 1283 options::OPT_no_integrated_as, 1284 TC->IsIntegratedAssemblerDefault()) && 1285 !C.getArgs().hasArg(options::OPT_save_temps) && 1286 isa<AssembleJobAction>(JA) && 1287 Inputs->size() == 1 && isa<CompileJobAction>(*Inputs->begin())) { 1288 const Tool &Compiler = TC->SelectTool( 1289 C, cast<JobAction>(**Inputs->begin()), (*Inputs)[0]->getInputs()); 1290 if (Compiler.hasIntegratedAssembler()) { 1291 Inputs = &(*Inputs)[0]->getInputs(); 1292 ToolForJob = &Compiler; 1293 } 1294 } 1295 1296 // Otherwise use the tool for the current job. 1297 if (!ToolForJob) 1298 ToolForJob = &TC->SelectTool(C, *JA, *Inputs); 1299 1300 // See if we should use an integrated preprocessor. We do so when we have 1301 // exactly one input, since this is the only use case we care about 1302 // (irrelevant since we don't support combine yet). 1303 if (Inputs->size() == 1 && isa<PreprocessJobAction>(*Inputs->begin()) && 1304 !C.getArgs().hasArg(options::OPT_no_integrated_cpp) && 1305 !C.getArgs().hasArg(options::OPT_traditional_cpp) && 1306 !C.getArgs().hasArg(options::OPT_save_temps) && 1307 !C.getArgs().hasArg(options::OPT_rewrite_objc) && 1308 ToolForJob->hasIntegratedCPP()) 1309 Inputs = &(*Inputs)[0]->getInputs(); 1310 1311 return *ToolForJob; 1312} 1313 1314void Driver::BuildJobsForAction(Compilation &C, 1315 const Action *A, 1316 const ToolChain *TC, 1317 const char *BoundArch, 1318 bool AtTopLevel, 1319 const char *LinkingOutput, 1320 InputInfo &Result) const { 1321 llvm::PrettyStackTraceString CrashInfo("Building compilation jobs"); 1322 1323 if (const InputAction *IA = dyn_cast<InputAction>(A)) { 1324 // FIXME: It would be nice to not claim this here; maybe the old scheme of 1325 // just using Args was better? 1326 const Arg &Input = IA->getInputArg(); 1327 Input.claim(); 1328 if (Input.getOption().matches(options::OPT_INPUT)) { 1329 const char *Name = Input.getValue(); 1330 Result = InputInfo(Name, A->getType(), Name); 1331 } else 1332 Result = InputInfo(&Input, A->getType(), ""); 1333 return; 1334 } 1335 1336 if (const BindArchAction *BAA = dyn_cast<BindArchAction>(A)) { 1337 const ToolChain *TC; 1338 const char *ArchName = BAA->getArchName(); 1339 1340 if (ArchName) 1341 TC = &getToolChain(C.getArgs(), ArchName); 1342 else 1343 TC = &C.getDefaultToolChain(); 1344 1345 BuildJobsForAction(C, *BAA->begin(), TC, BAA->getArchName(), 1346 AtTopLevel, LinkingOutput, Result); 1347 return; 1348 } 1349 1350 const ActionList *Inputs = &A->getInputs(); 1351 1352 const JobAction *JA = cast<JobAction>(A); 1353 const Tool &T = SelectToolForJob(C, TC, JA, Inputs); 1354 1355 // Only use pipes when there is exactly one input. 1356 InputInfoList InputInfos; 1357 for (ActionList::const_iterator it = Inputs->begin(), ie = Inputs->end(); 1358 it != ie; ++it) { 1359 // Treat dsymutil sub-jobs as being at the top-level too, they shouldn't get 1360 // temporary output names. 1361 // 1362 // FIXME: Clean this up. 1363 bool SubJobAtTopLevel = false; 1364 if (AtTopLevel && isa<DsymutilJobAction>(A)) 1365 SubJobAtTopLevel = true; 1366 1367 // Also treat verify sub-jobs as being at the top-level. They don't 1368 // produce any output and so don't need temporary output names. 1369 if (AtTopLevel && isa<VerifyJobAction>(A)) 1370 SubJobAtTopLevel = true; 1371 1372 InputInfo II; 1373 BuildJobsForAction(C, *it, TC, BoundArch, 1374 SubJobAtTopLevel, LinkingOutput, II); 1375 InputInfos.push_back(II); 1376 } 1377 1378 // Always use the first input as the base input. 1379 const char *BaseInput = InputInfos[0].getBaseInput(); 1380 1381 // ... except dsymutil actions, which use their actual input as the base 1382 // input. 1383 if (JA->getType() == types::TY_dSYM) 1384 BaseInput = InputInfos[0].getFilename(); 1385 1386 // Determine the place to write output to, if any. 1387 if (JA->getType() == types::TY_Nothing) { 1388 Result = InputInfo(A->getType(), BaseInput); 1389 } else { 1390 Result = InputInfo(GetNamedOutputPath(C, *JA, BaseInput, AtTopLevel), 1391 A->getType(), BaseInput); 1392 } 1393 1394 if (CCCPrintBindings && !CCGenDiagnostics) { 1395 llvm::errs() << "# \"" << T.getToolChain().getTripleString() << '"' 1396 << " - \"" << T.getName() << "\", inputs: ["; 1397 for (unsigned i = 0, e = InputInfos.size(); i != e; ++i) { 1398 llvm::errs() << InputInfos[i].getAsString(); 1399 if (i + 1 != e) 1400 llvm::errs() << ", "; 1401 } 1402 llvm::errs() << "], output: " << Result.getAsString() << "\n"; 1403 } else { 1404 T.ConstructJob(C, *JA, Result, InputInfos, 1405 C.getArgsForToolChain(TC, BoundArch), LinkingOutput); 1406 } 1407} 1408 1409const char *Driver::GetNamedOutputPath(Compilation &C, 1410 const JobAction &JA, 1411 const char *BaseInput, 1412 bool AtTopLevel) const { 1413 llvm::PrettyStackTraceString CrashInfo("Computing output path"); 1414 // Output to a user requested destination? 1415 if (AtTopLevel && !isa<DsymutilJobAction>(JA) && 1416 !isa<VerifyJobAction>(JA)) { 1417 if (Arg *FinalOutput = C.getArgs().getLastArg(options::OPT_o)) 1418 return C.addResultFile(FinalOutput->getValue()); 1419 } 1420 1421 // Default to writing to stdout? 1422 if (AtTopLevel && isa<PreprocessJobAction>(JA) && !CCGenDiagnostics) 1423 return "-"; 1424 1425 // Output to a temporary file? 1426 if ((!AtTopLevel && !C.getArgs().hasArg(options::OPT_save_temps)) || 1427 CCGenDiagnostics) { 1428 StringRef Name = llvm::sys::path::filename(BaseInput); 1429 std::pair<StringRef, StringRef> Split = Name.split('.'); 1430 std::string TmpName = 1431 GetTemporaryPath(Split.first, types::getTypeTempSuffix(JA.getType())); 1432 return C.addTempFile(C.getArgs().MakeArgString(TmpName.c_str())); 1433 } 1434 1435 SmallString<128> BasePath(BaseInput); 1436 StringRef BaseName; 1437 1438 // Dsymutil actions should use the full path. 1439 if (isa<DsymutilJobAction>(JA) || isa<VerifyJobAction>(JA)) 1440 BaseName = BasePath; 1441 else 1442 BaseName = llvm::sys::path::filename(BasePath); 1443 1444 // Determine what the derived output name should be. 1445 const char *NamedOutput; 1446 if (JA.getType() == types::TY_Image) { 1447 NamedOutput = DefaultImageName.c_str(); 1448 } else { 1449 const char *Suffix = types::getTypeTempSuffix(JA.getType()); 1450 assert(Suffix && "All types used for output should have a suffix."); 1451 1452 std::string::size_type End = std::string::npos; 1453 if (!types::appendSuffixForType(JA.getType())) 1454 End = BaseName.rfind('.'); 1455 std::string Suffixed(BaseName.substr(0, End)); 1456 Suffixed += '.'; 1457 Suffixed += Suffix; 1458 NamedOutput = C.getArgs().MakeArgString(Suffixed.c_str()); 1459 } 1460 1461 // If we're saving temps and the temp file conflicts with the input file, 1462 // then avoid overwriting input file. 1463 if (!AtTopLevel && C.getArgs().hasArg(options::OPT_save_temps) && 1464 NamedOutput == BaseName) { 1465 1466 bool SameFile = false; 1467 SmallString<256> Result; 1468 llvm::sys::fs::current_path(Result); 1469 llvm::sys::path::append(Result, BaseName); 1470 llvm::sys::fs::equivalent(BaseInput, Result.c_str(), SameFile); 1471 // Must share the same path to conflict. 1472 if (SameFile) { 1473 StringRef Name = llvm::sys::path::filename(BaseInput); 1474 std::pair<StringRef, StringRef> Split = Name.split('.'); 1475 std::string TmpName = 1476 GetTemporaryPath(Split.first, types::getTypeTempSuffix(JA.getType())); 1477 return C.addTempFile(C.getArgs().MakeArgString(TmpName.c_str())); 1478 } 1479 } 1480 1481 // As an annoying special case, PCH generation doesn't strip the pathname. 1482 if (JA.getType() == types::TY_PCH) { 1483 llvm::sys::path::remove_filename(BasePath); 1484 if (BasePath.empty()) 1485 BasePath = NamedOutput; 1486 else 1487 llvm::sys::path::append(BasePath, NamedOutput); 1488 return C.addResultFile(C.getArgs().MakeArgString(BasePath.c_str())); 1489 } else { 1490 return C.addResultFile(NamedOutput); 1491 } 1492} 1493 1494std::string Driver::GetFilePath(const char *Name, const ToolChain &TC) const { 1495 // Respect a limited subset of the '-Bprefix' functionality in GCC by 1496 // attempting to use this prefix when looking for file paths. 1497 for (Driver::prefix_list::const_iterator it = PrefixDirs.begin(), 1498 ie = PrefixDirs.end(); it != ie; ++it) { 1499 std::string Dir(*it); 1500 if (Dir.empty()) 1501 continue; 1502 if (Dir[0] == '=') 1503 Dir = SysRoot + Dir.substr(1); 1504 llvm::sys::Path P(Dir); 1505 P.appendComponent(Name); 1506 bool Exists; 1507 if (!llvm::sys::fs::exists(P.str(), Exists) && Exists) 1508 return P.str(); 1509 } 1510 1511 llvm::sys::Path P(ResourceDir); 1512 P.appendComponent(Name); 1513 bool Exists; 1514 if (!llvm::sys::fs::exists(P.str(), Exists) && Exists) 1515 return P.str(); 1516 1517 const ToolChain::path_list &List = TC.getFilePaths(); 1518 for (ToolChain::path_list::const_iterator 1519 it = List.begin(), ie = List.end(); it != ie; ++it) { 1520 std::string Dir(*it); 1521 if (Dir.empty()) 1522 continue; 1523 if (Dir[0] == '=') 1524 Dir = SysRoot + Dir.substr(1); 1525 llvm::sys::Path P(Dir); 1526 P.appendComponent(Name); 1527 bool Exists; 1528 if (!llvm::sys::fs::exists(P.str(), Exists) && Exists) 1529 return P.str(); 1530 } 1531 1532 return Name; 1533} 1534 1535std::string Driver::GetProgramPath(const char *Name, 1536 const ToolChain &TC) const { 1537 // FIXME: Needs a better variable than DefaultTargetTriple 1538 std::string TargetSpecificExecutable(DefaultTargetTriple + "-" + Name); 1539 // Respect a limited subset of the '-Bprefix' functionality in GCC by 1540 // attempting to use this prefix when looking for program paths. 1541 for (Driver::prefix_list::const_iterator it = PrefixDirs.begin(), 1542 ie = PrefixDirs.end(); it != ie; ++it) { 1543 bool IsDirectory; 1544 if (!llvm::sys::fs::is_directory(*it, IsDirectory) && IsDirectory) { 1545 llvm::sys::Path P(*it); 1546 P.appendComponent(TargetSpecificExecutable); 1547 if (P.canExecute()) return P.str(); 1548 P.eraseComponent(); 1549 P.appendComponent(Name); 1550 if (P.canExecute()) return P.str(); 1551 } else { 1552 llvm::sys::Path P(*it + Name); 1553 if (P.canExecute()) return P.str(); 1554 } 1555 } 1556 1557 const ToolChain::path_list &List = TC.getProgramPaths(); 1558 for (ToolChain::path_list::const_iterator 1559 it = List.begin(), ie = List.end(); it != ie; ++it) { 1560 llvm::sys::Path P(*it); 1561 P.appendComponent(TargetSpecificExecutable); 1562 if (P.canExecute()) return P.str(); 1563 P.eraseComponent(); 1564 P.appendComponent(Name); 1565 if (P.canExecute()) return P.str(); 1566 } 1567 1568 // If all else failed, search the path. 1569 llvm::sys::Path 1570 P(llvm::sys::Program::FindProgramByName(TargetSpecificExecutable)); 1571 if (!P.empty()) 1572 return P.str(); 1573 1574 P = llvm::sys::Path(llvm::sys::Program::FindProgramByName(Name)); 1575 if (!P.empty()) 1576 return P.str(); 1577 1578 return Name; 1579} 1580 1581std::string Driver::GetTemporaryPath(StringRef Prefix, const char *Suffix) 1582 const { 1583 // FIXME: This is lame; sys::Path should provide this function (in particular, 1584 // it should know how to find the temporary files dir). 1585 std::string Error; 1586 const char *TmpDir = ::getenv("TMPDIR"); 1587 if (!TmpDir) 1588 TmpDir = ::getenv("TEMP"); 1589 if (!TmpDir) 1590 TmpDir = ::getenv("TMP"); 1591 if (!TmpDir) 1592 TmpDir = "/tmp"; 1593 llvm::sys::Path P(TmpDir); 1594 P.appendComponent(Prefix); 1595 if (P.makeUnique(false, &Error)) { 1596 Diag(clang::diag::err_unable_to_make_temp) << Error; 1597 return ""; 1598 } 1599 1600 // FIXME: Grumble, makeUnique sometimes leaves the file around!? PR3837. 1601 P.eraseFromDisk(false, 0); 1602 1603 if (Suffix) 1604 P.appendSuffix(Suffix); 1605 return P.str(); 1606} 1607 1608/// \brief Compute target triple from args. 1609/// 1610/// This routine provides the logic to compute a target triple from various 1611/// args passed to the driver and the default triple string. 1612static llvm::Triple computeTargetTriple(StringRef DefaultTargetTriple, 1613 const ArgList &Args, 1614 StringRef DarwinArchName) { 1615 // FIXME: Already done in Compilation *Driver::BuildCompilation 1616 if (const Arg *A = Args.getLastArg(options::OPT_target)) 1617 DefaultTargetTriple = A->getValue(); 1618 1619 llvm::Triple Target(llvm::Triple::normalize(DefaultTargetTriple)); 1620 1621 // Handle Darwin-specific options available here. 1622 if (Target.isOSDarwin()) { 1623 // If an explict Darwin arch name is given, that trumps all. 1624 if (!DarwinArchName.empty()) { 1625 Target.setArch( 1626 tools::darwin::getArchTypeForDarwinArchName(DarwinArchName)); 1627 return Target; 1628 } 1629 1630 // Handle the Darwin '-arch' flag. 1631 if (Arg *A = Args.getLastArg(options::OPT_arch)) { 1632 llvm::Triple::ArchType DarwinArch 1633 = tools::darwin::getArchTypeForDarwinArchName(A->getValue()); 1634 if (DarwinArch != llvm::Triple::UnknownArch) 1635 Target.setArch(DarwinArch); 1636 } 1637 } 1638 1639 // Skip further flag support on OSes which don't support '-m32' or '-m64'. 1640 if (Target.getArchName() == "tce" || 1641 Target.getOS() == llvm::Triple::AuroraUX || 1642 Target.getOS() == llvm::Triple::Minix) 1643 return Target; 1644 1645 // Handle pseudo-target flags '-m32' and '-m64'. 1646 // FIXME: Should this information be in llvm::Triple? 1647 if (Arg *A = Args.getLastArg(options::OPT_m32, options::OPT_m64)) { 1648 if (A->getOption().matches(options::OPT_m32)) { 1649 if (Target.getArch() == llvm::Triple::x86_64) 1650 Target.setArch(llvm::Triple::x86); 1651 if (Target.getArch() == llvm::Triple::ppc64) 1652 Target.setArch(llvm::Triple::ppc); 1653 } else { 1654 if (Target.getArch() == llvm::Triple::x86) 1655 Target.setArch(llvm::Triple::x86_64); 1656 if (Target.getArch() == llvm::Triple::ppc) 1657 Target.setArch(llvm::Triple::ppc64); 1658 } 1659 } 1660 1661 return Target; 1662} 1663 1664const ToolChain &Driver::getToolChain(const ArgList &Args, 1665 StringRef DarwinArchName) const { 1666 llvm::Triple Target = computeTargetTriple(DefaultTargetTriple, Args, 1667 DarwinArchName); 1668 1669 ToolChain *&TC = ToolChains[Target.str()]; 1670 if (!TC) { 1671 switch (Target.getOS()) { 1672 case llvm::Triple::AuroraUX: 1673 TC = new toolchains::AuroraUX(*this, Target, Args); 1674 break; 1675 case llvm::Triple::Darwin: 1676 case llvm::Triple::MacOSX: 1677 case llvm::Triple::IOS: 1678 if (Target.getArch() == llvm::Triple::x86 || 1679 Target.getArch() == llvm::Triple::x86_64 || 1680 Target.getArch() == llvm::Triple::arm || 1681 Target.getArch() == llvm::Triple::thumb) 1682 TC = new toolchains::DarwinClang(*this, Target); 1683 else 1684 TC = new toolchains::Darwin_Generic_GCC(*this, Target, Args); 1685 break; 1686 case llvm::Triple::DragonFly: 1687 TC = new toolchains::DragonFly(*this, Target, Args); 1688 break; 1689 case llvm::Triple::OpenBSD: 1690 TC = new toolchains::OpenBSD(*this, Target, Args); 1691 break; 1692 case llvm::Triple::Bitrig: 1693 TC = new toolchains::Bitrig(*this, Target, Args); 1694 break; 1695 case llvm::Triple::NetBSD: 1696 TC = new toolchains::NetBSD(*this, Target, Args); 1697 break; 1698 case llvm::Triple::FreeBSD: 1699 TC = new toolchains::FreeBSD(*this, Target, Args); 1700 break; 1701 case llvm::Triple::Minix: 1702 TC = new toolchains::Minix(*this, Target, Args); 1703 break; 1704 case llvm::Triple::Linux: 1705 if (Target.getArch() == llvm::Triple::hexagon) 1706 TC = new toolchains::Hexagon_TC(*this, Target); 1707 else 1708 TC = new toolchains::Linux(*this, Target, Args); 1709 break; 1710 case llvm::Triple::Solaris: 1711 TC = new toolchains::Solaris(*this, Target, Args); 1712 break; 1713 case llvm::Triple::Win32: 1714 TC = new toolchains::Windows(*this, Target); 1715 break; 1716 case llvm::Triple::MinGW32: 1717 // FIXME: We need a MinGW toolchain. Fallthrough for now. 1718 default: 1719 // TCE is an OSless target 1720 if (Target.getArchName() == "tce") { 1721 TC = new toolchains::TCEToolChain(*this, Target); 1722 break; 1723 } 1724 1725 TC = new toolchains::Generic_GCC(*this, Target, Args); 1726 break; 1727 } 1728 } 1729 return *TC; 1730} 1731 1732/// GetReleaseVersion - Parse (([0-9]+)(.([0-9]+)(.([0-9]+)?))?)? and return the 1733/// grouped values as integers. Numbers which are not provided are set to 0. 1734/// 1735/// \return True if the entire string was parsed (9.2), or all groups were 1736/// parsed (10.3.5extrastuff). 1737bool Driver::GetReleaseVersion(const char *Str, unsigned &Major, 1738 unsigned &Minor, unsigned &Micro, 1739 bool &HadExtra) { 1740 HadExtra = false; 1741 1742 Major = Minor = Micro = 0; 1743 if (*Str == '\0') 1744 return true; 1745 1746 char *End; 1747 Major = (unsigned) strtol(Str, &End, 10); 1748 if (*Str != '\0' && *End == '\0') 1749 return true; 1750 if (*End != '.') 1751 return false; 1752 1753 Str = End+1; 1754 Minor = (unsigned) strtol(Str, &End, 10); 1755 if (*Str != '\0' && *End == '\0') 1756 return true; 1757 if (*End != '.') 1758 return false; 1759 1760 Str = End+1; 1761 Micro = (unsigned) strtol(Str, &End, 10); 1762 if (*Str != '\0' && *End == '\0') 1763 return true; 1764 if (Str == End) 1765 return false; 1766 HadExtra = true; 1767 return true; 1768} 1769