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