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