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