ToolChains.cpp revision 91720917d4ea35af0f9f15eeebf0daf709c41e98
1//===--- ToolChains.cpp - ToolChain Implementations -----------------------===// 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 "ToolChains.h" 11 12#include "clang/Driver/Arg.h" 13#include "clang/Driver/ArgList.h" 14#include "clang/Driver/Compilation.h" 15#include "clang/Driver/Driver.h" 16#include "clang/Driver/DriverDiagnostic.h" 17#include "clang/Driver/ObjCRuntime.h" 18#include "clang/Driver/OptTable.h" 19#include "clang/Driver/Option.h" 20#include "clang/Driver/Options.h" 21#include "clang/Basic/Version.h" 22 23#include "llvm/ADT/SmallString.h" 24#include "llvm/ADT/StringExtras.h" 25#include "llvm/ADT/StringSwitch.h" 26#include "llvm/ADT/STLExtras.h" 27#include "llvm/Support/ErrorHandling.h" 28#include "llvm/Support/FileSystem.h" 29#include "llvm/Support/MemoryBuffer.h" 30#include "llvm/Support/raw_ostream.h" 31#include "llvm/Support/Path.h" 32#include "llvm/Support/system_error.h" 33 34#include <cstdlib> // ::getenv 35 36#include "clang/Config/config.h" // for GCC_INSTALL_PREFIX 37 38using namespace clang::driver; 39using namespace clang::driver::toolchains; 40using namespace clang; 41 42/// Darwin - Darwin tool chain for i386 and x86_64. 43 44Darwin::Darwin(const Driver &D, const llvm::Triple& Triple) 45 : ToolChain(D, Triple), TargetInitialized(false), 46 ARCRuntimeForSimulator(ARCSimulator_None), 47 LibCXXForSimulator(LibCXXSimulator_None) 48{ 49 // Compute the initial Darwin version from the triple 50 unsigned Major, Minor, Micro; 51 if (!Triple.getMacOSXVersion(Major, Minor, Micro)) 52 getDriver().Diag(diag::err_drv_invalid_darwin_version) << 53 Triple.getOSName(); 54 llvm::raw_string_ostream(MacosxVersionMin) 55 << Major << '.' << Minor << '.' << Micro; 56 57 // FIXME: DarwinVersion is only used to find GCC's libexec directory. 58 // It should be removed when we stop supporting that. 59 DarwinVersion[0] = Minor + 4; 60 DarwinVersion[1] = Micro; 61 DarwinVersion[2] = 0; 62 63 // Compute the initial iOS version from the triple 64 Triple.getiOSVersion(Major, Minor, Micro); 65 llvm::raw_string_ostream(iOSVersionMin) 66 << Major << '.' << Minor << '.' << Micro; 67} 68 69types::ID Darwin::LookupTypeForExtension(const char *Ext) const { 70 types::ID Ty = types::lookupTypeForExtension(Ext); 71 72 // Darwin always preprocesses assembly files (unless -x is used explicitly). 73 if (Ty == types::TY_PP_Asm) 74 return types::TY_Asm; 75 76 return Ty; 77} 78 79bool Darwin::HasNativeLLVMSupport() const { 80 return true; 81} 82 83bool Darwin::hasARCRuntime() const { 84 // FIXME: Remove this once there is a proper way to detect an ARC runtime 85 // for the simulator. 86 switch (ARCRuntimeForSimulator) { 87 case ARCSimulator_None: 88 break; 89 case ARCSimulator_HasARCRuntime: 90 return true; 91 case ARCSimulator_NoARCRuntime: 92 return false; 93 } 94 95 if (isTargetIPhoneOS()) 96 return !isIPhoneOSVersionLT(5); 97 else 98 return !isMacosxVersionLT(10, 7); 99} 100 101bool Darwin::hasSubscriptingRuntime() const { 102 return !isTargetIPhoneOS() && !isMacosxVersionLT(10, 8); 103} 104 105/// Darwin provides an ARC runtime starting in MacOS X 10.7 and iOS 5.0. 106void Darwin::configureObjCRuntime(ObjCRuntime &runtime) const { 107 if (runtime.getKind() != ObjCRuntime::NeXT) 108 return ToolChain::configureObjCRuntime(runtime); 109 110 runtime.HasARC = runtime.HasWeak = hasARCRuntime(); 111 runtime.HasSubscripting = hasSubscriptingRuntime(); 112 113 // So far, objc_terminate is only available in iOS 5. 114 // FIXME: do the simulator logic properly. 115 if (!ARCRuntimeForSimulator && isTargetIPhoneOS()) 116 runtime.HasTerminate = !isIPhoneOSVersionLT(5); 117 else 118 runtime.HasTerminate = false; 119} 120 121/// Darwin provides a blocks runtime starting in MacOS X 10.6 and iOS 3.2. 122bool Darwin::hasBlocksRuntime() const { 123 if (isTargetIPhoneOS()) 124 return !isIPhoneOSVersionLT(3, 2); 125 else 126 return !isMacosxVersionLT(10, 6); 127} 128 129static const char *GetArmArchForMArch(StringRef Value) { 130 return llvm::StringSwitch<const char*>(Value) 131 .Case("armv6k", "armv6") 132 .Case("armv5tej", "armv5") 133 .Case("xscale", "xscale") 134 .Case("armv4t", "armv4t") 135 .Case("armv7", "armv7") 136 .Cases("armv7a", "armv7-a", "armv7") 137 .Cases("armv7r", "armv7-r", "armv7") 138 .Cases("armv7m", "armv7-m", "armv7") 139 .Default(0); 140} 141 142static const char *GetArmArchForMCpu(StringRef Value) { 143 return llvm::StringSwitch<const char *>(Value) 144 .Cases("arm9e", "arm946e-s", "arm966e-s", "arm968e-s", "arm926ej-s","armv5") 145 .Cases("arm10e", "arm10tdmi", "armv5") 146 .Cases("arm1020t", "arm1020e", "arm1022e", "arm1026ej-s", "armv5") 147 .Case("xscale", "xscale") 148 .Cases("arm1136j-s", "arm1136jf-s", "arm1176jz-s", 149 "arm1176jzf-s", "cortex-m0", "armv6") 150 .Cases("cortex-a8", "cortex-r4", "cortex-m3", "cortex-a9", "armv7") 151 .Default(0); 152} 153 154StringRef Darwin::getDarwinArchName(const ArgList &Args) const { 155 switch (getTriple().getArch()) { 156 default: 157 return getArchName(); 158 159 case llvm::Triple::thumb: 160 case llvm::Triple::arm: { 161 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) 162 if (const char *Arch = GetArmArchForMArch(A->getValue(Args))) 163 return Arch; 164 165 if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) 166 if (const char *Arch = GetArmArchForMCpu(A->getValue(Args))) 167 return Arch; 168 169 return "arm"; 170 } 171 } 172} 173 174Darwin::~Darwin() { 175 // Free tool implementations. 176 for (llvm::DenseMap<unsigned, Tool*>::iterator 177 it = Tools.begin(), ie = Tools.end(); it != ie; ++it) 178 delete it->second; 179} 180 181std::string Darwin::ComputeEffectiveClangTriple(const ArgList &Args, 182 types::ID InputType) const { 183 llvm::Triple Triple(ComputeLLVMTriple(Args, InputType)); 184 185 // If the target isn't initialized (e.g., an unknown Darwin platform, return 186 // the default triple). 187 if (!isTargetInitialized()) 188 return Triple.getTriple(); 189 190 SmallString<16> Str; 191 Str += isTargetIPhoneOS() ? "ios" : "macosx"; 192 Str += getTargetVersion().getAsString(); 193 Triple.setOSName(Str); 194 195 return Triple.getTriple(); 196} 197 198void Generic_ELF::anchor() {} 199 200Tool &Darwin::SelectTool(const Compilation &C, const JobAction &JA, 201 const ActionList &Inputs) const { 202 Action::ActionClass Key; 203 204 if (getDriver().ShouldUseClangCompiler(C, JA, getTriple())) { 205 // Fallback to llvm-gcc for i386 kext compiles, we don't support that ABI. 206 if (Inputs.size() == 1 && 207 types::isCXX(Inputs[0]->getType()) && 208 getTriple().isOSDarwin() && 209 getTriple().getArch() == llvm::Triple::x86 && 210 (C.getArgs().getLastArg(options::OPT_fapple_kext) || 211 C.getArgs().getLastArg(options::OPT_mkernel))) 212 Key = JA.getKind(); 213 else 214 Key = Action::AnalyzeJobClass; 215 } else 216 Key = JA.getKind(); 217 218 bool UseIntegratedAs = C.getArgs().hasFlag(options::OPT_integrated_as, 219 options::OPT_no_integrated_as, 220 IsIntegratedAssemblerDefault()); 221 222 Tool *&T = Tools[Key]; 223 if (!T) { 224 switch (Key) { 225 case Action::InputClass: 226 case Action::BindArchClass: 227 llvm_unreachable("Invalid tool kind."); 228 case Action::PreprocessJobClass: 229 T = new tools::darwin::Preprocess(*this); break; 230 case Action::AnalyzeJobClass: 231 case Action::MigrateJobClass: 232 T = new tools::Clang(*this); break; 233 case Action::PrecompileJobClass: 234 case Action::CompileJobClass: 235 T = new tools::darwin::Compile(*this); break; 236 case Action::AssembleJobClass: { 237 if (UseIntegratedAs) 238 T = new tools::ClangAs(*this); 239 else 240 T = new tools::darwin::Assemble(*this); 241 break; 242 } 243 case Action::LinkJobClass: 244 T = new tools::darwin::Link(*this); break; 245 case Action::LipoJobClass: 246 T = new tools::darwin::Lipo(*this); break; 247 case Action::DsymutilJobClass: 248 T = new tools::darwin::Dsymutil(*this); break; 249 case Action::VerifyJobClass: 250 T = new tools::darwin::VerifyDebug(*this); break; 251 } 252 } 253 254 return *T; 255} 256 257 258DarwinClang::DarwinClang(const Driver &D, const llvm::Triple& Triple) 259 : Darwin(D, Triple) 260{ 261 getProgramPaths().push_back(getDriver().getInstalledDir()); 262 if (getDriver().getInstalledDir() != getDriver().Dir) 263 getProgramPaths().push_back(getDriver().Dir); 264 265 // We expect 'as', 'ld', etc. to be adjacent to our install dir. 266 getProgramPaths().push_back(getDriver().getInstalledDir()); 267 if (getDriver().getInstalledDir() != getDriver().Dir) 268 getProgramPaths().push_back(getDriver().Dir); 269 270 // For fallback, we need to know how to find the GCC cc1 executables, so we 271 // also add the GCC libexec paths. This is legacy code that can be removed 272 // once fallback is no longer useful. 273 AddGCCLibexecPath(DarwinVersion[0]); 274 AddGCCLibexecPath(DarwinVersion[0] - 2); 275 AddGCCLibexecPath(DarwinVersion[0] - 1); 276 AddGCCLibexecPath(DarwinVersion[0] + 1); 277 AddGCCLibexecPath(DarwinVersion[0] + 2); 278} 279 280void DarwinClang::AddGCCLibexecPath(unsigned darwinVersion) { 281 std::string ToolChainDir = "i686-apple-darwin"; 282 ToolChainDir += llvm::utostr(darwinVersion); 283 ToolChainDir += "/4.2.1"; 284 285 std::string Path = getDriver().Dir; 286 Path += "/../llvm-gcc-4.2/libexec/gcc/"; 287 Path += ToolChainDir; 288 getProgramPaths().push_back(Path); 289 290 Path = "/usr/llvm-gcc-4.2/libexec/gcc/"; 291 Path += ToolChainDir; 292 getProgramPaths().push_back(Path); 293} 294 295void DarwinClang::AddLinkARCArgs(const ArgList &Args, 296 ArgStringList &CmdArgs) const { 297 298 CmdArgs.push_back("-force_load"); 299 llvm::sys::Path P(getDriver().ClangExecutable); 300 P.eraseComponent(); // 'clang' 301 P.eraseComponent(); // 'bin' 302 P.appendComponent("lib"); 303 P.appendComponent("arc"); 304 P.appendComponent("libarclite_"); 305 std::string s = P.str(); 306 // Mash in the platform. 307 if (isTargetIOSSimulator()) 308 s += "iphonesimulator"; 309 else if (isTargetIPhoneOS()) 310 s += "iphoneos"; 311 // FIXME: Remove this once we depend fully on -mios-simulator-version-min. 312 else if (ARCRuntimeForSimulator != ARCSimulator_None) 313 s += "iphonesimulator"; 314 else 315 s += "macosx"; 316 s += ".a"; 317 318 CmdArgs.push_back(Args.MakeArgString(s)); 319} 320 321void DarwinClang::AddLinkRuntimeLib(const ArgList &Args, 322 ArgStringList &CmdArgs, 323 const char *DarwinStaticLib) const { 324 llvm::sys::Path P(getDriver().ResourceDir); 325 P.appendComponent("lib"); 326 P.appendComponent("darwin"); 327 P.appendComponent(DarwinStaticLib); 328 329 // For now, allow missing resource libraries to support developers who may 330 // not have compiler-rt checked out or integrated into their build. 331 bool Exists; 332 if (!llvm::sys::fs::exists(P.str(), Exists) && Exists) 333 CmdArgs.push_back(Args.MakeArgString(P.str())); 334} 335 336void DarwinClang::AddLinkRuntimeLibArgs(const ArgList &Args, 337 ArgStringList &CmdArgs) const { 338 // Darwin only supports the compiler-rt based runtime libraries. 339 switch (GetRuntimeLibType(Args)) { 340 case ToolChain::RLT_CompilerRT: 341 break; 342 default: 343 getDriver().Diag(diag::err_drv_unsupported_rtlib_for_platform) 344 << Args.getLastArg(options::OPT_rtlib_EQ)->getValue(Args) << "darwin"; 345 return; 346 } 347 348 // Darwin doesn't support real static executables, don't link any runtime 349 // libraries with -static. 350 if (Args.hasArg(options::OPT_static)) 351 return; 352 353 // Reject -static-libgcc for now, we can deal with this when and if someone 354 // cares. This is useful in situations where someone wants to statically link 355 // something like libstdc++, and needs its runtime support routines. 356 if (const Arg *A = Args.getLastArg(options::OPT_static_libgcc)) { 357 getDriver().Diag(diag::err_drv_unsupported_opt) 358 << A->getAsString(Args); 359 return; 360 } 361 362 // If we are building profile support, link that library in. 363 if (Args.hasArg(options::OPT_fprofile_arcs) || 364 Args.hasArg(options::OPT_fprofile_generate) || 365 Args.hasArg(options::OPT_fcreate_profile) || 366 Args.hasArg(options::OPT_coverage)) { 367 // Select the appropriate runtime library for the target. 368 if (isTargetIPhoneOS()) { 369 AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.profile_ios.a"); 370 } else { 371 AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.profile_osx.a"); 372 } 373 } 374 375 // Add ASAN runtime library, if required. Dynamic libraries and bundles 376 // should not be linked with the runtime library. 377 if (Args.hasFlag(options::OPT_faddress_sanitizer, 378 options::OPT_fno_address_sanitizer, false)) { 379 if (Args.hasArg(options::OPT_dynamiclib) || 380 Args.hasArg(options::OPT_bundle)) return; 381 if (isTargetIPhoneOS()) { 382 getDriver().Diag(diag::err_drv_clang_unsupported_per_platform) 383 << "-faddress-sanitizer"; 384 } else { 385 AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.asan_osx.a"); 386 387 // The ASAN runtime library requires C++ and CoreFoundation. 388 AddCXXStdlibLibArgs(Args, CmdArgs); 389 CmdArgs.push_back("-framework"); 390 CmdArgs.push_back("CoreFoundation"); 391 } 392 } 393 394 // Otherwise link libSystem, then the dynamic runtime library, and finally any 395 // target specific static runtime library. 396 CmdArgs.push_back("-lSystem"); 397 398 // Select the dynamic runtime library and the target specific static library. 399 if (isTargetIPhoneOS()) { 400 // If we are compiling as iOS / simulator, don't attempt to link libgcc_s.1, 401 // it never went into the SDK. 402 // Linking against libgcc_s.1 isn't needed for iOS 5.0+ 403 if (isIPhoneOSVersionLT(5, 0) && !isTargetIOSSimulator()) 404 CmdArgs.push_back("-lgcc_s.1"); 405 406 // We currently always need a static runtime library for iOS. 407 AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.ios.a"); 408 } else { 409 // The dynamic runtime library was merged with libSystem for 10.6 and 410 // beyond; only 10.4 and 10.5 need an additional runtime library. 411 if (isMacosxVersionLT(10, 5)) 412 CmdArgs.push_back("-lgcc_s.10.4"); 413 else if (isMacosxVersionLT(10, 6)) 414 CmdArgs.push_back("-lgcc_s.10.5"); 415 416 // For OS X, we thought we would only need a static runtime library when 417 // targeting 10.4, to provide versions of the static functions which were 418 // omitted from 10.4.dylib. 419 // 420 // Unfortunately, that turned out to not be true, because Darwin system 421 // headers can still use eprintf on i386, and it is not exported from 422 // libSystem. Therefore, we still must provide a runtime library just for 423 // the tiny tiny handful of projects that *might* use that symbol. 424 if (isMacosxVersionLT(10, 5)) { 425 AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.10.4.a"); 426 } else { 427 if (getTriple().getArch() == llvm::Triple::x86) 428 AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.eprintf.a"); 429 AddLinkRuntimeLib(Args, CmdArgs, "libclang_rt.osx.a"); 430 } 431 } 432} 433 434static inline StringRef SimulatorVersionDefineName() { 435 return "__IPHONE_OS_VERSION_MIN_REQUIRED"; 436} 437 438/// \brief Parse the simulator version define: 439/// __IPHONE_OS_VERSION_MIN_REQUIRED=([0-9])([0-9][0-9])([0-9][0-9]) 440// and return the grouped values as integers, e.g: 441// __IPHONE_OS_VERSION_MIN_REQUIRED=40201 442// will return Major=4, Minor=2, Micro=1. 443static bool GetVersionFromSimulatorDefine(StringRef define, 444 unsigned &Major, unsigned &Minor, 445 unsigned &Micro) { 446 assert(define.startswith(SimulatorVersionDefineName())); 447 StringRef name, version; 448 llvm::tie(name, version) = define.split('='); 449 if (version.empty()) 450 return false; 451 std::string verstr = version.str(); 452 char *end; 453 unsigned num = (unsigned) strtol(verstr.c_str(), &end, 10); 454 if (*end != '\0') 455 return false; 456 Major = num / 10000; 457 num = num % 10000; 458 Minor = num / 100; 459 Micro = num % 100; 460 return true; 461} 462 463void Darwin::AddDeploymentTarget(DerivedArgList &Args) const { 464 const OptTable &Opts = getDriver().getOpts(); 465 466 Arg *OSXVersion = Args.getLastArg(options::OPT_mmacosx_version_min_EQ); 467 Arg *iOSVersion = Args.getLastArg(options::OPT_miphoneos_version_min_EQ); 468 Arg *iOSSimVersion = Args.getLastArg( 469 options::OPT_mios_simulator_version_min_EQ); 470 471 // FIXME: HACK! When compiling for the simulator we don't get a 472 // '-miphoneos-version-min' to help us know whether there is an ARC runtime 473 // or not; try to parse a __IPHONE_OS_VERSION_MIN_REQUIRED 474 // define passed in command-line. 475 if (!iOSVersion && !iOSSimVersion) { 476 for (arg_iterator it = Args.filtered_begin(options::OPT_D), 477 ie = Args.filtered_end(); it != ie; ++it) { 478 StringRef define = (*it)->getValue(Args); 479 if (define.startswith(SimulatorVersionDefineName())) { 480 unsigned Major = 0, Minor = 0, Micro = 0; 481 if (GetVersionFromSimulatorDefine(define, Major, Minor, Micro) && 482 Major < 10 && Minor < 100 && Micro < 100) { 483 ARCRuntimeForSimulator = Major < 5 ? ARCSimulator_NoARCRuntime 484 : ARCSimulator_HasARCRuntime; 485 LibCXXForSimulator = Major < 5 ? LibCXXSimulator_NotAvailable 486 : LibCXXSimulator_Available; 487 } 488 break; 489 } 490 } 491 } 492 493 if (OSXVersion && (iOSVersion || iOSSimVersion)) { 494 getDriver().Diag(diag::err_drv_argument_not_allowed_with) 495 << OSXVersion->getAsString(Args) 496 << (iOSVersion ? iOSVersion : iOSSimVersion)->getAsString(Args); 497 iOSVersion = iOSSimVersion = 0; 498 } else if (iOSVersion && iOSSimVersion) { 499 getDriver().Diag(diag::err_drv_argument_not_allowed_with) 500 << iOSVersion->getAsString(Args) 501 << iOSSimVersion->getAsString(Args); 502 iOSSimVersion = 0; 503 } else if (!OSXVersion && !iOSVersion && !iOSSimVersion) { 504 // If no deployment target was specified on the command line, check for 505 // environment defines. 506 StringRef OSXTarget; 507 StringRef iOSTarget; 508 StringRef iOSSimTarget; 509 if (char *env = ::getenv("MACOSX_DEPLOYMENT_TARGET")) 510 OSXTarget = env; 511 if (char *env = ::getenv("IPHONEOS_DEPLOYMENT_TARGET")) 512 iOSTarget = env; 513 if (char *env = ::getenv("IOS_SIMULATOR_DEPLOYMENT_TARGET")) 514 iOSSimTarget = env; 515 516 // If no '-miphoneos-version-min' specified on the command line and 517 // IPHONEOS_DEPLOYMENT_TARGET is not defined, see if we can set the default 518 // based on -isysroot. 519 if (iOSTarget.empty()) { 520 if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) { 521 StringRef first, second; 522 StringRef isysroot = A->getValue(Args); 523 llvm::tie(first, second) = isysroot.split(StringRef("SDKs/iPhoneOS")); 524 if (second != "") 525 iOSTarget = second.substr(0,3); 526 } 527 } 528 529 // If no OSX or iOS target has been specified and we're compiling for armv7, 530 // go ahead as assume we're targeting iOS. 531 if (OSXTarget.empty() && iOSTarget.empty() && 532 getDarwinArchName(Args) == "armv7") 533 iOSTarget = iOSVersionMin; 534 535 // Handle conflicting deployment targets 536 // 537 // FIXME: Don't hardcode default here. 538 539 // Do not allow conflicts with the iOS simulator target. 540 if (!iOSSimTarget.empty() && (!OSXTarget.empty() || !iOSTarget.empty())) { 541 getDriver().Diag(diag::err_drv_conflicting_deployment_targets) 542 << "IOS_SIMULATOR_DEPLOYMENT_TARGET" 543 << (!OSXTarget.empty() ? "MACOSX_DEPLOYMENT_TARGET" : 544 "IPHONEOS_DEPLOYMENT_TARGET"); 545 } 546 547 // Allow conflicts among OSX and iOS for historical reasons, but choose the 548 // default platform. 549 if (!OSXTarget.empty() && !iOSTarget.empty()) { 550 if (getTriple().getArch() == llvm::Triple::arm || 551 getTriple().getArch() == llvm::Triple::thumb) 552 OSXTarget = ""; 553 else 554 iOSTarget = ""; 555 } 556 557 if (!OSXTarget.empty()) { 558 const Option *O = Opts.getOption(options::OPT_mmacosx_version_min_EQ); 559 OSXVersion = Args.MakeJoinedArg(0, O, OSXTarget); 560 Args.append(OSXVersion); 561 } else if (!iOSTarget.empty()) { 562 const Option *O = Opts.getOption(options::OPT_miphoneos_version_min_EQ); 563 iOSVersion = Args.MakeJoinedArg(0, O, iOSTarget); 564 Args.append(iOSVersion); 565 } else if (!iOSSimTarget.empty()) { 566 const Option *O = Opts.getOption( 567 options::OPT_mios_simulator_version_min_EQ); 568 iOSSimVersion = Args.MakeJoinedArg(0, O, iOSSimTarget); 569 Args.append(iOSSimVersion); 570 } else { 571 // Otherwise, assume we are targeting OS X. 572 const Option *O = Opts.getOption(options::OPT_mmacosx_version_min_EQ); 573 OSXVersion = Args.MakeJoinedArg(0, O, MacosxVersionMin); 574 Args.append(OSXVersion); 575 } 576 } 577 578 // Reject invalid architecture combinations. 579 if (iOSSimVersion && (getTriple().getArch() != llvm::Triple::x86 && 580 getTriple().getArch() != llvm::Triple::x86_64)) { 581 getDriver().Diag(diag::err_drv_invalid_arch_for_deployment_target) 582 << getTriple().getArchName() << iOSSimVersion->getAsString(Args); 583 } 584 585 // Set the tool chain target information. 586 unsigned Major, Minor, Micro; 587 bool HadExtra; 588 if (OSXVersion) { 589 assert((!iOSVersion && !iOSSimVersion) && "Unknown target platform!"); 590 if (!Driver::GetReleaseVersion(OSXVersion->getValue(Args), Major, Minor, 591 Micro, HadExtra) || HadExtra || 592 Major != 10 || Minor >= 100 || Micro >= 100) 593 getDriver().Diag(diag::err_drv_invalid_version_number) 594 << OSXVersion->getAsString(Args); 595 } else { 596 const Arg *Version = iOSVersion ? iOSVersion : iOSSimVersion; 597 assert(Version && "Unknown target platform!"); 598 if (!Driver::GetReleaseVersion(Version->getValue(Args), Major, Minor, 599 Micro, HadExtra) || HadExtra || 600 Major >= 10 || Minor >= 100 || Micro >= 100) 601 getDriver().Diag(diag::err_drv_invalid_version_number) 602 << Version->getAsString(Args); 603 } 604 605 bool IsIOSSim = bool(iOSSimVersion); 606 607 // In GCC, the simulator historically was treated as being OS X in some 608 // contexts, like determining the link logic, despite generally being called 609 // with an iOS deployment target. For compatibility, we detect the 610 // simulator as iOS + x86, and treat it differently in a few contexts. 611 if (iOSVersion && (getTriple().getArch() == llvm::Triple::x86 || 612 getTriple().getArch() == llvm::Triple::x86_64)) 613 IsIOSSim = true; 614 615 setTarget(/*IsIPhoneOS=*/ !OSXVersion, Major, Minor, Micro, IsIOSSim); 616} 617 618void DarwinClang::AddCXXStdlibLibArgs(const ArgList &Args, 619 ArgStringList &CmdArgs) const { 620 CXXStdlibType Type = GetCXXStdlibType(Args); 621 622 switch (Type) { 623 case ToolChain::CST_Libcxx: 624 CmdArgs.push_back("-lc++"); 625 break; 626 627 case ToolChain::CST_Libstdcxx: { 628 // Unfortunately, -lstdc++ doesn't always exist in the standard search path; 629 // it was previously found in the gcc lib dir. However, for all the Darwin 630 // platforms we care about it was -lstdc++.6, so we search for that 631 // explicitly if we can't see an obvious -lstdc++ candidate. 632 633 // Check in the sysroot first. 634 bool Exists; 635 if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) { 636 llvm::sys::Path P(A->getValue(Args)); 637 P.appendComponent("usr"); 638 P.appendComponent("lib"); 639 P.appendComponent("libstdc++.dylib"); 640 641 if (llvm::sys::fs::exists(P.str(), Exists) || !Exists) { 642 P.eraseComponent(); 643 P.appendComponent("libstdc++.6.dylib"); 644 if (!llvm::sys::fs::exists(P.str(), Exists) && Exists) { 645 CmdArgs.push_back(Args.MakeArgString(P.str())); 646 return; 647 } 648 } 649 } 650 651 // Otherwise, look in the root. 652 // FIXME: This should be removed someday when we don't have to care about 653 // 10.6 and earlier, where /usr/lib/libstdc++.dylib does not exist. 654 if ((llvm::sys::fs::exists("/usr/lib/libstdc++.dylib", Exists) || !Exists)&& 655 (!llvm::sys::fs::exists("/usr/lib/libstdc++.6.dylib", Exists) && Exists)){ 656 CmdArgs.push_back("/usr/lib/libstdc++.6.dylib"); 657 return; 658 } 659 660 // Otherwise, let the linker search. 661 CmdArgs.push_back("-lstdc++"); 662 break; 663 } 664 } 665} 666 667void DarwinClang::AddCCKextLibArgs(const ArgList &Args, 668 ArgStringList &CmdArgs) const { 669 670 // For Darwin platforms, use the compiler-rt-based support library 671 // instead of the gcc-provided one (which is also incidentally 672 // only present in the gcc lib dir, which makes it hard to find). 673 674 llvm::sys::Path P(getDriver().ResourceDir); 675 P.appendComponent("lib"); 676 P.appendComponent("darwin"); 677 P.appendComponent("libclang_rt.cc_kext.a"); 678 679 // For now, allow missing resource libraries to support developers who may 680 // not have compiler-rt checked out or integrated into their build. 681 bool Exists; 682 if (!llvm::sys::fs::exists(P.str(), Exists) && Exists) 683 CmdArgs.push_back(Args.MakeArgString(P.str())); 684} 685 686DerivedArgList *Darwin::TranslateArgs(const DerivedArgList &Args, 687 const char *BoundArch) const { 688 DerivedArgList *DAL = new DerivedArgList(Args.getBaseArgs()); 689 const OptTable &Opts = getDriver().getOpts(); 690 691 // FIXME: We really want to get out of the tool chain level argument 692 // translation business, as it makes the driver functionality much 693 // more opaque. For now, we follow gcc closely solely for the 694 // purpose of easily achieving feature parity & testability. Once we 695 // have something that works, we should reevaluate each translation 696 // and try to push it down into tool specific logic. 697 698 for (ArgList::const_iterator it = Args.begin(), 699 ie = Args.end(); it != ie; ++it) { 700 Arg *A = *it; 701 702 if (A->getOption().matches(options::OPT_Xarch__)) { 703 // Skip this argument unless the architecture matches either the toolchain 704 // triple arch, or the arch being bound. 705 // 706 // FIXME: Canonicalize name. 707 StringRef XarchArch = A->getValue(Args, 0); 708 if (!(XarchArch == getArchName() || 709 (BoundArch && XarchArch == BoundArch))) 710 continue; 711 712 Arg *OriginalArg = A; 713 unsigned Index = Args.getBaseArgs().MakeIndex(A->getValue(Args, 1)); 714 unsigned Prev = Index; 715 Arg *XarchArg = Opts.ParseOneArg(Args, Index); 716 717 // If the argument parsing failed or more than one argument was 718 // consumed, the -Xarch_ argument's parameter tried to consume 719 // extra arguments. Emit an error and ignore. 720 // 721 // We also want to disallow any options which would alter the 722 // driver behavior; that isn't going to work in our model. We 723 // use isDriverOption() as an approximation, although things 724 // like -O4 are going to slip through. 725 if (!XarchArg || Index > Prev + 1) { 726 getDriver().Diag(diag::err_drv_invalid_Xarch_argument_with_args) 727 << A->getAsString(Args); 728 continue; 729 } else if (XarchArg->getOption().isDriverOption()) { 730 getDriver().Diag(diag::err_drv_invalid_Xarch_argument_isdriver) 731 << A->getAsString(Args); 732 continue; 733 } 734 735 XarchArg->setBaseArg(A); 736 A = XarchArg; 737 738 DAL->AddSynthesizedArg(A); 739 740 // Linker input arguments require custom handling. The problem is that we 741 // have already constructed the phase actions, so we can not treat them as 742 // "input arguments". 743 if (A->getOption().isLinkerInput()) { 744 // Convert the argument into individual Zlinker_input_args. 745 for (unsigned i = 0, e = A->getNumValues(); i != e; ++i) { 746 DAL->AddSeparateArg(OriginalArg, 747 Opts.getOption(options::OPT_Zlinker_input), 748 A->getValue(Args, i)); 749 750 } 751 continue; 752 } 753 } 754 755 // Sob. These is strictly gcc compatible for the time being. Apple 756 // gcc translates options twice, which means that self-expanding 757 // options add duplicates. 758 switch ((options::ID) A->getOption().getID()) { 759 default: 760 DAL->append(A); 761 break; 762 763 case options::OPT_mkernel: 764 case options::OPT_fapple_kext: 765 DAL->append(A); 766 DAL->AddFlagArg(A, Opts.getOption(options::OPT_static)); 767 break; 768 769 case options::OPT_dependency_file: 770 DAL->AddSeparateArg(A, Opts.getOption(options::OPT_MF), 771 A->getValue(Args)); 772 break; 773 774 case options::OPT_gfull: 775 DAL->AddFlagArg(A, Opts.getOption(options::OPT_g_Flag)); 776 DAL->AddFlagArg(A, 777 Opts.getOption(options::OPT_fno_eliminate_unused_debug_symbols)); 778 break; 779 780 case options::OPT_gused: 781 DAL->AddFlagArg(A, Opts.getOption(options::OPT_g_Flag)); 782 DAL->AddFlagArg(A, 783 Opts.getOption(options::OPT_feliminate_unused_debug_symbols)); 784 break; 785 786 case options::OPT_shared: 787 DAL->AddFlagArg(A, Opts.getOption(options::OPT_dynamiclib)); 788 break; 789 790 case options::OPT_fconstant_cfstrings: 791 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mconstant_cfstrings)); 792 break; 793 794 case options::OPT_fno_constant_cfstrings: 795 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mno_constant_cfstrings)); 796 break; 797 798 case options::OPT_Wnonportable_cfstrings: 799 DAL->AddFlagArg(A, 800 Opts.getOption(options::OPT_mwarn_nonportable_cfstrings)); 801 break; 802 803 case options::OPT_Wno_nonportable_cfstrings: 804 DAL->AddFlagArg(A, 805 Opts.getOption(options::OPT_mno_warn_nonportable_cfstrings)); 806 break; 807 808 case options::OPT_fpascal_strings: 809 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mpascal_strings)); 810 break; 811 812 case options::OPT_fno_pascal_strings: 813 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mno_pascal_strings)); 814 break; 815 } 816 } 817 818 if (getTriple().getArch() == llvm::Triple::x86 || 819 getTriple().getArch() == llvm::Triple::x86_64) 820 if (!Args.hasArgNoClaim(options::OPT_mtune_EQ)) 821 DAL->AddJoinedArg(0, Opts.getOption(options::OPT_mtune_EQ), "core2"); 822 823 // Add the arch options based on the particular spelling of -arch, to match 824 // how the driver driver works. 825 if (BoundArch) { 826 StringRef Name = BoundArch; 827 const Option *MCpu = Opts.getOption(options::OPT_mcpu_EQ); 828 const Option *MArch = Opts.getOption(options::OPT_march_EQ); 829 830 // This code must be kept in sync with LLVM's getArchTypeForDarwinArch, 831 // which defines the list of which architectures we accept. 832 if (Name == "ppc") 833 ; 834 else if (Name == "ppc601") 835 DAL->AddJoinedArg(0, MCpu, "601"); 836 else if (Name == "ppc603") 837 DAL->AddJoinedArg(0, MCpu, "603"); 838 else if (Name == "ppc604") 839 DAL->AddJoinedArg(0, MCpu, "604"); 840 else if (Name == "ppc604e") 841 DAL->AddJoinedArg(0, MCpu, "604e"); 842 else if (Name == "ppc750") 843 DAL->AddJoinedArg(0, MCpu, "750"); 844 else if (Name == "ppc7400") 845 DAL->AddJoinedArg(0, MCpu, "7400"); 846 else if (Name == "ppc7450") 847 DAL->AddJoinedArg(0, MCpu, "7450"); 848 else if (Name == "ppc970") 849 DAL->AddJoinedArg(0, MCpu, "970"); 850 851 else if (Name == "ppc64") 852 DAL->AddFlagArg(0, Opts.getOption(options::OPT_m64)); 853 854 else if (Name == "i386") 855 ; 856 else if (Name == "i486") 857 DAL->AddJoinedArg(0, MArch, "i486"); 858 else if (Name == "i586") 859 DAL->AddJoinedArg(0, MArch, "i586"); 860 else if (Name == "i686") 861 DAL->AddJoinedArg(0, MArch, "i686"); 862 else if (Name == "pentium") 863 DAL->AddJoinedArg(0, MArch, "pentium"); 864 else if (Name == "pentium2") 865 DAL->AddJoinedArg(0, MArch, "pentium2"); 866 else if (Name == "pentpro") 867 DAL->AddJoinedArg(0, MArch, "pentiumpro"); 868 else if (Name == "pentIIm3") 869 DAL->AddJoinedArg(0, MArch, "pentium2"); 870 871 else if (Name == "x86_64") 872 DAL->AddFlagArg(0, Opts.getOption(options::OPT_m64)); 873 874 else if (Name == "arm") 875 DAL->AddJoinedArg(0, MArch, "armv4t"); 876 else if (Name == "armv4t") 877 DAL->AddJoinedArg(0, MArch, "armv4t"); 878 else if (Name == "armv5") 879 DAL->AddJoinedArg(0, MArch, "armv5tej"); 880 else if (Name == "xscale") 881 DAL->AddJoinedArg(0, MArch, "xscale"); 882 else if (Name == "armv6") 883 DAL->AddJoinedArg(0, MArch, "armv6k"); 884 else if (Name == "armv7") 885 DAL->AddJoinedArg(0, MArch, "armv7a"); 886 887 else 888 llvm_unreachable("invalid Darwin arch"); 889 } 890 891 // Add an explicit version min argument for the deployment target. We do this 892 // after argument translation because -Xarch_ arguments may add a version min 893 // argument. 894 if (BoundArch) 895 AddDeploymentTarget(*DAL); 896 897 // Validate the C++ standard library choice. 898 CXXStdlibType Type = GetCXXStdlibType(*DAL); 899 if (Type == ToolChain::CST_Libcxx) { 900 switch (LibCXXForSimulator) { 901 case LibCXXSimulator_None: 902 // Handle non-simulator cases. 903 if (isTargetIPhoneOS()) { 904 if (isIPhoneOSVersionLT(5, 0)) { 905 getDriver().Diag(clang::diag::err_drv_invalid_libcxx_deployment) 906 << "iOS 5.0"; 907 } 908 } 909 break; 910 case LibCXXSimulator_NotAvailable: 911 getDriver().Diag(clang::diag::err_drv_invalid_libcxx_deployment) 912 << "iOS 5.0"; 913 break; 914 case LibCXXSimulator_Available: 915 break; 916 } 917 } 918 919 return DAL; 920} 921 922bool Darwin::IsUnwindTablesDefault() const { 923 // FIXME: Gross; we should probably have some separate target 924 // definition, possibly even reusing the one in clang. 925 return getArchName() == "x86_64"; 926} 927 928bool Darwin::UseDwarfDebugFlags() const { 929 if (const char *S = ::getenv("RC_DEBUG_OPTIONS")) 930 return S[0] != '\0'; 931 return false; 932} 933 934bool Darwin::UseSjLjExceptions() const { 935 // Darwin uses SjLj exceptions on ARM. 936 return (getTriple().getArch() == llvm::Triple::arm || 937 getTriple().getArch() == llvm::Triple::thumb); 938} 939 940const char *Darwin::GetDefaultRelocationModel() const { 941 return "pic"; 942} 943 944const char *Darwin::GetForcedPicModel() const { 945 if (getArchName() == "x86_64") 946 return "pic"; 947 return 0; 948} 949 950bool Darwin::SupportsProfiling() const { 951 // Profiling instrumentation is only supported on x86. 952 return getArchName() == "i386" || getArchName() == "x86_64"; 953} 954 955bool Darwin::SupportsObjCGC() const { 956 // Garbage collection is supported everywhere except on iPhone OS. 957 return !isTargetIPhoneOS(); 958} 959 960bool Darwin::SupportsObjCARC() const { 961 return isTargetIPhoneOS() || !isMacosxVersionLT(10, 6); 962} 963 964std::string 965Darwin_Generic_GCC::ComputeEffectiveClangTriple(const ArgList &Args, 966 types::ID InputType) const { 967 return ComputeLLVMTriple(Args, InputType); 968} 969 970/// Generic_GCC - A tool chain using the 'gcc' command to perform 971/// all subcommands; this relies on gcc translating the majority of 972/// command line options. 973 974/// \brief Parse a GCCVersion object out of a string of text. 975/// 976/// This is the primary means of forming GCCVersion objects. 977/*static*/ 978Generic_GCC::GCCVersion Linux::GCCVersion::Parse(StringRef VersionText) { 979 const GCCVersion BadVersion = { VersionText.str(), -1, -1, -1, "" }; 980 std::pair<StringRef, StringRef> First = VersionText.split('.'); 981 std::pair<StringRef, StringRef> Second = First.second.split('.'); 982 983 GCCVersion GoodVersion = { VersionText.str(), -1, -1, -1, "" }; 984 if (First.first.getAsInteger(10, GoodVersion.Major) || 985 GoodVersion.Major < 0) 986 return BadVersion; 987 if (Second.first.getAsInteger(10, GoodVersion.Minor) || 988 GoodVersion.Minor < 0) 989 return BadVersion; 990 991 // First look for a number prefix and parse that if present. Otherwise just 992 // stash the entire patch string in the suffix, and leave the number 993 // unspecified. This covers versions strings such as: 994 // 4.4 995 // 4.4.0 996 // 4.4.x 997 // 4.4.2-rc4 998 // 4.4.x-patched 999 // And retains any patch number it finds. 1000 StringRef PatchText = GoodVersion.PatchSuffix = Second.second.str(); 1001 if (!PatchText.empty()) { 1002 if (unsigned EndNumber = PatchText.find_first_not_of("0123456789")) { 1003 // Try to parse the number and any suffix. 1004 if (PatchText.slice(0, EndNumber).getAsInteger(10, GoodVersion.Patch) || 1005 GoodVersion.Patch < 0) 1006 return BadVersion; 1007 GoodVersion.PatchSuffix = PatchText.substr(EndNumber).str(); 1008 } 1009 } 1010 1011 return GoodVersion; 1012} 1013 1014/// \brief Less-than for GCCVersion, implementing a Strict Weak Ordering. 1015bool Generic_GCC::GCCVersion::operator<(const GCCVersion &RHS) const { 1016 if (Major < RHS.Major) return true; if (Major > RHS.Major) return false; 1017 if (Minor < RHS.Minor) return true; if (Minor > RHS.Minor) return false; 1018 1019 // Note that we rank versions with *no* patch specified is better than ones 1020 // hard-coding a patch version. Thus if the RHS has no patch, it always 1021 // wins, and the LHS only wins if it has no patch and the RHS does have 1022 // a patch. 1023 if (RHS.Patch == -1) return true; if (Patch == -1) return false; 1024 if (Patch < RHS.Patch) return true; if (Patch > RHS.Patch) return false; 1025 if (PatchSuffix == RHS.PatchSuffix) return false; 1026 1027 // Finally, between completely tied version numbers, the version with the 1028 // suffix loses as we prefer full releases. 1029 if (RHS.PatchSuffix.empty()) return true; 1030 return false; 1031} 1032 1033static StringRef getGCCToolchainDir(const ArgList &Args) { 1034 const Arg *A = Args.getLastArg(options::OPT_gcc_toolchain); 1035 if (A) 1036 return A->getValue(Args); 1037 return GCC_INSTALL_PREFIX; 1038} 1039 1040/// \brief Construct a GCCInstallationDetector from the driver. 1041/// 1042/// This performs all of the autodetection and sets up the various paths. 1043/// Once constructed, a GCCInstallationDetector is essentially immutable. 1044/// 1045/// FIXME: We shouldn't need an explicit TargetTriple parameter here, and 1046/// should instead pull the target out of the driver. This is currently 1047/// necessary because the driver doesn't store the final version of the target 1048/// triple. 1049Generic_GCC::GCCInstallationDetector::GCCInstallationDetector( 1050 const Driver &D, 1051 const llvm::Triple &TargetTriple, 1052 const ArgList &Args) 1053 : IsValid(false) { 1054 llvm::Triple MultiarchTriple 1055 = TargetTriple.isArch32Bit() ? TargetTriple.get64BitArchVariant() 1056 : TargetTriple.get32BitArchVariant(); 1057 llvm::Triple::ArchType TargetArch = TargetTriple.getArch(); 1058 // The library directories which may contain GCC installations. 1059 SmallVector<StringRef, 4> CandidateLibDirs, CandidateMultiarchLibDirs; 1060 // The compatible GCC triples for this particular architecture. 1061 SmallVector<StringRef, 10> CandidateTripleAliases; 1062 SmallVector<StringRef, 10> CandidateMultiarchTripleAliases; 1063 CollectLibDirsAndTriples(TargetTriple, MultiarchTriple, CandidateLibDirs, 1064 CandidateTripleAliases, 1065 CandidateMultiarchLibDirs, 1066 CandidateMultiarchTripleAliases); 1067 1068 // Compute the set of prefixes for our search. 1069 SmallVector<std::string, 8> Prefixes(D.PrefixDirs.begin(), 1070 D.PrefixDirs.end()); 1071 1072 StringRef GCCToolchainDir = getGCCToolchainDir(Args); 1073 if (GCCToolchainDir != "") { 1074 if (GCCToolchainDir.back() == '/') 1075 GCCToolchainDir = GCCToolchainDir.drop_back(); // remove the / 1076 1077 Prefixes.push_back(GCCToolchainDir); 1078 } else { 1079 Prefixes.push_back(D.SysRoot); 1080 Prefixes.push_back(D.SysRoot + "/usr"); 1081 Prefixes.push_back(D.InstalledDir + "/.."); 1082 } 1083 1084 // Loop over the various components which exist and select the best GCC 1085 // installation available. GCC installs are ranked by version number. 1086 Version = GCCVersion::Parse("0.0.0"); 1087 for (unsigned i = 0, ie = Prefixes.size(); i < ie; ++i) { 1088 if (!llvm::sys::fs::exists(Prefixes[i])) 1089 continue; 1090 for (unsigned j = 0, je = CandidateLibDirs.size(); j < je; ++j) { 1091 const std::string LibDir = Prefixes[i] + CandidateLibDirs[j].str(); 1092 if (!llvm::sys::fs::exists(LibDir)) 1093 continue; 1094 for (unsigned k = 0, ke = CandidateTripleAliases.size(); k < ke; ++k) 1095 ScanLibDirForGCCTriple(TargetArch, LibDir, CandidateTripleAliases[k]); 1096 } 1097 for (unsigned j = 0, je = CandidateMultiarchLibDirs.size(); j < je; ++j) { 1098 const std::string LibDir 1099 = Prefixes[i] + CandidateMultiarchLibDirs[j].str(); 1100 if (!llvm::sys::fs::exists(LibDir)) 1101 continue; 1102 for (unsigned k = 0, ke = CandidateMultiarchTripleAliases.size(); k < ke; 1103 ++k) 1104 ScanLibDirForGCCTriple(TargetArch, LibDir, 1105 CandidateMultiarchTripleAliases[k], 1106 /*NeedsMultiarchSuffix=*/true); 1107 } 1108 } 1109} 1110 1111/*static*/ void Generic_GCC::GCCInstallationDetector::CollectLibDirsAndTriples( 1112 const llvm::Triple &TargetTriple, 1113 const llvm::Triple &MultiarchTriple, 1114 SmallVectorImpl<StringRef> &LibDirs, 1115 SmallVectorImpl<StringRef> &TripleAliases, 1116 SmallVectorImpl<StringRef> &MultiarchLibDirs, 1117 SmallVectorImpl<StringRef> &MultiarchTripleAliases) { 1118 // Declare a bunch of static data sets that we'll select between below. These 1119 // are specifically designed to always refer to string literals to avoid any 1120 // lifetime or initialization issues. 1121 static const char *const ARMLibDirs[] = { "/lib" }; 1122 static const char *const ARMTriples[] = { 1123 "arm-linux-gnueabi", 1124 "arm-linux-androideabi" 1125 }; 1126 1127 static const char *const X86_64LibDirs[] = { "/lib64", "/lib" }; 1128 static const char *const X86_64Triples[] = { 1129 "x86_64-linux-gnu", 1130 "x86_64-unknown-linux-gnu", 1131 "x86_64-pc-linux-gnu", 1132 "x86_64-redhat-linux6E", 1133 "x86_64-redhat-linux", 1134 "x86_64-suse-linux", 1135 "x86_64-manbo-linux-gnu", 1136 "x86_64-linux-gnu", 1137 "x86_64-slackware-linux" 1138 }; 1139 static const char *const X86LibDirs[] = { "/lib32", "/lib" }; 1140 static const char *const X86Triples[] = { 1141 "i686-linux-gnu", 1142 "i686-pc-linux-gnu", 1143 "i486-linux-gnu", 1144 "i386-linux-gnu", 1145 "i686-redhat-linux", 1146 "i586-redhat-linux", 1147 "i386-redhat-linux", 1148 "i586-suse-linux", 1149 "i486-slackware-linux", 1150 "i686-montavista-linux" 1151 }; 1152 1153 static const char *const MIPSLibDirs[] = { "/lib" }; 1154 static const char *const MIPSTriples[] = { "mips-linux-gnu" }; 1155 static const char *const MIPSELLibDirs[] = { "/lib" }; 1156 static const char *const MIPSELTriples[] = { "mipsel-linux-gnu" }; 1157 1158 static const char *const MIPS64LibDirs[] = { "/lib64", "/lib" }; 1159 static const char *const MIPS64Triples[] = { "mips64-linux-gnu" }; 1160 static const char *const MIPS64ELLibDirs[] = { "/lib64", "/lib" }; 1161 static const char *const MIPS64ELTriples[] = { "mips64el-linux-gnu" }; 1162 1163 static const char *const PPCLibDirs[] = { "/lib32", "/lib" }; 1164 static const char *const PPCTriples[] = { 1165 "powerpc-linux-gnu", 1166 "powerpc-unknown-linux-gnu", 1167 "powerpc-suse-linux", 1168 "powerpc-montavista-linuxspe" 1169 }; 1170 static const char *const PPC64LibDirs[] = { "/lib64", "/lib" }; 1171 static const char *const PPC64Triples[] = { 1172 "powerpc64-linux-gnu", 1173 "powerpc64-unknown-linux-gnu", 1174 "powerpc64-suse-linux", 1175 "ppc64-redhat-linux" 1176 }; 1177 1178 switch (TargetTriple.getArch()) { 1179 case llvm::Triple::arm: 1180 case llvm::Triple::thumb: 1181 LibDirs.append(ARMLibDirs, ARMLibDirs + llvm::array_lengthof(ARMLibDirs)); 1182 TripleAliases.append( 1183 ARMTriples, ARMTriples + llvm::array_lengthof(ARMTriples)); 1184 break; 1185 case llvm::Triple::x86_64: 1186 LibDirs.append( 1187 X86_64LibDirs, X86_64LibDirs + llvm::array_lengthof(X86_64LibDirs)); 1188 TripleAliases.append( 1189 X86_64Triples, X86_64Triples + llvm::array_lengthof(X86_64Triples)); 1190 MultiarchLibDirs.append( 1191 X86LibDirs, X86LibDirs + llvm::array_lengthof(X86LibDirs)); 1192 MultiarchTripleAliases.append( 1193 X86Triples, X86Triples + llvm::array_lengthof(X86Triples)); 1194 break; 1195 case llvm::Triple::x86: 1196 LibDirs.append(X86LibDirs, X86LibDirs + llvm::array_lengthof(X86LibDirs)); 1197 TripleAliases.append( 1198 X86Triples, X86Triples + llvm::array_lengthof(X86Triples)); 1199 MultiarchLibDirs.append( 1200 X86_64LibDirs, X86_64LibDirs + llvm::array_lengthof(X86_64LibDirs)); 1201 MultiarchTripleAliases.append( 1202 X86_64Triples, X86_64Triples + llvm::array_lengthof(X86_64Triples)); 1203 break; 1204 case llvm::Triple::mips: 1205 LibDirs.append( 1206 MIPSLibDirs, MIPSLibDirs + llvm::array_lengthof(MIPSLibDirs)); 1207 TripleAliases.append( 1208 MIPSTriples, MIPSTriples + llvm::array_lengthof(MIPSTriples)); 1209 MultiarchLibDirs.append( 1210 MIPS64LibDirs, MIPS64LibDirs + llvm::array_lengthof(MIPS64LibDirs)); 1211 MultiarchTripleAliases.append( 1212 MIPS64Triples, MIPS64Triples + llvm::array_lengthof(MIPS64Triples)); 1213 break; 1214 case llvm::Triple::mipsel: 1215 LibDirs.append( 1216 MIPSELLibDirs, MIPSELLibDirs + llvm::array_lengthof(MIPSELLibDirs)); 1217 TripleAliases.append( 1218 MIPSELTriples, MIPSELTriples + llvm::array_lengthof(MIPSELTriples)); 1219 MultiarchLibDirs.append( 1220 MIPS64ELLibDirs, MIPS64ELLibDirs + llvm::array_lengthof(MIPS64ELLibDirs)); 1221 MultiarchTripleAliases.append( 1222 MIPS64ELTriples, MIPS64ELTriples + llvm::array_lengthof(MIPS64ELTriples)); 1223 break; 1224 case llvm::Triple::mips64: 1225 LibDirs.append( 1226 MIPS64LibDirs, MIPS64LibDirs + llvm::array_lengthof(MIPS64LibDirs)); 1227 TripleAliases.append( 1228 MIPS64Triples, MIPS64Triples + llvm::array_lengthof(MIPS64Triples)); 1229 MultiarchLibDirs.append( 1230 MIPSLibDirs, MIPSLibDirs + llvm::array_lengthof(MIPSLibDirs)); 1231 MultiarchTripleAliases.append( 1232 MIPSTriples, MIPSTriples + llvm::array_lengthof(MIPSTriples)); 1233 break; 1234 case llvm::Triple::mips64el: 1235 LibDirs.append( 1236 MIPS64ELLibDirs, MIPS64ELLibDirs + llvm::array_lengthof(MIPS64ELLibDirs)); 1237 TripleAliases.append( 1238 MIPS64ELTriples, MIPS64ELTriples + llvm::array_lengthof(MIPS64ELTriples)); 1239 MultiarchLibDirs.append( 1240 MIPSELLibDirs, MIPSELLibDirs + llvm::array_lengthof(MIPSELLibDirs)); 1241 MultiarchTripleAliases.append( 1242 MIPSELTriples, MIPSELTriples + llvm::array_lengthof(MIPSELTriples)); 1243 break; 1244 case llvm::Triple::ppc: 1245 LibDirs.append(PPCLibDirs, PPCLibDirs + llvm::array_lengthof(PPCLibDirs)); 1246 TripleAliases.append( 1247 PPCTriples, PPCTriples + llvm::array_lengthof(PPCTriples)); 1248 MultiarchLibDirs.append( 1249 PPC64LibDirs, PPC64LibDirs + llvm::array_lengthof(PPC64LibDirs)); 1250 MultiarchTripleAliases.append( 1251 PPC64Triples, PPC64Triples + llvm::array_lengthof(PPC64Triples)); 1252 break; 1253 case llvm::Triple::ppc64: 1254 LibDirs.append( 1255 PPC64LibDirs, PPC64LibDirs + llvm::array_lengthof(PPC64LibDirs)); 1256 TripleAliases.append( 1257 PPC64Triples, PPC64Triples + llvm::array_lengthof(PPC64Triples)); 1258 MultiarchLibDirs.append( 1259 PPCLibDirs, PPCLibDirs + llvm::array_lengthof(PPCLibDirs)); 1260 MultiarchTripleAliases.append( 1261 PPCTriples, PPCTriples + llvm::array_lengthof(PPCTriples)); 1262 break; 1263 1264 default: 1265 // By default, just rely on the standard lib directories and the original 1266 // triple. 1267 break; 1268 } 1269 1270 // Always append the drivers target triple to the end, in case it doesn't 1271 // match any of our aliases. 1272 TripleAliases.push_back(TargetTriple.str()); 1273 1274 // Also include the multiarch variant if it's different. 1275 if (TargetTriple.str() != MultiarchTriple.str()) 1276 MultiarchTripleAliases.push_back(MultiarchTriple.str()); 1277} 1278 1279void Generic_GCC::GCCInstallationDetector::ScanLibDirForGCCTriple( 1280 llvm::Triple::ArchType TargetArch, const std::string &LibDir, 1281 StringRef CandidateTriple, bool NeedsMultiarchSuffix) { 1282 // There are various different suffixes involving the triple we 1283 // check for. We also record what is necessary to walk from each back 1284 // up to the lib directory. 1285 const std::string LibSuffixes[] = { 1286 "/gcc/" + CandidateTriple.str(), 1287 "/" + CandidateTriple.str() + "/gcc/" + CandidateTriple.str(), 1288 1289 // Ubuntu has a strange mis-matched pair of triples that this happens to 1290 // match. 1291 // FIXME: It may be worthwhile to generalize this and look for a second 1292 // triple. 1293 "/i386-linux-gnu/gcc/" + CandidateTriple.str() 1294 }; 1295 const std::string InstallSuffixes[] = { 1296 "/../../..", 1297 "/../../../..", 1298 "/../../../.." 1299 }; 1300 // Only look at the final, weird Ubuntu suffix for i386-linux-gnu. 1301 const unsigned NumLibSuffixes = (llvm::array_lengthof(LibSuffixes) - 1302 (TargetArch != llvm::Triple::x86)); 1303 for (unsigned i = 0; i < NumLibSuffixes; ++i) { 1304 StringRef LibSuffix = LibSuffixes[i]; 1305 llvm::error_code EC; 1306 for (llvm::sys::fs::directory_iterator LI(LibDir + LibSuffix, EC), LE; 1307 !EC && LI != LE; LI = LI.increment(EC)) { 1308 StringRef VersionText = llvm::sys::path::filename(LI->path()); 1309 GCCVersion CandidateVersion = GCCVersion::Parse(VersionText); 1310 static const GCCVersion MinVersion = { "4.1.1", 4, 1, 1, "" }; 1311 if (CandidateVersion < MinVersion) 1312 continue; 1313 if (CandidateVersion <= Version) 1314 continue; 1315 1316 // Some versions of SUSE and Fedora on ppc64 put 32-bit libs 1317 // in what would normally be GCCInstallPath and put the 64-bit 1318 // libs in a subdirectory named 64. The simple logic we follow is that 1319 // *if* there is a subdirectory of the right name with crtbegin.o in it, 1320 // we use that. If not, and if not a multiarch triple, we look for 1321 // crtbegin.o without the subdirectory. 1322 StringRef MultiarchSuffix 1323 = (TargetArch == llvm::Triple::x86_64 || 1324 TargetArch == llvm::Triple::ppc64 || 1325 TargetArch == llvm::Triple::mips64 || 1326 TargetArch == llvm::Triple::mips64el) ? "/64" : "/32"; 1327 if (llvm::sys::fs::exists(LI->path() + MultiarchSuffix + "/crtbegin.o")) { 1328 GCCMultiarchSuffix = MultiarchSuffix.str(); 1329 } else { 1330 if (NeedsMultiarchSuffix || 1331 !llvm::sys::fs::exists(LI->path() + "/crtbegin.o")) 1332 continue; 1333 GCCMultiarchSuffix.clear(); 1334 } 1335 1336 Version = CandidateVersion; 1337 GCCTriple.setTriple(CandidateTriple); 1338 // FIXME: We hack together the directory name here instead of 1339 // using LI to ensure stable path separators across Windows and 1340 // Linux. 1341 GCCInstallPath = LibDir + LibSuffixes[i] + "/" + VersionText.str(); 1342 GCCParentLibPath = GCCInstallPath + InstallSuffixes[i]; 1343 IsValid = true; 1344 } 1345 } 1346} 1347 1348Generic_GCC::Generic_GCC(const Driver &D, const llvm::Triple& Triple, 1349 const ArgList &Args) 1350 : ToolChain(D, Triple), GCCInstallation(getDriver(), Triple, Args) { 1351 getProgramPaths().push_back(getDriver().getInstalledDir()); 1352 if (getDriver().getInstalledDir() != getDriver().Dir) 1353 getProgramPaths().push_back(getDriver().Dir); 1354} 1355 1356Generic_GCC::~Generic_GCC() { 1357 // Free tool implementations. 1358 for (llvm::DenseMap<unsigned, Tool*>::iterator 1359 it = Tools.begin(), ie = Tools.end(); it != ie; ++it) 1360 delete it->second; 1361} 1362 1363Tool &Generic_GCC::SelectTool(const Compilation &C, 1364 const JobAction &JA, 1365 const ActionList &Inputs) const { 1366 Action::ActionClass Key; 1367 if (getDriver().ShouldUseClangCompiler(C, JA, getTriple())) 1368 Key = Action::AnalyzeJobClass; 1369 else 1370 Key = JA.getKind(); 1371 1372 Tool *&T = Tools[Key]; 1373 if (!T) { 1374 switch (Key) { 1375 case Action::InputClass: 1376 case Action::BindArchClass: 1377 llvm_unreachable("Invalid tool kind."); 1378 case Action::PreprocessJobClass: 1379 T = new tools::gcc::Preprocess(*this); break; 1380 case Action::PrecompileJobClass: 1381 T = new tools::gcc::Precompile(*this); break; 1382 case Action::AnalyzeJobClass: 1383 case Action::MigrateJobClass: 1384 T = new tools::Clang(*this); break; 1385 case Action::CompileJobClass: 1386 T = new tools::gcc::Compile(*this); break; 1387 case Action::AssembleJobClass: 1388 T = new tools::gcc::Assemble(*this); break; 1389 case Action::LinkJobClass: 1390 T = new tools::gcc::Link(*this); break; 1391 1392 // This is a bit ungeneric, but the only platform using a driver 1393 // driver is Darwin. 1394 case Action::LipoJobClass: 1395 T = new tools::darwin::Lipo(*this); break; 1396 case Action::DsymutilJobClass: 1397 T = new tools::darwin::Dsymutil(*this); break; 1398 case Action::VerifyJobClass: 1399 T = new tools::darwin::VerifyDebug(*this); break; 1400 } 1401 } 1402 1403 return *T; 1404} 1405 1406bool Generic_GCC::IsUnwindTablesDefault() const { 1407 // FIXME: Gross; we should probably have some separate target 1408 // definition, possibly even reusing the one in clang. 1409 return getArchName() == "x86_64"; 1410} 1411 1412const char *Generic_GCC::GetDefaultRelocationModel() const { 1413 return "static"; 1414} 1415 1416const char *Generic_GCC::GetForcedPicModel() const { 1417 return 0; 1418} 1419/// Hexagon Toolchain 1420 1421Hexagon_TC::Hexagon_TC(const Driver &D, const llvm::Triple& Triple) 1422 : ToolChain(D, Triple) { 1423 getProgramPaths().push_back(getDriver().getInstalledDir()); 1424 if (getDriver().getInstalledDir() != getDriver().Dir.c_str()) 1425 getProgramPaths().push_back(getDriver().Dir); 1426} 1427 1428Hexagon_TC::~Hexagon_TC() { 1429 // Free tool implementations. 1430 for (llvm::DenseMap<unsigned, Tool*>::iterator 1431 it = Tools.begin(), ie = Tools.end(); it != ie; ++it) 1432 delete it->second; 1433} 1434 1435Tool &Hexagon_TC::SelectTool(const Compilation &C, 1436 const JobAction &JA, 1437 const ActionList &Inputs) const { 1438 Action::ActionClass Key; 1439 // if (JA.getKind () == Action::CompileJobClass) 1440 // Key = JA.getKind (); 1441 // else 1442 1443 if (getDriver().ShouldUseClangCompiler(C, JA, getTriple())) 1444 Key = Action::AnalyzeJobClass; 1445 else 1446 Key = JA.getKind(); 1447 // if ((JA.getKind () == Action::CompileJobClass) 1448 // && (JA.getType () != types::TY_LTO_BC)) { 1449 // Key = JA.getKind (); 1450 // } 1451 1452 Tool *&T = Tools[Key]; 1453 if (!T) { 1454 switch (Key) { 1455 case Action::InputClass: 1456 case Action::BindArchClass: 1457 assert(0 && "Invalid tool kind."); 1458 case Action::AnalyzeJobClass: 1459 T = new tools::Clang(*this); break; 1460 case Action::AssembleJobClass: 1461 T = new tools::hexagon::Assemble(*this); break; 1462 case Action::LinkJobClass: 1463 T = new tools::hexagon::Link(*this); break; 1464 default: 1465 assert(false && "Unsupported action for Hexagon target."); 1466 } 1467 } 1468 1469 return *T; 1470} 1471 1472bool Hexagon_TC::IsUnwindTablesDefault() const { 1473 // FIXME: Gross; we should probably have some separate target 1474 // definition, possibly even reusing the one in clang. 1475 return getArchName() == "x86_64"; 1476} 1477 1478const char *Hexagon_TC::GetDefaultRelocationModel() const { 1479 return "static"; 1480} 1481 1482const char *Hexagon_TC::GetForcedPicModel() const { 1483 return 0; 1484} // End Hexagon 1485 1486 1487/// TCEToolChain - A tool chain using the llvm bitcode tools to perform 1488/// all subcommands. See http://tce.cs.tut.fi for our peculiar target. 1489/// Currently does not support anything else but compilation. 1490 1491TCEToolChain::TCEToolChain(const Driver &D, const llvm::Triple& Triple) 1492 : ToolChain(D, Triple) { 1493 // Path mangling to find libexec 1494 std::string Path(getDriver().Dir); 1495 1496 Path += "/../libexec"; 1497 getProgramPaths().push_back(Path); 1498} 1499 1500TCEToolChain::~TCEToolChain() { 1501 for (llvm::DenseMap<unsigned, Tool*>::iterator 1502 it = Tools.begin(), ie = Tools.end(); it != ie; ++it) 1503 delete it->second; 1504} 1505 1506bool TCEToolChain::IsMathErrnoDefault() const { 1507 return true; 1508} 1509 1510bool TCEToolChain::IsUnwindTablesDefault() const { 1511 return false; 1512} 1513 1514const char *TCEToolChain::GetDefaultRelocationModel() const { 1515 return "static"; 1516} 1517 1518const char *TCEToolChain::GetForcedPicModel() const { 1519 return 0; 1520} 1521 1522Tool &TCEToolChain::SelectTool(const Compilation &C, 1523 const JobAction &JA, 1524 const ActionList &Inputs) const { 1525 Action::ActionClass Key; 1526 Key = Action::AnalyzeJobClass; 1527 1528 Tool *&T = Tools[Key]; 1529 if (!T) { 1530 switch (Key) { 1531 case Action::PreprocessJobClass: 1532 T = new tools::gcc::Preprocess(*this); break; 1533 case Action::AnalyzeJobClass: 1534 T = new tools::Clang(*this); break; 1535 default: 1536 llvm_unreachable("Unsupported action for TCE target."); 1537 } 1538 } 1539 return *T; 1540} 1541 1542/// OpenBSD - OpenBSD tool chain which can call as(1) and ld(1) directly. 1543 1544OpenBSD::OpenBSD(const Driver &D, const llvm::Triple& Triple, const ArgList &Args) 1545 : Generic_ELF(D, Triple, Args) { 1546 getFilePaths().push_back(getDriver().Dir + "/../lib"); 1547 getFilePaths().push_back("/usr/lib"); 1548} 1549 1550Tool &OpenBSD::SelectTool(const Compilation &C, const JobAction &JA, 1551 const ActionList &Inputs) const { 1552 Action::ActionClass Key; 1553 if (getDriver().ShouldUseClangCompiler(C, JA, getTriple())) 1554 Key = Action::AnalyzeJobClass; 1555 else 1556 Key = JA.getKind(); 1557 1558 bool UseIntegratedAs = C.getArgs().hasFlag(options::OPT_integrated_as, 1559 options::OPT_no_integrated_as, 1560 IsIntegratedAssemblerDefault()); 1561 1562 Tool *&T = Tools[Key]; 1563 if (!T) { 1564 switch (Key) { 1565 case Action::AssembleJobClass: { 1566 if (UseIntegratedAs) 1567 T = new tools::ClangAs(*this); 1568 else 1569 T = new tools::openbsd::Assemble(*this); 1570 break; 1571 } 1572 case Action::LinkJobClass: 1573 T = new tools::openbsd::Link(*this); break; 1574 default: 1575 T = &Generic_GCC::SelectTool(C, JA, Inputs); 1576 } 1577 } 1578 1579 return *T; 1580} 1581 1582/// FreeBSD - FreeBSD tool chain which can call as(1) and ld(1) directly. 1583 1584FreeBSD::FreeBSD(const Driver &D, const llvm::Triple& Triple, const ArgList &Args) 1585 : Generic_ELF(D, Triple, Args) { 1586 1587 // When targeting 32-bit platforms, look for '/usr/lib32/crt1.o' and fall 1588 // back to '/usr/lib' if it doesn't exist. 1589 if ((Triple.getArch() == llvm::Triple::x86 || 1590 Triple.getArch() == llvm::Triple::ppc) && 1591 llvm::sys::fs::exists(getDriver().SysRoot + "/usr/lib32/crt1.o")) 1592 getFilePaths().push_back(getDriver().SysRoot + "/usr/lib32"); 1593 else 1594 getFilePaths().push_back(getDriver().SysRoot + "/usr/lib"); 1595} 1596 1597Tool &FreeBSD::SelectTool(const Compilation &C, const JobAction &JA, 1598 const ActionList &Inputs) const { 1599 Action::ActionClass Key; 1600 if (getDriver().ShouldUseClangCompiler(C, JA, getTriple())) 1601 Key = Action::AnalyzeJobClass; 1602 else 1603 Key = JA.getKind(); 1604 1605 bool UseIntegratedAs = C.getArgs().hasFlag(options::OPT_integrated_as, 1606 options::OPT_no_integrated_as, 1607 IsIntegratedAssemblerDefault()); 1608 1609 Tool *&T = Tools[Key]; 1610 if (!T) { 1611 switch (Key) { 1612 case Action::AssembleJobClass: 1613 if (UseIntegratedAs) 1614 T = new tools::ClangAs(*this); 1615 else 1616 T = new tools::freebsd::Assemble(*this); 1617 break; 1618 case Action::LinkJobClass: 1619 T = new tools::freebsd::Link(*this); break; 1620 default: 1621 T = &Generic_GCC::SelectTool(C, JA, Inputs); 1622 } 1623 } 1624 1625 return *T; 1626} 1627 1628/// NetBSD - NetBSD tool chain which can call as(1) and ld(1) directly. 1629 1630NetBSD::NetBSD(const Driver &D, const llvm::Triple& Triple, const ArgList &Args) 1631 : Generic_ELF(D, Triple, Args) { 1632 1633 if (getDriver().UseStdLib) { 1634 // When targeting a 32-bit platform, try the special directory used on 1635 // 64-bit hosts, and only fall back to the main library directory if that 1636 // doesn't work. 1637 // FIXME: It'd be nicer to test if this directory exists, but I'm not sure 1638 // what all logic is needed to emulate the '=' prefix here. 1639 if (Triple.getArch() == llvm::Triple::x86) 1640 getFilePaths().push_back("=/usr/lib/i386"); 1641 1642 getFilePaths().push_back("=/usr/lib"); 1643 } 1644} 1645 1646Tool &NetBSD::SelectTool(const Compilation &C, const JobAction &JA, 1647 const ActionList &Inputs) const { 1648 Action::ActionClass Key; 1649 if (getDriver().ShouldUseClangCompiler(C, JA, getTriple())) 1650 Key = Action::AnalyzeJobClass; 1651 else 1652 Key = JA.getKind(); 1653 1654 bool UseIntegratedAs = C.getArgs().hasFlag(options::OPT_integrated_as, 1655 options::OPT_no_integrated_as, 1656 IsIntegratedAssemblerDefault()); 1657 1658 Tool *&T = Tools[Key]; 1659 if (!T) { 1660 switch (Key) { 1661 case Action::AssembleJobClass: 1662 if (UseIntegratedAs) 1663 T = new tools::ClangAs(*this); 1664 else 1665 T = new tools::netbsd::Assemble(*this); 1666 break; 1667 case Action::LinkJobClass: 1668 T = new tools::netbsd::Link(*this); 1669 break; 1670 default: 1671 T = &Generic_GCC::SelectTool(C, JA, Inputs); 1672 } 1673 } 1674 1675 return *T; 1676} 1677 1678/// Minix - Minix tool chain which can call as(1) and ld(1) directly. 1679 1680Minix::Minix(const Driver &D, const llvm::Triple& Triple, const ArgList &Args) 1681 : Generic_ELF(D, Triple, Args) { 1682 getFilePaths().push_back(getDriver().Dir + "/../lib"); 1683 getFilePaths().push_back("/usr/lib"); 1684} 1685 1686Tool &Minix::SelectTool(const Compilation &C, const JobAction &JA, 1687 const ActionList &Inputs) const { 1688 Action::ActionClass Key; 1689 if (getDriver().ShouldUseClangCompiler(C, JA, getTriple())) 1690 Key = Action::AnalyzeJobClass; 1691 else 1692 Key = JA.getKind(); 1693 1694 Tool *&T = Tools[Key]; 1695 if (!T) { 1696 switch (Key) { 1697 case Action::AssembleJobClass: 1698 T = new tools::minix::Assemble(*this); break; 1699 case Action::LinkJobClass: 1700 T = new tools::minix::Link(*this); break; 1701 default: 1702 T = &Generic_GCC::SelectTool(C, JA, Inputs); 1703 } 1704 } 1705 1706 return *T; 1707} 1708 1709/// AuroraUX - AuroraUX tool chain which can call as(1) and ld(1) directly. 1710 1711AuroraUX::AuroraUX(const Driver &D, const llvm::Triple& Triple, 1712 const ArgList &Args) 1713 : Generic_GCC(D, Triple, Args) { 1714 1715 getProgramPaths().push_back(getDriver().getInstalledDir()); 1716 if (getDriver().getInstalledDir() != getDriver().Dir) 1717 getProgramPaths().push_back(getDriver().Dir); 1718 1719 getFilePaths().push_back(getDriver().Dir + "/../lib"); 1720 getFilePaths().push_back("/usr/lib"); 1721 getFilePaths().push_back("/usr/sfw/lib"); 1722 getFilePaths().push_back("/opt/gcc4/lib"); 1723 getFilePaths().push_back("/opt/gcc4/lib/gcc/i386-pc-solaris2.11/4.2.4"); 1724 1725} 1726 1727Tool &AuroraUX::SelectTool(const Compilation &C, const JobAction &JA, 1728 const ActionList &Inputs) const { 1729 Action::ActionClass Key; 1730 if (getDriver().ShouldUseClangCompiler(C, JA, getTriple())) 1731 Key = Action::AnalyzeJobClass; 1732 else 1733 Key = JA.getKind(); 1734 1735 Tool *&T = Tools[Key]; 1736 if (!T) { 1737 switch (Key) { 1738 case Action::AssembleJobClass: 1739 T = new tools::auroraux::Assemble(*this); break; 1740 case Action::LinkJobClass: 1741 T = new tools::auroraux::Link(*this); break; 1742 default: 1743 T = &Generic_GCC::SelectTool(C, JA, Inputs); 1744 } 1745 } 1746 1747 return *T; 1748} 1749 1750/// Solaris - Solaris tool chain which can call as(1) and ld(1) directly. 1751 1752Solaris::Solaris(const Driver &D, const llvm::Triple& Triple, 1753 const ArgList &Args) 1754 : Generic_GCC(D, Triple, Args) { 1755 1756 getProgramPaths().push_back(getDriver().getInstalledDir()); 1757 if (getDriver().getInstalledDir() != getDriver().Dir) 1758 getProgramPaths().push_back(getDriver().Dir); 1759 1760 getFilePaths().push_back(getDriver().Dir + "/../lib"); 1761 getFilePaths().push_back("/usr/lib"); 1762} 1763 1764Tool &Solaris::SelectTool(const Compilation &C, const JobAction &JA, 1765 const ActionList &Inputs) const { 1766 Action::ActionClass Key; 1767 if (getDriver().ShouldUseClangCompiler(C, JA, getTriple())) 1768 Key = Action::AnalyzeJobClass; 1769 else 1770 Key = JA.getKind(); 1771 1772 Tool *&T = Tools[Key]; 1773 if (!T) { 1774 switch (Key) { 1775 case Action::AssembleJobClass: 1776 T = new tools::solaris::Assemble(*this); break; 1777 case Action::LinkJobClass: 1778 T = new tools::solaris::Link(*this); break; 1779 default: 1780 T = &Generic_GCC::SelectTool(C, JA, Inputs); 1781 } 1782 } 1783 1784 return *T; 1785} 1786 1787/// Linux toolchain (very bare-bones at the moment). 1788 1789enum LinuxDistro { 1790 ArchLinux, 1791 DebianLenny, 1792 DebianSqueeze, 1793 DebianWheezy, 1794 Exherbo, 1795 RHEL4, 1796 RHEL5, 1797 RHEL6, 1798 Fedora13, 1799 Fedora14, 1800 Fedora15, 1801 Fedora16, 1802 FedoraRawhide, 1803 OpenSuse11_3, 1804 OpenSuse11_4, 1805 OpenSuse12_1, 1806 OpenSuse12_2, 1807 UbuntuHardy, 1808 UbuntuIntrepid, 1809 UbuntuJaunty, 1810 UbuntuKarmic, 1811 UbuntuLucid, 1812 UbuntuMaverick, 1813 UbuntuNatty, 1814 UbuntuOneiric, 1815 UbuntuPrecise, 1816 UnknownDistro 1817}; 1818 1819static bool IsRedhat(enum LinuxDistro Distro) { 1820 return (Distro >= Fedora13 && Distro <= FedoraRawhide) || 1821 (Distro >= RHEL4 && Distro <= RHEL6); 1822} 1823 1824static bool IsOpenSuse(enum LinuxDistro Distro) { 1825 return Distro >= OpenSuse11_3 && Distro <= OpenSuse12_2; 1826} 1827 1828static bool IsDebian(enum LinuxDistro Distro) { 1829 return Distro >= DebianLenny && Distro <= DebianWheezy; 1830} 1831 1832static bool IsUbuntu(enum LinuxDistro Distro) { 1833 return Distro >= UbuntuHardy && Distro <= UbuntuPrecise; 1834} 1835 1836static LinuxDistro DetectLinuxDistro(llvm::Triple::ArchType Arch) { 1837 OwningPtr<llvm::MemoryBuffer> File; 1838 if (!llvm::MemoryBuffer::getFile("/etc/lsb-release", File)) { 1839 StringRef Data = File.get()->getBuffer(); 1840 SmallVector<StringRef, 8> Lines; 1841 Data.split(Lines, "\n"); 1842 LinuxDistro Version = UnknownDistro; 1843 for (unsigned i = 0, s = Lines.size(); i != s; ++i) 1844 if (Version == UnknownDistro && Lines[i].startswith("DISTRIB_CODENAME=")) 1845 Version = llvm::StringSwitch<LinuxDistro>(Lines[i].substr(17)) 1846 .Case("hardy", UbuntuHardy) 1847 .Case("intrepid", UbuntuIntrepid) 1848 .Case("jaunty", UbuntuJaunty) 1849 .Case("karmic", UbuntuKarmic) 1850 .Case("lucid", UbuntuLucid) 1851 .Case("maverick", UbuntuMaverick) 1852 .Case("natty", UbuntuNatty) 1853 .Case("oneiric", UbuntuOneiric) 1854 .Case("precise", UbuntuPrecise) 1855 .Default(UnknownDistro); 1856 return Version; 1857 } 1858 1859 if (!llvm::MemoryBuffer::getFile("/etc/redhat-release", File)) { 1860 StringRef Data = File.get()->getBuffer(); 1861 if (Data.startswith("Fedora release 16")) 1862 return Fedora16; 1863 else if (Data.startswith("Fedora release 15")) 1864 return Fedora15; 1865 else if (Data.startswith("Fedora release 14")) 1866 return Fedora14; 1867 else if (Data.startswith("Fedora release 13")) 1868 return Fedora13; 1869 else if (Data.startswith("Fedora release") && 1870 Data.find("Rawhide") != StringRef::npos) 1871 return FedoraRawhide; 1872 else if (Data.startswith("Red Hat Enterprise Linux") && 1873 Data.find("release 6") != StringRef::npos) 1874 return RHEL6; 1875 else if ((Data.startswith("Red Hat Enterprise Linux") || 1876 Data.startswith("CentOS")) && 1877 Data.find("release 5") != StringRef::npos) 1878 return RHEL5; 1879 else if ((Data.startswith("Red Hat Enterprise Linux") || 1880 Data.startswith("CentOS")) && 1881 Data.find("release 4") != StringRef::npos) 1882 return RHEL4; 1883 return UnknownDistro; 1884 } 1885 1886 if (!llvm::MemoryBuffer::getFile("/etc/debian_version", File)) { 1887 StringRef Data = File.get()->getBuffer(); 1888 if (Data[0] == '5') 1889 return DebianLenny; 1890 else if (Data.startswith("squeeze/sid") || Data[0] == '6') 1891 return DebianSqueeze; 1892 else if (Data.startswith("wheezy/sid") || Data[0] == '7') 1893 return DebianWheezy; 1894 return UnknownDistro; 1895 } 1896 1897 if (!llvm::MemoryBuffer::getFile("/etc/SuSE-release", File)) 1898 return llvm::StringSwitch<LinuxDistro>(File.get()->getBuffer()) 1899 .StartsWith("openSUSE 11.3", OpenSuse11_3) 1900 .StartsWith("openSUSE 11.4", OpenSuse11_4) 1901 .StartsWith("openSUSE 12.1", OpenSuse12_1) 1902 .StartsWith("openSUSE 12.2", OpenSuse12_2) 1903 .Default(UnknownDistro); 1904 1905 bool Exists; 1906 if (!llvm::sys::fs::exists("/etc/exherbo-release", Exists) && Exists) 1907 return Exherbo; 1908 1909 if (!llvm::sys::fs::exists("/etc/arch-release", Exists) && Exists) 1910 return ArchLinux; 1911 1912 return UnknownDistro; 1913} 1914 1915/// \brief Get our best guess at the multiarch triple for a target. 1916/// 1917/// Debian-based systems are starting to use a multiarch setup where they use 1918/// a target-triple directory in the library and header search paths. 1919/// Unfortunately, this triple does not align with the vanilla target triple, 1920/// so we provide a rough mapping here. 1921static std::string getMultiarchTriple(const llvm::Triple TargetTriple, 1922 StringRef SysRoot) { 1923 // For most architectures, just use whatever we have rather than trying to be 1924 // clever. 1925 switch (TargetTriple.getArch()) { 1926 default: 1927 return TargetTriple.str(); 1928 1929 // We use the existence of '/lib/<triple>' as a directory to detect some 1930 // common linux triples that don't quite match the Clang triple for both 1931 // 32-bit and 64-bit targets. Multiarch fixes its install triples to these 1932 // regardless of what the actual target triple is. 1933 case llvm::Triple::x86: 1934 if (llvm::sys::fs::exists(SysRoot + "/lib/i386-linux-gnu")) 1935 return "i386-linux-gnu"; 1936 return TargetTriple.str(); 1937 case llvm::Triple::x86_64: 1938 if (llvm::sys::fs::exists(SysRoot + "/lib/x86_64-linux-gnu")) 1939 return "x86_64-linux-gnu"; 1940 return TargetTriple.str(); 1941 case llvm::Triple::mips: 1942 if (llvm::sys::fs::exists(SysRoot + "/lib/mips-linux-gnu")) 1943 return "mips-linux-gnu"; 1944 return TargetTriple.str(); 1945 case llvm::Triple::mipsel: 1946 if (llvm::sys::fs::exists(SysRoot + "/lib/mipsel-linux-gnu")) 1947 return "mipsel-linux-gnu"; 1948 return TargetTriple.str(); 1949 case llvm::Triple::ppc: 1950 if (llvm::sys::fs::exists(SysRoot + "/lib/powerpc-linux-gnu")) 1951 return "powerpc-linux-gnu"; 1952 return TargetTriple.str(); 1953 case llvm::Triple::ppc64: 1954 if (llvm::sys::fs::exists(SysRoot + "/lib/powerpc64-linux-gnu")) 1955 return "powerpc64-linux-gnu"; 1956 return TargetTriple.str(); 1957 } 1958} 1959 1960static void addPathIfExists(Twine Path, ToolChain::path_list &Paths) { 1961 if (llvm::sys::fs::exists(Path)) Paths.push_back(Path.str()); 1962} 1963 1964Linux::Linux(const Driver &D, const llvm::Triple &Triple, const ArgList &Args) 1965 : Generic_ELF(D, Triple, Args) { 1966 llvm::Triple::ArchType Arch = Triple.getArch(); 1967 const std::string &SysRoot = getDriver().SysRoot; 1968 1969 // OpenSuse stores the linker with the compiler, add that to the search 1970 // path. 1971 ToolChain::path_list &PPaths = getProgramPaths(); 1972 PPaths.push_back(Twine(GCCInstallation.getParentLibPath() + "/../" + 1973 GCCInstallation.getTriple().str() + "/bin").str()); 1974 1975 Linker = GetProgramPath("ld"); 1976 1977 LinuxDistro Distro = DetectLinuxDistro(Arch); 1978 1979 if (IsOpenSuse(Distro) || IsUbuntu(Distro)) { 1980 ExtraOpts.push_back("-z"); 1981 ExtraOpts.push_back("relro"); 1982 } 1983 1984 if (Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb) 1985 ExtraOpts.push_back("-X"); 1986 1987 const bool IsMips = Arch == llvm::Triple::mips || 1988 Arch == llvm::Triple::mipsel || 1989 Arch == llvm::Triple::mips64 || 1990 Arch == llvm::Triple::mips64el; 1991 1992 const bool IsAndroid = Triple.getEnvironment() == llvm::Triple::ANDROIDEABI; 1993 1994 // Do not use 'gnu' hash style for Mips targets because .gnu.hash 1995 // and the MIPS ABI require .dynsym to be sorted in different ways. 1996 // .gnu.hash needs symbols to be grouped by hash code whereas the MIPS 1997 // ABI requires a mapping between the GOT and the symbol table. 1998 // Android loader does not support .gnu.hash. 1999 if (!IsMips && !IsAndroid) { 2000 if (IsRedhat(Distro) || IsOpenSuse(Distro) || 2001 (IsUbuntu(Distro) && Distro >= UbuntuMaverick)) 2002 ExtraOpts.push_back("--hash-style=gnu"); 2003 2004 if (IsDebian(Distro) || IsOpenSuse(Distro) || Distro == UbuntuLucid || 2005 Distro == UbuntuJaunty || Distro == UbuntuKarmic) 2006 ExtraOpts.push_back("--hash-style=both"); 2007 } 2008 2009 if (IsRedhat(Distro)) 2010 ExtraOpts.push_back("--no-add-needed"); 2011 2012 if (Distro == DebianSqueeze || Distro == DebianWheezy || 2013 IsOpenSuse(Distro) || 2014 (IsRedhat(Distro) && Distro != RHEL4 && Distro != RHEL5) || 2015 (IsUbuntu(Distro) && Distro >= UbuntuKarmic)) 2016 ExtraOpts.push_back("--build-id"); 2017 2018 if (IsOpenSuse(Distro)) 2019 ExtraOpts.push_back("--enable-new-dtags"); 2020 2021 // The selection of paths to try here is designed to match the patterns which 2022 // the GCC driver itself uses, as this is part of the GCC-compatible driver. 2023 // This was determined by running GCC in a fake filesystem, creating all 2024 // possible permutations of these directories, and seeing which ones it added 2025 // to the link paths. 2026 path_list &Paths = getFilePaths(); 2027 2028 const std::string Multilib = Triple.isArch32Bit() ? "lib32" : "lib64"; 2029 const std::string MultiarchTriple = getMultiarchTriple(Triple, SysRoot); 2030 2031 // Add the multilib suffixed paths where they are available. 2032 if (GCCInstallation.isValid()) { 2033 const llvm::Triple &GCCTriple = GCCInstallation.getTriple(); 2034 const std::string &LibPath = GCCInstallation.getParentLibPath(); 2035 addPathIfExists((GCCInstallation.getInstallPath() + 2036 GCCInstallation.getMultiarchSuffix()), 2037 Paths); 2038 2039 // If the GCC installation we found is inside of the sysroot, we want to 2040 // prefer libraries installed in the parent prefix of the GCC installation. 2041 // It is important to *not* use these paths when the GCC installation is 2042 // outside of the system root as that can pick up unintended libraries. 2043 // This usually happens when there is an external cross compiler on the 2044 // host system, and a more minimal sysroot available that is the target of 2045 // the cross. 2046 if (StringRef(LibPath).startswith(SysRoot)) { 2047 addPathIfExists(LibPath + "/../" + GCCTriple.str() + "/lib/../" + Multilib, 2048 Paths); 2049 addPathIfExists(LibPath + "/" + MultiarchTriple, Paths); 2050 addPathIfExists(LibPath + "/../" + Multilib, Paths); 2051 } 2052 } 2053 addPathIfExists(SysRoot + "/lib/" + MultiarchTriple, Paths); 2054 addPathIfExists(SysRoot + "/lib/../" + Multilib, Paths); 2055 addPathIfExists(SysRoot + "/usr/lib/" + MultiarchTriple, Paths); 2056 addPathIfExists(SysRoot + "/usr/lib/../" + Multilib, Paths); 2057 2058 // Try walking via the GCC triple path in case of multiarch GCC 2059 // installations with strange symlinks. 2060 if (GCCInstallation.isValid()) 2061 addPathIfExists(SysRoot + "/usr/lib/" + GCCInstallation.getTriple().str() + 2062 "/../../" + Multilib, Paths); 2063 2064 // Add the non-multilib suffixed paths (if potentially different). 2065 if (GCCInstallation.isValid()) { 2066 const std::string &LibPath = GCCInstallation.getParentLibPath(); 2067 const llvm::Triple &GCCTriple = GCCInstallation.getTriple(); 2068 if (!GCCInstallation.getMultiarchSuffix().empty()) 2069 addPathIfExists(GCCInstallation.getInstallPath(), Paths); 2070 2071 if (StringRef(LibPath).startswith(SysRoot)) { 2072 addPathIfExists(LibPath + "/../" + GCCTriple.str() + "/lib", Paths); 2073 addPathIfExists(LibPath, Paths); 2074 } 2075 } 2076 addPathIfExists(SysRoot + "/lib", Paths); 2077 addPathIfExists(SysRoot + "/usr/lib", Paths); 2078} 2079 2080bool Linux::HasNativeLLVMSupport() const { 2081 return true; 2082} 2083 2084Tool &Linux::SelectTool(const Compilation &C, const JobAction &JA, 2085 const ActionList &Inputs) const { 2086 Action::ActionClass Key; 2087 if (getDriver().ShouldUseClangCompiler(C, JA, getTriple())) 2088 Key = Action::AnalyzeJobClass; 2089 else 2090 Key = JA.getKind(); 2091 2092 bool UseIntegratedAs = C.getArgs().hasFlag(options::OPT_integrated_as, 2093 options::OPT_no_integrated_as, 2094 IsIntegratedAssemblerDefault()); 2095 2096 Tool *&T = Tools[Key]; 2097 if (!T) { 2098 switch (Key) { 2099 case Action::AssembleJobClass: 2100 if (UseIntegratedAs) 2101 T = new tools::ClangAs(*this); 2102 else 2103 T = new tools::linuxtools::Assemble(*this); 2104 break; 2105 case Action::LinkJobClass: 2106 T = new tools::linuxtools::Link(*this); break; 2107 default: 2108 T = &Generic_GCC::SelectTool(C, JA, Inputs); 2109 } 2110 } 2111 2112 return *T; 2113} 2114 2115void Linux::AddClangSystemIncludeArgs(const ArgList &DriverArgs, 2116 ArgStringList &CC1Args) const { 2117 const Driver &D = getDriver(); 2118 2119 if (DriverArgs.hasArg(options::OPT_nostdinc)) 2120 return; 2121 2122 if (!DriverArgs.hasArg(options::OPT_nostdlibinc)) 2123 addSystemInclude(DriverArgs, CC1Args, D.SysRoot + "/usr/local/include"); 2124 2125 if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) { 2126 llvm::sys::Path P(D.ResourceDir); 2127 P.appendComponent("include"); 2128 addSystemInclude(DriverArgs, CC1Args, P.str()); 2129 } 2130 2131 if (DriverArgs.hasArg(options::OPT_nostdlibinc)) 2132 return; 2133 2134 // Check for configure-time C include directories. 2135 StringRef CIncludeDirs(C_INCLUDE_DIRS); 2136 if (CIncludeDirs != "") { 2137 SmallVector<StringRef, 5> dirs; 2138 CIncludeDirs.split(dirs, ":"); 2139 for (SmallVectorImpl<StringRef>::iterator I = dirs.begin(), E = dirs.end(); 2140 I != E; ++I) { 2141 StringRef Prefix = llvm::sys::path::is_absolute(*I) ? D.SysRoot : ""; 2142 addExternCSystemInclude(DriverArgs, CC1Args, Prefix + *I); 2143 } 2144 return; 2145 } 2146 2147 // Lacking those, try to detect the correct set of system includes for the 2148 // target triple. 2149 2150 // Implement generic Debian multiarch support. 2151 const StringRef X86_64MultiarchIncludeDirs[] = { 2152 "/usr/include/x86_64-linux-gnu", 2153 2154 // FIXME: These are older forms of multiarch. It's not clear that they're 2155 // in use in any released version of Debian, so we should consider 2156 // removing them. 2157 "/usr/include/i686-linux-gnu/64", 2158 "/usr/include/i486-linux-gnu/64" 2159 }; 2160 const StringRef X86MultiarchIncludeDirs[] = { 2161 "/usr/include/i386-linux-gnu", 2162 2163 // FIXME: These are older forms of multiarch. It's not clear that they're 2164 // in use in any released version of Debian, so we should consider 2165 // removing them. 2166 "/usr/include/x86_64-linux-gnu/32", 2167 "/usr/include/i686-linux-gnu", 2168 "/usr/include/i486-linux-gnu" 2169 }; 2170 const StringRef ARMMultiarchIncludeDirs[] = { 2171 "/usr/include/arm-linux-gnueabi" 2172 }; 2173 const StringRef MIPSMultiarchIncludeDirs[] = { 2174 "/usr/include/mips-linux-gnu" 2175 }; 2176 const StringRef MIPSELMultiarchIncludeDirs[] = { 2177 "/usr/include/mipsel-linux-gnu" 2178 }; 2179 const StringRef PPCMultiarchIncludeDirs[] = { 2180 "/usr/include/powerpc-linux-gnu" 2181 }; 2182 const StringRef PPC64MultiarchIncludeDirs[] = { 2183 "/usr/include/powerpc64-linux-gnu" 2184 }; 2185 ArrayRef<StringRef> MultiarchIncludeDirs; 2186 if (getTriple().getArch() == llvm::Triple::x86_64) { 2187 MultiarchIncludeDirs = X86_64MultiarchIncludeDirs; 2188 } else if (getTriple().getArch() == llvm::Triple::x86) { 2189 MultiarchIncludeDirs = X86MultiarchIncludeDirs; 2190 } else if (getTriple().getArch() == llvm::Triple::arm) { 2191 MultiarchIncludeDirs = ARMMultiarchIncludeDirs; 2192 } else if (getTriple().getArch() == llvm::Triple::mips) { 2193 MultiarchIncludeDirs = MIPSMultiarchIncludeDirs; 2194 } else if (getTriple().getArch() == llvm::Triple::mipsel) { 2195 MultiarchIncludeDirs = MIPSELMultiarchIncludeDirs; 2196 } else if (getTriple().getArch() == llvm::Triple::ppc) { 2197 MultiarchIncludeDirs = PPCMultiarchIncludeDirs; 2198 } else if (getTriple().getArch() == llvm::Triple::ppc64) { 2199 MultiarchIncludeDirs = PPC64MultiarchIncludeDirs; 2200 } 2201 for (ArrayRef<StringRef>::iterator I = MultiarchIncludeDirs.begin(), 2202 E = MultiarchIncludeDirs.end(); 2203 I != E; ++I) { 2204 if (llvm::sys::fs::exists(D.SysRoot + *I)) { 2205 addExternCSystemInclude(DriverArgs, CC1Args, D.SysRoot + *I); 2206 break; 2207 } 2208 } 2209 2210 if (getTriple().getOS() == llvm::Triple::RTEMS) 2211 return; 2212 2213 // Add an include of '/include' directly. This isn't provided by default by 2214 // system GCCs, but is often used with cross-compiling GCCs, and harmless to 2215 // add even when Clang is acting as-if it were a system compiler. 2216 addExternCSystemInclude(DriverArgs, CC1Args, D.SysRoot + "/include"); 2217 2218 addExternCSystemInclude(DriverArgs, CC1Args, D.SysRoot + "/usr/include"); 2219} 2220 2221/// \brief Helper to add the thre variant paths for a libstdc++ installation. 2222/*static*/ bool Linux::addLibStdCXXIncludePaths(Twine Base, Twine TargetArchDir, 2223 const ArgList &DriverArgs, 2224 ArgStringList &CC1Args) { 2225 if (!llvm::sys::fs::exists(Base)) 2226 return false; 2227 addSystemInclude(DriverArgs, CC1Args, Base); 2228 addSystemInclude(DriverArgs, CC1Args, Base + "/" + TargetArchDir); 2229 addSystemInclude(DriverArgs, CC1Args, Base + "/backward"); 2230 return true; 2231} 2232 2233void Linux::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs, 2234 ArgStringList &CC1Args) const { 2235 if (DriverArgs.hasArg(options::OPT_nostdlibinc) || 2236 DriverArgs.hasArg(options::OPT_nostdincxx)) 2237 return; 2238 2239 // Check if libc++ has been enabled and provide its include paths if so. 2240 if (GetCXXStdlibType(DriverArgs) == ToolChain::CST_Libcxx) { 2241 // libc++ is always installed at a fixed path on Linux currently. 2242 addSystemInclude(DriverArgs, CC1Args, 2243 getDriver().SysRoot + "/usr/include/c++/v1"); 2244 return; 2245 } 2246 2247 // We need a detected GCC installation on Linux to provide libstdc++'s 2248 // headers. We handled the libc++ case above. 2249 if (!GCCInstallation.isValid()) 2250 return; 2251 2252 // By default, look for the C++ headers in an include directory adjacent to 2253 // the lib directory of the GCC installation. Note that this is expect to be 2254 // equivalent to '/usr/include/c++/X.Y' in almost all cases. 2255 StringRef LibDir = GCCInstallation.getParentLibPath(); 2256 StringRef InstallDir = GCCInstallation.getInstallPath(); 2257 StringRef Version = GCCInstallation.getVersion(); 2258 if (!addLibStdCXXIncludePaths(LibDir + "/../include/c++/" + Version, 2259 (GCCInstallation.getTriple().str() + 2260 GCCInstallation.getMultiarchSuffix()), 2261 DriverArgs, CC1Args)) { 2262 // Gentoo is weird and places its headers inside the GCC install, so if the 2263 // first attempt to find the headers fails, try this pattern. 2264 addLibStdCXXIncludePaths(InstallDir + "/include/g++-v4", 2265 (GCCInstallation.getTriple().str() + 2266 GCCInstallation.getMultiarchSuffix()), 2267 DriverArgs, CC1Args); 2268 } 2269} 2270 2271/// DragonFly - DragonFly tool chain which can call as(1) and ld(1) directly. 2272 2273DragonFly::DragonFly(const Driver &D, const llvm::Triple& Triple, const ArgList &Args) 2274 : Generic_ELF(D, Triple, Args) { 2275 2276 // Path mangling to find libexec 2277 getProgramPaths().push_back(getDriver().getInstalledDir()); 2278 if (getDriver().getInstalledDir() != getDriver().Dir) 2279 getProgramPaths().push_back(getDriver().Dir); 2280 2281 getFilePaths().push_back(getDriver().Dir + "/../lib"); 2282 getFilePaths().push_back("/usr/lib"); 2283 getFilePaths().push_back("/usr/lib/gcc41"); 2284} 2285 2286Tool &DragonFly::SelectTool(const Compilation &C, const JobAction &JA, 2287 const ActionList &Inputs) const { 2288 Action::ActionClass Key; 2289 if (getDriver().ShouldUseClangCompiler(C, JA, getTriple())) 2290 Key = Action::AnalyzeJobClass; 2291 else 2292 Key = JA.getKind(); 2293 2294 Tool *&T = Tools[Key]; 2295 if (!T) { 2296 switch (Key) { 2297 case Action::AssembleJobClass: 2298 T = new tools::dragonfly::Assemble(*this); break; 2299 case Action::LinkJobClass: 2300 T = new tools::dragonfly::Link(*this); break; 2301 default: 2302 T = &Generic_GCC::SelectTool(C, JA, Inputs); 2303 } 2304 } 2305 2306 return *T; 2307} 2308