1 //===--- ToolChain.cpp - Collections of tools for one platform ------------===// 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 "Tools.h" 11 #include "clang/Basic/ObjCRuntime.h" 12 #include "clang/Config/config.h" 13 #include "clang/Driver/Action.h" 14 #include "clang/Driver/Driver.h" 15 #include "clang/Driver/DriverDiagnostic.h" 16 #include "clang/Driver/Options.h" 17 #include "clang/Driver/SanitizerArgs.h" 18 #include "clang/Driver/ToolChain.h" 19 #include "llvm/ADT/SmallString.h" 20 #include "llvm/ADT/StringSwitch.h" 21 #include "llvm/Option/Arg.h" 22 #include "llvm/Option/ArgList.h" 23 #include "llvm/Option/Option.h" 24 #include "llvm/Support/ErrorHandling.h" 25 #include "llvm/Support/FileSystem.h" 26 #include "llvm/Support/TargetRegistry.h" 27 #include "llvm/Support/TargetParser.h" 28 29 using namespace clang::driver; 30 using namespace clang::driver::tools; 31 using namespace clang; 32 using namespace llvm; 33 using namespace llvm::opt; 34 35 static llvm::opt::Arg *GetRTTIArgument(const ArgList &Args) { 36 return Args.getLastArg(options::OPT_mkernel, options::OPT_fapple_kext, 37 options::OPT_fno_rtti, options::OPT_frtti); 38 } 39 40 static ToolChain::RTTIMode CalculateRTTIMode(const ArgList &Args, 41 const llvm::Triple &Triple, 42 const Arg *CachedRTTIArg) { 43 // Explicit rtti/no-rtti args 44 if (CachedRTTIArg) { 45 if (CachedRTTIArg->getOption().matches(options::OPT_frtti)) 46 return ToolChain::RM_EnabledExplicitly; 47 else 48 return ToolChain::RM_DisabledExplicitly; 49 } 50 51 // -frtti is default, except for the PS4 CPU. 52 if (!Triple.isPS4CPU()) 53 return ToolChain::RM_EnabledImplicitly; 54 55 // On the PS4, turning on c++ exceptions turns on rtti. 56 // We're assuming that, if we see -fexceptions, rtti gets turned on. 57 Arg *Exceptions = Args.getLastArgNoClaim( 58 options::OPT_fcxx_exceptions, options::OPT_fno_cxx_exceptions, 59 options::OPT_fexceptions, options::OPT_fno_exceptions); 60 if (Exceptions && 61 (Exceptions->getOption().matches(options::OPT_fexceptions) || 62 Exceptions->getOption().matches(options::OPT_fcxx_exceptions))) 63 return ToolChain::RM_EnabledImplicitly; 64 65 return ToolChain::RM_DisabledImplicitly; 66 } 67 68 ToolChain::ToolChain(const Driver &D, const llvm::Triple &T, 69 const ArgList &Args) 70 : D(D), Triple(T), Args(Args), CachedRTTIArg(GetRTTIArgument(Args)), 71 CachedRTTIMode(CalculateRTTIMode(Args, Triple, CachedRTTIArg)) { 72 if (Arg *A = Args.getLastArg(options::OPT_mthread_model)) 73 if (!isThreadModelSupported(A->getValue())) 74 D.Diag(diag::err_drv_invalid_thread_model_for_target) 75 << A->getValue() << A->getAsString(Args); 76 } 77 78 ToolChain::~ToolChain() { 79 } 80 81 vfs::FileSystem &ToolChain::getVFS() const { return getDriver().getVFS(); } 82 83 bool ToolChain::useIntegratedAs() const { 84 return Args.hasFlag(options::OPT_fintegrated_as, 85 options::OPT_fno_integrated_as, 86 IsIntegratedAssemblerDefault()); 87 } 88 89 const SanitizerArgs& ToolChain::getSanitizerArgs() const { 90 if (!SanitizerArguments.get()) 91 SanitizerArguments.reset(new SanitizerArgs(*this, Args)); 92 return *SanitizerArguments.get(); 93 } 94 95 namespace { 96 struct DriverSuffix { 97 const char *Suffix; 98 const char *ModeFlag; 99 }; 100 101 const DriverSuffix *FindDriverSuffix(StringRef ProgName) { 102 // A list of known driver suffixes. Suffixes are compared against the 103 // program name in order. If there is a match, the frontend type is updated as 104 // necessary by applying the ModeFlag. 105 static const DriverSuffix DriverSuffixes[] = { 106 {"clang", nullptr}, 107 {"clang++", "--driver-mode=g++"}, 108 {"clang-c++", "--driver-mode=g++"}, 109 {"clang-cc", nullptr}, 110 {"clang-cpp", "--driver-mode=cpp"}, 111 {"clang-g++", "--driver-mode=g++"}, 112 {"clang-gcc", nullptr}, 113 {"clang-cl", "--driver-mode=cl"}, 114 {"cc", nullptr}, 115 {"cpp", "--driver-mode=cpp"}, 116 {"cl", "--driver-mode=cl"}, 117 {"++", "--driver-mode=g++"}, 118 }; 119 120 for (size_t i = 0; i < llvm::array_lengthof(DriverSuffixes); ++i) 121 if (ProgName.endswith(DriverSuffixes[i].Suffix)) 122 return &DriverSuffixes[i]; 123 return nullptr; 124 } 125 126 /// Normalize the program name from argv[0] by stripping the file extension if 127 /// present and lower-casing the string on Windows. 128 std::string normalizeProgramName(llvm::StringRef Argv0) { 129 std::string ProgName = llvm::sys::path::stem(Argv0); 130 #ifdef LLVM_ON_WIN32 131 // Transform to lowercase for case insensitive file systems. 132 std::transform(ProgName.begin(), ProgName.end(), ProgName.begin(), ::tolower); 133 #endif 134 return ProgName; 135 } 136 137 const DriverSuffix *parseDriverSuffix(StringRef ProgName) { 138 // Try to infer frontend type and default target from the program name by 139 // comparing it against DriverSuffixes in order. 140 141 // If there is a match, the function tries to identify a target as prefix. 142 // E.g. "x86_64-linux-clang" as interpreted as suffix "clang" with target 143 // prefix "x86_64-linux". If such a target prefix is found, it may be 144 // added via -target as implicit first argument. 145 const DriverSuffix *DS = FindDriverSuffix(ProgName); 146 147 if (!DS) { 148 // Try again after stripping any trailing version number: 149 // clang++3.5 -> clang++ 150 ProgName = ProgName.rtrim("0123456789."); 151 DS = FindDriverSuffix(ProgName); 152 } 153 154 if (!DS) { 155 // Try again after stripping trailing -component. 156 // clang++-tot -> clang++ 157 ProgName = ProgName.slice(0, ProgName.rfind('-')); 158 DS = FindDriverSuffix(ProgName); 159 } 160 return DS; 161 } 162 } // anonymous namespace 163 164 std::pair<std::string, std::string> 165 ToolChain::getTargetAndModeFromProgramName(StringRef PN) { 166 std::string ProgName = normalizeProgramName(PN); 167 const DriverSuffix *DS = parseDriverSuffix(ProgName); 168 if (!DS) 169 return std::make_pair("", ""); 170 std::string ModeFlag = DS->ModeFlag == nullptr ? "" : DS->ModeFlag; 171 172 std::string::size_type LastComponent = 173 ProgName.rfind('-', ProgName.size() - strlen(DS->Suffix)); 174 if (LastComponent == std::string::npos) 175 return std::make_pair("", ModeFlag); 176 177 // Infer target from the prefix. 178 StringRef Prefix(ProgName); 179 Prefix = Prefix.slice(0, LastComponent); 180 std::string IgnoredError; 181 std::string Target; 182 if (llvm::TargetRegistry::lookupTarget(Prefix, IgnoredError)) { 183 Target = Prefix; 184 } 185 return std::make_pair(Target, ModeFlag); 186 } 187 188 StringRef ToolChain::getDefaultUniversalArchName() const { 189 // In universal driver terms, the arch name accepted by -arch isn't exactly 190 // the same as the ones that appear in the triple. Roughly speaking, this is 191 // an inverse of the darwin::getArchTypeForDarwinArchName() function, but the 192 // only interesting special case is powerpc. 193 switch (Triple.getArch()) { 194 case llvm::Triple::ppc: 195 return "ppc"; 196 case llvm::Triple::ppc64: 197 return "ppc64"; 198 case llvm::Triple::ppc64le: 199 return "ppc64le"; 200 default: 201 return Triple.getArchName(); 202 } 203 } 204 205 bool ToolChain::IsUnwindTablesDefault() const { 206 return false; 207 } 208 209 Tool *ToolChain::getClang() const { 210 if (!Clang) 211 Clang.reset(new tools::Clang(*this)); 212 return Clang.get(); 213 } 214 215 Tool *ToolChain::buildAssembler() const { 216 return new tools::ClangAs(*this); 217 } 218 219 Tool *ToolChain::buildLinker() const { 220 llvm_unreachable("Linking is not supported by this toolchain"); 221 } 222 223 Tool *ToolChain::getAssemble() const { 224 if (!Assemble) 225 Assemble.reset(buildAssembler()); 226 return Assemble.get(); 227 } 228 229 Tool *ToolChain::getClangAs() const { 230 if (!Assemble) 231 Assemble.reset(new tools::ClangAs(*this)); 232 return Assemble.get(); 233 } 234 235 Tool *ToolChain::getLink() const { 236 if (!Link) 237 Link.reset(buildLinker()); 238 return Link.get(); 239 } 240 241 Tool *ToolChain::getTool(Action::ActionClass AC) const { 242 switch (AC) { 243 case Action::AssembleJobClass: 244 return getAssemble(); 245 246 case Action::LinkJobClass: 247 return getLink(); 248 249 case Action::InputClass: 250 case Action::BindArchClass: 251 case Action::CudaDeviceClass: 252 case Action::CudaHostClass: 253 case Action::LipoJobClass: 254 case Action::DsymutilJobClass: 255 case Action::VerifyDebugInfoJobClass: 256 llvm_unreachable("Invalid tool kind."); 257 258 case Action::CompileJobClass: 259 case Action::PrecompileJobClass: 260 case Action::PreprocessJobClass: 261 case Action::AnalyzeJobClass: 262 case Action::MigrateJobClass: 263 case Action::VerifyPCHJobClass: 264 case Action::BackendJobClass: 265 return getClang(); 266 } 267 268 llvm_unreachable("Invalid tool kind."); 269 } 270 271 static StringRef getArchNameForCompilerRTLib(const ToolChain &TC, 272 const ArgList &Args) { 273 const llvm::Triple &Triple = TC.getTriple(); 274 bool IsWindows = Triple.isOSWindows(); 275 276 if (Triple.isWindowsMSVCEnvironment() && TC.getArch() == llvm::Triple::x86) 277 return "i386"; 278 279 if (TC.getArch() == llvm::Triple::arm || TC.getArch() == llvm::Triple::armeb) 280 return (arm::getARMFloatABI(TC, Args) == arm::FloatABI::Hard && !IsWindows) 281 ? "armhf" 282 : "arm"; 283 284 return TC.getArchName(); 285 } 286 287 std::string ToolChain::getCompilerRT(const ArgList &Args, StringRef Component, 288 bool Shared) const { 289 const llvm::Triple &TT = getTriple(); 290 const char *Env = TT.isAndroid() ? "-android" : ""; 291 bool IsITANMSVCWindows = 292 TT.isWindowsMSVCEnvironment() || TT.isWindowsItaniumEnvironment(); 293 294 StringRef Arch = getArchNameForCompilerRTLib(*this, Args); 295 const char *Prefix = IsITANMSVCWindows ? "" : "lib"; 296 const char *Suffix = Shared ? (Triple.isOSWindows() ? ".dll" : ".so") 297 : (IsITANMSVCWindows ? ".lib" : ".a"); 298 299 SmallString<128> Path(getDriver().ResourceDir); 300 StringRef OSLibName = Triple.isOSFreeBSD() ? "freebsd" : getOS(); 301 llvm::sys::path::append(Path, "lib", OSLibName); 302 llvm::sys::path::append(Path, Prefix + Twine("clang_rt.") + Component + "-" + 303 Arch + Env + Suffix); 304 return Path.str(); 305 } 306 307 const char *ToolChain::getCompilerRTArgString(const llvm::opt::ArgList &Args, 308 StringRef Component, 309 bool Shared) const { 310 return Args.MakeArgString(getCompilerRT(Args, Component, Shared)); 311 } 312 313 bool ToolChain::needsProfileRT(const ArgList &Args) { 314 if (Args.hasFlag(options::OPT_fprofile_arcs, options::OPT_fno_profile_arcs, 315 false) || 316 Args.hasArg(options::OPT_fprofile_generate) || 317 Args.hasArg(options::OPT_fprofile_generate_EQ) || 318 Args.hasArg(options::OPT_fprofile_instr_generate) || 319 Args.hasArg(options::OPT_fprofile_instr_generate_EQ) || 320 Args.hasArg(options::OPT_fcreate_profile) || 321 Args.hasArg(options::OPT_coverage)) 322 return true; 323 324 return false; 325 } 326 327 Tool *ToolChain::SelectTool(const JobAction &JA) const { 328 if (getDriver().ShouldUseClangCompiler(JA)) return getClang(); 329 Action::ActionClass AC = JA.getKind(); 330 if (AC == Action::AssembleJobClass && useIntegratedAs()) 331 return getClangAs(); 332 return getTool(AC); 333 } 334 335 std::string ToolChain::GetFilePath(const char *Name) const { 336 return D.GetFilePath(Name, *this); 337 } 338 339 std::string ToolChain::GetProgramPath(const char *Name) const { 340 return D.GetProgramPath(Name, *this); 341 } 342 343 std::string ToolChain::GetLinkerPath() const { 344 if (Arg *A = Args.getLastArg(options::OPT_fuse_ld_EQ)) { 345 StringRef UseLinker = A->getValue(); 346 347 if (llvm::sys::path::is_absolute(UseLinker)) { 348 // If we're passed -fuse-ld= with what looks like an absolute path, 349 // don't attempt to second-guess that. 350 if (llvm::sys::fs::exists(UseLinker)) 351 return UseLinker; 352 } else { 353 // If we're passed -fuse-ld= with no argument, or with the argument ld, 354 // then use whatever the default system linker is. 355 if (UseLinker.empty() || UseLinker == "ld") 356 return GetProgramPath("ld"); 357 358 llvm::SmallString<8> LinkerName("ld."); 359 LinkerName.append(UseLinker); 360 361 std::string LinkerPath(GetProgramPath(LinkerName.c_str())); 362 if (llvm::sys::fs::exists(LinkerPath)) 363 return LinkerPath; 364 } 365 366 getDriver().Diag(diag::err_drv_invalid_linker_name) << A->getAsString(Args); 367 return ""; 368 } 369 370 return GetProgramPath(DefaultLinker); 371 } 372 373 types::ID ToolChain::LookupTypeForExtension(const char *Ext) const { 374 return types::lookupTypeForExtension(Ext); 375 } 376 377 bool ToolChain::HasNativeLLVMSupport() const { 378 return false; 379 } 380 381 bool ToolChain::isCrossCompiling() const { 382 llvm::Triple HostTriple(LLVM_HOST_TRIPLE); 383 switch (HostTriple.getArch()) { 384 // The A32/T32/T16 instruction sets are not separate architectures in this 385 // context. 386 case llvm::Triple::arm: 387 case llvm::Triple::armeb: 388 case llvm::Triple::thumb: 389 case llvm::Triple::thumbeb: 390 return getArch() != llvm::Triple::arm && getArch() != llvm::Triple::thumb && 391 getArch() != llvm::Triple::armeb && getArch() != llvm::Triple::thumbeb; 392 default: 393 return HostTriple.getArch() != getArch(); 394 } 395 } 396 397 ObjCRuntime ToolChain::getDefaultObjCRuntime(bool isNonFragile) const { 398 return ObjCRuntime(isNonFragile ? ObjCRuntime::GNUstep : ObjCRuntime::GCC, 399 VersionTuple()); 400 } 401 402 bool ToolChain::isThreadModelSupported(const StringRef Model) const { 403 if (Model == "single") { 404 // FIXME: 'single' is only supported on ARM and WebAssembly so far. 405 return Triple.getArch() == llvm::Triple::arm || 406 Triple.getArch() == llvm::Triple::armeb || 407 Triple.getArch() == llvm::Triple::thumb || 408 Triple.getArch() == llvm::Triple::thumbeb || 409 Triple.getArch() == llvm::Triple::wasm32 || 410 Triple.getArch() == llvm::Triple::wasm64; 411 } else if (Model == "posix") 412 return true; 413 414 return false; 415 } 416 417 std::string ToolChain::ComputeLLVMTriple(const ArgList &Args, 418 types::ID InputType) const { 419 switch (getTriple().getArch()) { 420 default: 421 return getTripleString(); 422 423 case llvm::Triple::x86_64: { 424 llvm::Triple Triple = getTriple(); 425 if (!Triple.isOSBinFormatMachO()) 426 return getTripleString(); 427 428 if (Arg *A = Args.getLastArg(options::OPT_march_EQ)) { 429 // x86_64h goes in the triple. Other -march options just use the 430 // vanilla triple we already have. 431 StringRef MArch = A->getValue(); 432 if (MArch == "x86_64h") 433 Triple.setArchName(MArch); 434 } 435 return Triple.getTriple(); 436 } 437 case llvm::Triple::aarch64: { 438 llvm::Triple Triple = getTriple(); 439 if (!Triple.isOSBinFormatMachO()) 440 return getTripleString(); 441 442 // FIXME: older versions of ld64 expect the "arm64" component in the actual 443 // triple string and query it to determine whether an LTO file can be 444 // handled. Remove this when we don't care any more. 445 Triple.setArchName("arm64"); 446 return Triple.getTriple(); 447 } 448 case llvm::Triple::arm: 449 case llvm::Triple::armeb: 450 case llvm::Triple::thumb: 451 case llvm::Triple::thumbeb: { 452 // FIXME: Factor into subclasses. 453 llvm::Triple Triple = getTriple(); 454 bool IsBigEndian = getTriple().getArch() == llvm::Triple::armeb || 455 getTriple().getArch() == llvm::Triple::thumbeb; 456 457 // Handle pseudo-target flags '-mlittle-endian'/'-EL' and 458 // '-mbig-endian'/'-EB'. 459 if (Arg *A = Args.getLastArg(options::OPT_mlittle_endian, 460 options::OPT_mbig_endian)) { 461 IsBigEndian = !A->getOption().matches(options::OPT_mlittle_endian); 462 } 463 464 // Thumb2 is the default for V7 on Darwin. 465 // 466 // FIXME: Thumb should just be another -target-feaure, not in the triple. 467 StringRef MCPU, MArch; 468 if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) 469 MCPU = A->getValue(); 470 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) 471 MArch = A->getValue(); 472 std::string CPU = 473 Triple.isOSBinFormatMachO() 474 ? tools::arm::getARMCPUForMArch(MArch, Triple).str() 475 : tools::arm::getARMTargetCPU(MCPU, MArch, Triple); 476 StringRef Suffix = 477 tools::arm::getLLVMArchSuffixForARM(CPU, MArch, Triple); 478 bool IsMProfile = ARM::parseArchProfile(Suffix) == ARM::PK_M; 479 bool ThumbDefault = IsMProfile || (ARM::parseArchVersion(Suffix) == 7 && 480 getTriple().isOSBinFormatMachO()); 481 // FIXME: this is invalid for WindowsCE 482 if (getTriple().isOSWindows()) 483 ThumbDefault = true; 484 std::string ArchName; 485 if (IsBigEndian) 486 ArchName = "armeb"; 487 else 488 ArchName = "arm"; 489 490 // Assembly files should start in ARM mode, unless arch is M-profile. 491 if ((InputType != types::TY_PP_Asm && Args.hasFlag(options::OPT_mthumb, 492 options::OPT_mno_thumb, ThumbDefault)) || IsMProfile) { 493 if (IsBigEndian) 494 ArchName = "thumbeb"; 495 else 496 ArchName = "thumb"; 497 } 498 Triple.setArchName(ArchName + Suffix.str()); 499 500 return Triple.getTriple(); 501 } 502 } 503 } 504 505 std::string ToolChain::ComputeEffectiveClangTriple(const ArgList &Args, 506 types::ID InputType) const { 507 return ComputeLLVMTriple(Args, InputType); 508 } 509 510 void ToolChain::AddClangSystemIncludeArgs(const ArgList &DriverArgs, 511 ArgStringList &CC1Args) const { 512 // Each toolchain should provide the appropriate include flags. 513 } 514 515 void ToolChain::addClangTargetOptions(const ArgList &DriverArgs, 516 ArgStringList &CC1Args) const { 517 } 518 519 void ToolChain::addClangWarningOptions(ArgStringList &CC1Args) const {} 520 521 void ToolChain::addProfileRTLibs(const llvm::opt::ArgList &Args, 522 llvm::opt::ArgStringList &CmdArgs) const { 523 if (!needsProfileRT(Args)) return; 524 525 CmdArgs.push_back(getCompilerRTArgString(Args, "profile")); 526 } 527 528 ToolChain::RuntimeLibType ToolChain::GetRuntimeLibType( 529 const ArgList &Args) const { 530 if (Arg *A = Args.getLastArg(options::OPT_rtlib_EQ)) { 531 StringRef Value = A->getValue(); 532 if (Value == "compiler-rt") 533 return ToolChain::RLT_CompilerRT; 534 if (Value == "libgcc") 535 return ToolChain::RLT_Libgcc; 536 getDriver().Diag(diag::err_drv_invalid_rtlib_name) 537 << A->getAsString(Args); 538 } 539 540 return GetDefaultRuntimeLibType(); 541 } 542 543 static bool ParseCXXStdlibType(const StringRef& Name, 544 ToolChain::CXXStdlibType& Type) { 545 if (Name == "libc++") 546 Type = ToolChain::CST_Libcxx; 547 else if (Name == "libstdc++") 548 Type = ToolChain::CST_Libstdcxx; 549 else 550 return false; 551 552 return true; 553 } 554 555 ToolChain::CXXStdlibType ToolChain::GetCXXStdlibType(const ArgList &Args) const{ 556 ToolChain::CXXStdlibType Type; 557 bool HasValidType = false; 558 bool ForcePlatformDefault = false; 559 560 const Arg *A = Args.getLastArg(options::OPT_stdlib_EQ); 561 if (A) { 562 StringRef Value = A->getValue(); 563 HasValidType = ParseCXXStdlibType(Value, Type); 564 565 // Only use in tests to override CLANG_DEFAULT_CXX_STDLIB! 566 if (Value == "platform") 567 ForcePlatformDefault = true; 568 else if (!HasValidType) 569 getDriver().Diag(diag::err_drv_invalid_stdlib_name) 570 << A->getAsString(Args); 571 } 572 573 if (!HasValidType && (ForcePlatformDefault || 574 !ParseCXXStdlibType(CLANG_DEFAULT_CXX_STDLIB, Type))) 575 Type = GetDefaultCXXStdlibType(); 576 577 return Type; 578 } 579 580 /// \brief Utility function to add a system include directory to CC1 arguments. 581 /*static*/ void ToolChain::addSystemInclude(const ArgList &DriverArgs, 582 ArgStringList &CC1Args, 583 const Twine &Path) { 584 CC1Args.push_back("-internal-isystem"); 585 CC1Args.push_back(DriverArgs.MakeArgString(Path)); 586 } 587 588 /// \brief Utility function to add a system include directory with extern "C" 589 /// semantics to CC1 arguments. 590 /// 591 /// Note that this should be used rarely, and only for directories that 592 /// historically and for legacy reasons are treated as having implicit extern 593 /// "C" semantics. These semantics are *ignored* by and large today, but its 594 /// important to preserve the preprocessor changes resulting from the 595 /// classification. 596 /*static*/ void ToolChain::addExternCSystemInclude(const ArgList &DriverArgs, 597 ArgStringList &CC1Args, 598 const Twine &Path) { 599 CC1Args.push_back("-internal-externc-isystem"); 600 CC1Args.push_back(DriverArgs.MakeArgString(Path)); 601 } 602 603 void ToolChain::addExternCSystemIncludeIfExists(const ArgList &DriverArgs, 604 ArgStringList &CC1Args, 605 const Twine &Path) { 606 if (llvm::sys::fs::exists(Path)) 607 addExternCSystemInclude(DriverArgs, CC1Args, Path); 608 } 609 610 /// \brief Utility function to add a list of system include directories to CC1. 611 /*static*/ void ToolChain::addSystemIncludes(const ArgList &DriverArgs, 612 ArgStringList &CC1Args, 613 ArrayRef<StringRef> Paths) { 614 for (StringRef Path : Paths) { 615 CC1Args.push_back("-internal-isystem"); 616 CC1Args.push_back(DriverArgs.MakeArgString(Path)); 617 } 618 } 619 620 void ToolChain::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs, 621 ArgStringList &CC1Args) const { 622 // Header search paths should be handled by each of the subclasses. 623 // Historically, they have not been, and instead have been handled inside of 624 // the CC1-layer frontend. As the logic is hoisted out, this generic function 625 // will slowly stop being called. 626 // 627 // While it is being called, replicate a bit of a hack to propagate the 628 // '-stdlib=' flag down to CC1 so that it can in turn customize the C++ 629 // header search paths with it. Once all systems are overriding this 630 // function, the CC1 flag and this line can be removed. 631 DriverArgs.AddAllArgs(CC1Args, options::OPT_stdlib_EQ); 632 } 633 634 void ToolChain::AddCXXStdlibLibArgs(const ArgList &Args, 635 ArgStringList &CmdArgs) const { 636 CXXStdlibType Type = GetCXXStdlibType(Args); 637 638 switch (Type) { 639 case ToolChain::CST_Libcxx: 640 CmdArgs.push_back("-lc++"); 641 break; 642 643 case ToolChain::CST_Libstdcxx: 644 CmdArgs.push_back("-lstdc++"); 645 break; 646 } 647 } 648 649 void ToolChain::AddFilePathLibArgs(const ArgList &Args, 650 ArgStringList &CmdArgs) const { 651 for (const auto &LibPath : getFilePaths()) 652 if(LibPath.length() > 0) 653 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + LibPath)); 654 } 655 656 void ToolChain::AddCCKextLibArgs(const ArgList &Args, 657 ArgStringList &CmdArgs) const { 658 CmdArgs.push_back("-lcc_kext"); 659 } 660 661 bool ToolChain::AddFastMathRuntimeIfAvailable(const ArgList &Args, 662 ArgStringList &CmdArgs) const { 663 // Do not check for -fno-fast-math or -fno-unsafe-math when -Ofast passed 664 // (to keep the linker options consistent with gcc and clang itself). 665 if (!isOptimizationLevelFast(Args)) { 666 // Check if -ffast-math or -funsafe-math. 667 Arg *A = 668 Args.getLastArg(options::OPT_ffast_math, options::OPT_fno_fast_math, 669 options::OPT_funsafe_math_optimizations, 670 options::OPT_fno_unsafe_math_optimizations); 671 672 if (!A || A->getOption().getID() == options::OPT_fno_fast_math || 673 A->getOption().getID() == options::OPT_fno_unsafe_math_optimizations) 674 return false; 675 } 676 // If crtfastmath.o exists add it to the arguments. 677 std::string Path = GetFilePath("crtfastmath.o"); 678 if (Path == "crtfastmath.o") // Not found. 679 return false; 680 681 CmdArgs.push_back(Args.MakeArgString(Path)); 682 return true; 683 } 684 685 SanitizerMask ToolChain::getSupportedSanitizers() const { 686 // Return sanitizers which don't require runtime support and are not 687 // platform dependent. 688 using namespace SanitizerKind; 689 SanitizerMask Res = (Undefined & ~Vptr & ~Function) | (CFI & ~CFIICall) | 690 CFICastStrict | UnsignedIntegerOverflow | LocalBounds; 691 if (getTriple().getArch() == llvm::Triple::x86 || 692 getTriple().getArch() == llvm::Triple::x86_64) 693 Res |= CFIICall; 694 return Res; 695 } 696 697 void ToolChain::AddCudaIncludeArgs(const ArgList &DriverArgs, 698 ArgStringList &CC1Args) const {} 699 700 void ToolChain::AddIAMCUIncludeArgs(const ArgList &DriverArgs, 701 ArgStringList &CC1Args) const {} 702