ToolChains.cpp revision 8e8e95c57c310bbc52cdc8d32df23c95afc77916
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 "armv7hl-redhat-linux-gnueabi" 1090 }; 1091 1092 static const char *const X86_64LibDirs[] = { "/lib64", "/lib" }; 1093 static const char *const X86_64Triples[] = { 1094 "x86_64-linux-gnu", 1095 "x86_64-unknown-linux-gnu", 1096 "x86_64-pc-linux-gnu", 1097 "x86_64-redhat-linux6E", 1098 "x86_64-redhat-linux", 1099 "x86_64-suse-linux", 1100 "x86_64-manbo-linux-gnu", 1101 "x86_64-linux-gnu", 1102 "x86_64-slackware-linux" 1103 }; 1104 static const char *const X86LibDirs[] = { "/lib32", "/lib" }; 1105 static const char *const X86Triples[] = { 1106 "i686-linux-gnu", 1107 "i686-pc-linux-gnu", 1108 "i486-linux-gnu", 1109 "i386-linux-gnu", 1110 "i386-redhat-linux6E", 1111 "i686-redhat-linux", 1112 "i586-redhat-linux", 1113 "i386-redhat-linux", 1114 "i586-suse-linux", 1115 "i486-slackware-linux", 1116 "i686-montavista-linux" 1117 }; 1118 1119 static const char *const MIPSLibDirs[] = { "/lib" }; 1120 static const char *const MIPSTriples[] = { "mips-linux-gnu" }; 1121 static const char *const MIPSELLibDirs[] = { "/lib" }; 1122 static const char *const MIPSELTriples[] = { 1123 "mipsel-linux-gnu", 1124 "mipsel-linux-android", 1125 "mips-linux-gnu" 1126 }; 1127 1128 static const char *const MIPS64LibDirs[] = { "/lib64", "/lib" }; 1129 static const char *const MIPS64Triples[] = { "mips64-linux-gnu" }; 1130 static const char *const MIPS64ELLibDirs[] = { "/lib64", "/lib" }; 1131 static const char *const MIPS64ELTriples[] = { "mips64el-linux-gnu" }; 1132 1133 static const char *const PPCLibDirs[] = { "/lib32", "/lib" }; 1134 static const char *const PPCTriples[] = { 1135 "powerpc-linux-gnu", 1136 "powerpc-unknown-linux-gnu", 1137 "powerpc-linux-gnuspe", 1138 "powerpc-suse-linux", 1139 "powerpc-montavista-linuxspe" 1140 }; 1141 static const char *const PPC64LibDirs[] = { "/lib64", "/lib" }; 1142 static const char *const PPC64Triples[] = { 1143 "powerpc64-linux-gnu", 1144 "powerpc64-unknown-linux-gnu", 1145 "powerpc64-suse-linux", 1146 "ppc64-redhat-linux" 1147 }; 1148 1149 switch (TargetTriple.getArch()) { 1150 case llvm::Triple::aarch64: 1151 LibDirs.append(AArch64LibDirs, AArch64LibDirs 1152 + llvm::array_lengthof(AArch64LibDirs)); 1153 TripleAliases.append( 1154 AArch64Triples, AArch64Triples + llvm::array_lengthof(AArch64Triples)); 1155 MultiarchLibDirs.append( 1156 AArch64LibDirs, AArch64LibDirs + llvm::array_lengthof(AArch64LibDirs)); 1157 MultiarchTripleAliases.append( 1158 AArch64Triples, AArch64Triples + llvm::array_lengthof(AArch64Triples)); 1159 break; 1160 case llvm::Triple::arm: 1161 case llvm::Triple::thumb: 1162 LibDirs.append(ARMLibDirs, ARMLibDirs + llvm::array_lengthof(ARMLibDirs)); 1163 if (TargetTriple.getEnvironment() == llvm::Triple::GNUEABIHF) { 1164 TripleAliases.append( 1165 ARMHFTriples, ARMHFTriples + llvm::array_lengthof(ARMHFTriples)); 1166 } else { 1167 TripleAliases.append( 1168 ARMTriples, ARMTriples + llvm::array_lengthof(ARMTriples)); 1169 } 1170 break; 1171 case llvm::Triple::x86_64: 1172 LibDirs.append( 1173 X86_64LibDirs, X86_64LibDirs + llvm::array_lengthof(X86_64LibDirs)); 1174 TripleAliases.append( 1175 X86_64Triples, X86_64Triples + llvm::array_lengthof(X86_64Triples)); 1176 MultiarchLibDirs.append( 1177 X86LibDirs, X86LibDirs + llvm::array_lengthof(X86LibDirs)); 1178 MultiarchTripleAliases.append( 1179 X86Triples, X86Triples + llvm::array_lengthof(X86Triples)); 1180 break; 1181 case llvm::Triple::x86: 1182 LibDirs.append(X86LibDirs, X86LibDirs + llvm::array_lengthof(X86LibDirs)); 1183 TripleAliases.append( 1184 X86Triples, X86Triples + llvm::array_lengthof(X86Triples)); 1185 MultiarchLibDirs.append( 1186 X86_64LibDirs, X86_64LibDirs + llvm::array_lengthof(X86_64LibDirs)); 1187 MultiarchTripleAliases.append( 1188 X86_64Triples, X86_64Triples + llvm::array_lengthof(X86_64Triples)); 1189 break; 1190 case llvm::Triple::mips: 1191 LibDirs.append( 1192 MIPSLibDirs, MIPSLibDirs + llvm::array_lengthof(MIPSLibDirs)); 1193 TripleAliases.append( 1194 MIPSTriples, MIPSTriples + llvm::array_lengthof(MIPSTriples)); 1195 MultiarchLibDirs.append( 1196 MIPS64LibDirs, MIPS64LibDirs + llvm::array_lengthof(MIPS64LibDirs)); 1197 MultiarchTripleAliases.append( 1198 MIPS64Triples, MIPS64Triples + llvm::array_lengthof(MIPS64Triples)); 1199 break; 1200 case llvm::Triple::mipsel: 1201 LibDirs.append( 1202 MIPSELLibDirs, MIPSELLibDirs + llvm::array_lengthof(MIPSELLibDirs)); 1203 TripleAliases.append( 1204 MIPSELTriples, MIPSELTriples + llvm::array_lengthof(MIPSELTriples)); 1205 MultiarchLibDirs.append( 1206 MIPS64ELLibDirs, MIPS64ELLibDirs + llvm::array_lengthof(MIPS64ELLibDirs)); 1207 MultiarchTripleAliases.append( 1208 MIPS64ELTriples, MIPS64ELTriples + llvm::array_lengthof(MIPS64ELTriples)); 1209 break; 1210 case llvm::Triple::mips64: 1211 LibDirs.append( 1212 MIPS64LibDirs, MIPS64LibDirs + llvm::array_lengthof(MIPS64LibDirs)); 1213 TripleAliases.append( 1214 MIPS64Triples, MIPS64Triples + llvm::array_lengthof(MIPS64Triples)); 1215 MultiarchLibDirs.append( 1216 MIPSLibDirs, MIPSLibDirs + llvm::array_lengthof(MIPSLibDirs)); 1217 MultiarchTripleAliases.append( 1218 MIPSTriples, MIPSTriples + llvm::array_lengthof(MIPSTriples)); 1219 break; 1220 case llvm::Triple::mips64el: 1221 LibDirs.append( 1222 MIPS64ELLibDirs, MIPS64ELLibDirs + llvm::array_lengthof(MIPS64ELLibDirs)); 1223 TripleAliases.append( 1224 MIPS64ELTriples, MIPS64ELTriples + llvm::array_lengthof(MIPS64ELTriples)); 1225 MultiarchLibDirs.append( 1226 MIPSELLibDirs, MIPSELLibDirs + llvm::array_lengthof(MIPSELLibDirs)); 1227 MultiarchTripleAliases.append( 1228 MIPSELTriples, MIPSELTriples + llvm::array_lengthof(MIPSELTriples)); 1229 break; 1230 case llvm::Triple::ppc: 1231 LibDirs.append(PPCLibDirs, PPCLibDirs + llvm::array_lengthof(PPCLibDirs)); 1232 TripleAliases.append( 1233 PPCTriples, PPCTriples + llvm::array_lengthof(PPCTriples)); 1234 MultiarchLibDirs.append( 1235 PPC64LibDirs, PPC64LibDirs + llvm::array_lengthof(PPC64LibDirs)); 1236 MultiarchTripleAliases.append( 1237 PPC64Triples, PPC64Triples + llvm::array_lengthof(PPC64Triples)); 1238 break; 1239 case llvm::Triple::ppc64: 1240 LibDirs.append( 1241 PPC64LibDirs, PPC64LibDirs + llvm::array_lengthof(PPC64LibDirs)); 1242 TripleAliases.append( 1243 PPC64Triples, PPC64Triples + llvm::array_lengthof(PPC64Triples)); 1244 MultiarchLibDirs.append( 1245 PPCLibDirs, PPCLibDirs + llvm::array_lengthof(PPCLibDirs)); 1246 MultiarchTripleAliases.append( 1247 PPCTriples, PPCTriples + llvm::array_lengthof(PPCTriples)); 1248 break; 1249 1250 default: 1251 // By default, just rely on the standard lib directories and the original 1252 // triple. 1253 break; 1254 } 1255 1256 // Always append the drivers target triple to the end, in case it doesn't 1257 // match any of our aliases. 1258 TripleAliases.push_back(TargetTriple.str()); 1259 1260 // Also include the multiarch variant if it's different. 1261 if (TargetTriple.str() != MultiarchTriple.str()) 1262 MultiarchTripleAliases.push_back(MultiarchTriple.str()); 1263} 1264 1265static bool isSoftFloatABI(const ArgList &Args) { 1266 Arg *A = Args.getLastArg(options::OPT_msoft_float, 1267 options::OPT_mhard_float, 1268 options::OPT_mfloat_abi_EQ); 1269 if (!A) return false; 1270 1271 return A->getOption().matches(options::OPT_msoft_float) || 1272 (A->getOption().matches(options::OPT_mfloat_abi_EQ) && 1273 A->getValue() == StringRef("soft")); 1274} 1275 1276static bool isMipsArch(llvm::Triple::ArchType Arch) { 1277 return Arch == llvm::Triple::mips || 1278 Arch == llvm::Triple::mipsel || 1279 Arch == llvm::Triple::mips64 || 1280 Arch == llvm::Triple::mips64el; 1281} 1282 1283static bool isMips16(const ArgList &Args) { 1284 Arg *A = Args.getLastArg(options::OPT_mips16, 1285 options::OPT_mno_mips16); 1286 return A && A->getOption().matches(options::OPT_mips16); 1287} 1288 1289static bool isMicroMips(const ArgList &Args) { 1290 Arg *A = Args.getLastArg(options::OPT_mmicromips, 1291 options::OPT_mno_micromips); 1292 return A && A->getOption().matches(options::OPT_mmicromips); 1293} 1294 1295// FIXME: There is the same routine in the Tools.cpp. 1296static bool hasMipsN32ABIArg(const ArgList &Args) { 1297 Arg *A = Args.getLastArg(options::OPT_mabi_EQ); 1298 return A && (A->getValue() == StringRef("n32")); 1299} 1300 1301static void appendMipsTargetSuffix(SmallVectorImpl<char> &Path, 1302 llvm::Triple::ArchType TargetArch, 1303 const ArgList &Args) { 1304 if (isMips16(Args)) 1305 llvm::sys::path::append(Path, "/mips16"); 1306 else if (isMicroMips(Args)) 1307 llvm::sys::path::append(Path, "/micromips"); 1308 1309 if (isSoftFloatABI(Args)) 1310 llvm::sys::path::append(Path, "/soft-float"); 1311 1312 if (TargetArch == llvm::Triple::mipsel || 1313 TargetArch == llvm::Triple::mips64el) 1314 llvm::sys::path::append(Path, "/el"); 1315} 1316 1317static StringRef getMipsTargetABISuffix(llvm::Triple::ArchType TargetArch, 1318 const ArgList &Args) { 1319 if (TargetArch == llvm::Triple::mips64 || 1320 TargetArch == llvm::Triple::mips64el) 1321 return hasMipsN32ABIArg(Args) ? "/n32" : "/64"; 1322 1323 return "/32"; 1324} 1325 1326static bool findTargetMultiarchSuffix(SmallString<32> &Suffix, 1327 StringRef Path, 1328 llvm::Triple::ArchType TargetArch, 1329 const ArgList &Args) { 1330 if (isMipsArch(TargetArch)) { 1331 StringRef ABISuffix = getMipsTargetABISuffix(TargetArch, Args); 1332 1333 // First build and check a complex path to crtbegin.o 1334 // depends on command line options (-mips16, -msoft-float, ...) 1335 // like mips-linux-gnu/4.7/mips16/soft-float/el/crtbegin.o 1336 appendMipsTargetSuffix(Suffix, TargetArch, Args); 1337 1338 if (TargetArch == llvm::Triple::mips64 || 1339 TargetArch == llvm::Triple::mips64el) 1340 llvm::sys::path::append(Suffix, ABISuffix); 1341 1342 if (llvm::sys::fs::exists(Path + Suffix.str() + "/crtbegin.o")) 1343 return true; 1344 1345 // Then fall back and probe a simple case like 1346 // mips-linux-gnu/4.7/32/crtbegin.o 1347 Suffix = ABISuffix; 1348 return llvm::sys::fs::exists(Path + Suffix.str() + "/crtbegin.o"); 1349 } 1350 1351 if (TargetArch == llvm::Triple::x86_64 || 1352 TargetArch == llvm::Triple::ppc64) 1353 Suffix = "/64"; 1354 else 1355 Suffix = "/32"; 1356 1357 return llvm::sys::fs::exists(Path + Suffix.str() + "/crtbegin.o"); 1358} 1359 1360void Generic_GCC::GCCInstallationDetector::ScanLibDirForGCCTriple( 1361 llvm::Triple::ArchType TargetArch, const ArgList &Args, 1362 const std::string &LibDir, 1363 StringRef CandidateTriple, bool NeedsMultiarchSuffix) { 1364 // There are various different suffixes involving the triple we 1365 // check for. We also record what is necessary to walk from each back 1366 // up to the lib directory. 1367 const std::string LibSuffixes[] = { 1368 "/gcc/" + CandidateTriple.str(), 1369 "/" + CandidateTriple.str() + "/gcc/" + CandidateTriple.str(), 1370 1371 // The Freescale PPC SDK has the gcc libraries in 1372 // <sysroot>/usr/lib/<triple>/x.y.z so have a look there as well. 1373 "/" + CandidateTriple.str(), 1374 1375 // Ubuntu has a strange mis-matched pair of triples that this happens to 1376 // match. 1377 // FIXME: It may be worthwhile to generalize this and look for a second 1378 // triple. 1379 "/i386-linux-gnu/gcc/" + CandidateTriple.str() 1380 }; 1381 const std::string InstallSuffixes[] = { 1382 "/../../..", 1383 "/../../../..", 1384 "/../..", 1385 "/../../../.." 1386 }; 1387 // Only look at the final, weird Ubuntu suffix for i386-linux-gnu. 1388 const unsigned NumLibSuffixes = (llvm::array_lengthof(LibSuffixes) - 1389 (TargetArch != llvm::Triple::x86)); 1390 for (unsigned i = 0; i < NumLibSuffixes; ++i) { 1391 StringRef LibSuffix = LibSuffixes[i]; 1392 llvm::error_code EC; 1393 for (llvm::sys::fs::directory_iterator LI(LibDir + LibSuffix, EC), LE; 1394 !EC && LI != LE; LI = LI.increment(EC)) { 1395 StringRef VersionText = llvm::sys::path::filename(LI->path()); 1396 GCCVersion CandidateVersion = GCCVersion::Parse(VersionText); 1397 static const GCCVersion MinVersion = { "4.1.1", 4, 1, 1, "" }; 1398 if (CandidateVersion < MinVersion) 1399 continue; 1400 if (CandidateVersion <= Version) 1401 continue; 1402 1403 // Some versions of SUSE and Fedora on ppc64 put 32-bit libs 1404 // in what would normally be GCCInstallPath and put the 64-bit 1405 // libs in a subdirectory named 64. The simple logic we follow is that 1406 // *if* there is a subdirectory of the right name with crtbegin.o in it, 1407 // we use that. If not, and if not a multiarch triple, we look for 1408 // crtbegin.o without the subdirectory. 1409 1410 SmallString<32> MultiarchSuffix; 1411 if (findTargetMultiarchSuffix(MultiarchSuffix, 1412 LI->path(), TargetArch, Args)) { 1413 GCCMultiarchSuffix = MultiarchSuffix.str(); 1414 } else { 1415 if (NeedsMultiarchSuffix || 1416 !llvm::sys::fs::exists(LI->path() + "/crtbegin.o")) 1417 continue; 1418 GCCMultiarchSuffix.clear(); 1419 } 1420 1421 Version = CandidateVersion; 1422 GCCTriple.setTriple(CandidateTriple); 1423 // FIXME: We hack together the directory name here instead of 1424 // using LI to ensure stable path separators across Windows and 1425 // Linux. 1426 GCCInstallPath = LibDir + LibSuffixes[i] + "/" + VersionText.str(); 1427 GCCParentLibPath = GCCInstallPath + InstallSuffixes[i]; 1428 IsValid = true; 1429 } 1430 } 1431} 1432 1433Generic_GCC::Generic_GCC(const Driver &D, const llvm::Triple& Triple, 1434 const ArgList &Args) 1435 : ToolChain(D, Triple, Args), GCCInstallation(getDriver(), Triple, Args) { 1436 getProgramPaths().push_back(getDriver().getInstalledDir()); 1437 if (getDriver().getInstalledDir() != getDriver().Dir) 1438 getProgramPaths().push_back(getDriver().Dir); 1439} 1440 1441Generic_GCC::~Generic_GCC() { 1442} 1443 1444Tool *Generic_GCC::getTool(Action::ActionClass AC) const { 1445 switch (AC) { 1446 case Action::PreprocessJobClass: 1447 if (!Preprocess) 1448 Preprocess.reset(new tools::gcc::Preprocess(*this)); 1449 return Preprocess.get(); 1450 case Action::PrecompileJobClass: 1451 if (!Precompile) 1452 Precompile.reset(new tools::gcc::Precompile(*this)); 1453 return Precompile.get(); 1454 case Action::CompileJobClass: 1455 if (!Compile) 1456 Compile.reset(new tools::gcc::Compile(*this)); 1457 return Compile.get(); 1458 default: 1459 return ToolChain::getTool(AC); 1460 } 1461} 1462 1463Tool *Generic_GCC::buildAssembler() const { 1464 return new tools::gcc::Assemble(*this); 1465} 1466 1467Tool *Generic_GCC::buildLinker() const { 1468 return new tools::gcc::Link(*this); 1469} 1470 1471bool Generic_GCC::IsUnwindTablesDefault() const { 1472 return getArch() == llvm::Triple::x86_64; 1473} 1474 1475bool Generic_GCC::isPICDefault() const { 1476 return false; 1477} 1478 1479bool Generic_GCC::isPIEDefault() const { 1480 return false; 1481} 1482 1483bool Generic_GCC::isPICDefaultForced() const { 1484 return false; 1485} 1486 1487/// Hexagon Toolchain 1488 1489std::string Hexagon_TC::GetGnuDir(const std::string &InstalledDir) { 1490 1491 // Locate the rest of the toolchain ... 1492 if (strlen(GCC_INSTALL_PREFIX)) 1493 return std::string(GCC_INSTALL_PREFIX); 1494 1495 std::string InstallRelDir = InstalledDir + "/../../gnu"; 1496 if (llvm::sys::fs::exists(InstallRelDir)) 1497 return InstallRelDir; 1498 1499 std::string PrefixRelDir = std::string(LLVM_PREFIX) + "/../gnu"; 1500 if (llvm::sys::fs::exists(PrefixRelDir)) 1501 return PrefixRelDir; 1502 1503 return InstallRelDir; 1504} 1505 1506static void GetHexagonLibraryPaths( 1507 const ArgList &Args, 1508 const std::string Ver, 1509 const std::string MarchString, 1510 const std::string &InstalledDir, 1511 ToolChain::path_list *LibPaths) 1512{ 1513 bool buildingLib = Args.hasArg(options::OPT_shared); 1514 1515 //---------------------------------------------------------------------------- 1516 // -L Args 1517 //---------------------------------------------------------------------------- 1518 for (arg_iterator 1519 it = Args.filtered_begin(options::OPT_L), 1520 ie = Args.filtered_end(); 1521 it != ie; 1522 ++it) { 1523 for (unsigned i = 0, e = (*it)->getNumValues(); i != e; ++i) 1524 LibPaths->push_back((*it)->getValue(i)); 1525 } 1526 1527 //---------------------------------------------------------------------------- 1528 // Other standard paths 1529 //---------------------------------------------------------------------------- 1530 const std::string MarchSuffix = "/" + MarchString; 1531 const std::string G0Suffix = "/G0"; 1532 const std::string MarchG0Suffix = MarchSuffix + G0Suffix; 1533 const std::string RootDir = Hexagon_TC::GetGnuDir(InstalledDir) + "/"; 1534 1535 // lib/gcc/hexagon/... 1536 std::string LibGCCHexagonDir = RootDir + "lib/gcc/hexagon/"; 1537 if (buildingLib) { 1538 LibPaths->push_back(LibGCCHexagonDir + Ver + MarchG0Suffix); 1539 LibPaths->push_back(LibGCCHexagonDir + Ver + G0Suffix); 1540 } 1541 LibPaths->push_back(LibGCCHexagonDir + Ver + MarchSuffix); 1542 LibPaths->push_back(LibGCCHexagonDir + Ver); 1543 1544 // lib/gcc/... 1545 LibPaths->push_back(RootDir + "lib/gcc"); 1546 1547 // hexagon/lib/... 1548 std::string HexagonLibDir = RootDir + "hexagon/lib"; 1549 if (buildingLib) { 1550 LibPaths->push_back(HexagonLibDir + MarchG0Suffix); 1551 LibPaths->push_back(HexagonLibDir + G0Suffix); 1552 } 1553 LibPaths->push_back(HexagonLibDir + MarchSuffix); 1554 LibPaths->push_back(HexagonLibDir); 1555} 1556 1557Hexagon_TC::Hexagon_TC(const Driver &D, const llvm::Triple &Triple, 1558 const ArgList &Args) 1559 : Linux(D, Triple, Args) { 1560 const std::string InstalledDir(getDriver().getInstalledDir()); 1561 const std::string GnuDir = Hexagon_TC::GetGnuDir(InstalledDir); 1562 1563 // Note: Generic_GCC::Generic_GCC adds InstalledDir and getDriver().Dir to 1564 // program paths 1565 const std::string BinDir(GnuDir + "/bin"); 1566 if (llvm::sys::fs::exists(BinDir)) 1567 getProgramPaths().push_back(BinDir); 1568 1569 // Determine version of GCC libraries and headers to use. 1570 const std::string HexagonDir(GnuDir + "/lib/gcc/hexagon"); 1571 llvm::error_code ec; 1572 GCCVersion MaxVersion= GCCVersion::Parse("0.0.0"); 1573 for (llvm::sys::fs::directory_iterator di(HexagonDir, ec), de; 1574 !ec && di != de; di = di.increment(ec)) { 1575 GCCVersion cv = GCCVersion::Parse(llvm::sys::path::filename(di->path())); 1576 if (MaxVersion < cv) 1577 MaxVersion = cv; 1578 } 1579 GCCLibAndIncVersion = MaxVersion; 1580 1581 ToolChain::path_list *LibPaths= &getFilePaths(); 1582 1583 // Remove paths added by Linux toolchain. Currently Hexagon_TC really targets 1584 // 'elf' OS type, so the Linux paths are not appropriate. When we actually 1585 // support 'linux' we'll need to fix this up 1586 LibPaths->clear(); 1587 1588 GetHexagonLibraryPaths( 1589 Args, 1590 GetGCCLibAndIncVersion(), 1591 GetTargetCPU(Args), 1592 InstalledDir, 1593 LibPaths); 1594} 1595 1596Hexagon_TC::~Hexagon_TC() { 1597} 1598 1599Tool *Hexagon_TC::buildAssembler() const { 1600 return new tools::hexagon::Assemble(*this); 1601} 1602 1603Tool *Hexagon_TC::buildLinker() const { 1604 return new tools::hexagon::Link(*this); 1605} 1606 1607void Hexagon_TC::AddClangSystemIncludeArgs(const ArgList &DriverArgs, 1608 ArgStringList &CC1Args) const { 1609 const Driver &D = getDriver(); 1610 1611 if (DriverArgs.hasArg(options::OPT_nostdinc) || 1612 DriverArgs.hasArg(options::OPT_nostdlibinc)) 1613 return; 1614 1615 llvm::sys::Path InstallDir(D.InstalledDir); 1616 std::string Ver(GetGCCLibAndIncVersion()); 1617 std::string GnuDir = Hexagon_TC::GetGnuDir(D.InstalledDir); 1618 std::string HexagonDir(GnuDir + "/lib/gcc/hexagon/" + Ver); 1619 addExternCSystemInclude(DriverArgs, CC1Args, HexagonDir + "/include"); 1620 addExternCSystemInclude(DriverArgs, CC1Args, HexagonDir + "/include-fixed"); 1621 addExternCSystemInclude(DriverArgs, CC1Args, GnuDir + "/hexagon/include"); 1622} 1623 1624void Hexagon_TC::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs, 1625 ArgStringList &CC1Args) const { 1626 1627 if (DriverArgs.hasArg(options::OPT_nostdlibinc) || 1628 DriverArgs.hasArg(options::OPT_nostdincxx)) 1629 return; 1630 1631 const Driver &D = getDriver(); 1632 std::string Ver(GetGCCLibAndIncVersion()); 1633 llvm::sys::Path IncludeDir(Hexagon_TC::GetGnuDir(D.InstalledDir)); 1634 1635 IncludeDir.appendComponent("hexagon/include/c++/"); 1636 IncludeDir.appendComponent(Ver); 1637 addSystemInclude(DriverArgs, CC1Args, IncludeDir.str()); 1638} 1639 1640ToolChain::CXXStdlibType 1641Hexagon_TC::GetCXXStdlibType(const ArgList &Args) const { 1642 Arg *A = Args.getLastArg(options::OPT_stdlib_EQ); 1643 if (!A) 1644 return ToolChain::CST_Libstdcxx; 1645 1646 StringRef Value = A->getValue(); 1647 if (Value != "libstdc++") { 1648 getDriver().Diag(diag::err_drv_invalid_stdlib_name) 1649 << A->getAsString(Args); 1650 } 1651 1652 return ToolChain::CST_Libstdcxx; 1653} 1654 1655static Arg *GetLastHexagonArchArg(const ArgList &Args) 1656{ 1657 Arg *A = NULL; 1658 1659 for (ArgList::const_iterator it = Args.begin(), ie = Args.end(); 1660 it != ie; ++it) { 1661 if ((*it)->getOption().matches(options::OPT_march_EQ) || 1662 (*it)->getOption().matches(options::OPT_mcpu_EQ)) { 1663 A = *it; 1664 A->claim(); 1665 } else if ((*it)->getOption().matches(options::OPT_m_Joined)) { 1666 StringRef Value = (*it)->getValue(0); 1667 if (Value.startswith("v")) { 1668 A = *it; 1669 A->claim(); 1670 } 1671 } 1672 } 1673 return A; 1674} 1675 1676StringRef Hexagon_TC::GetTargetCPU(const ArgList &Args) 1677{ 1678 // Select the default CPU (v4) if none was given or detection failed. 1679 Arg *A = GetLastHexagonArchArg (Args); 1680 if (A) { 1681 StringRef WhichHexagon = A->getValue(); 1682 if (WhichHexagon.startswith("hexagon")) 1683 return WhichHexagon.substr(sizeof("hexagon") - 1); 1684 if (WhichHexagon != "") 1685 return WhichHexagon; 1686 } 1687 1688 return "v4"; 1689} 1690// End Hexagon 1691 1692/// TCEToolChain - A tool chain using the llvm bitcode tools to perform 1693/// all subcommands. See http://tce.cs.tut.fi for our peculiar target. 1694/// Currently does not support anything else but compilation. 1695 1696TCEToolChain::TCEToolChain(const Driver &D, const llvm::Triple& Triple, 1697 const ArgList &Args) 1698 : ToolChain(D, Triple, Args) { 1699 // Path mangling to find libexec 1700 std::string Path(getDriver().Dir); 1701 1702 Path += "/../libexec"; 1703 getProgramPaths().push_back(Path); 1704} 1705 1706TCEToolChain::~TCEToolChain() { 1707} 1708 1709bool TCEToolChain::IsMathErrnoDefault() const { 1710 return true; 1711} 1712 1713bool TCEToolChain::isPICDefault() const { 1714 return false; 1715} 1716 1717bool TCEToolChain::isPIEDefault() const { 1718 return false; 1719} 1720 1721bool TCEToolChain::isPICDefaultForced() const { 1722 return false; 1723} 1724 1725/// OpenBSD - OpenBSD tool chain which can call as(1) and ld(1) directly. 1726 1727OpenBSD::OpenBSD(const Driver &D, const llvm::Triple& Triple, const ArgList &Args) 1728 : Generic_ELF(D, Triple, Args) { 1729 getFilePaths().push_back(getDriver().Dir + "/../lib"); 1730 getFilePaths().push_back("/usr/lib"); 1731} 1732 1733Tool *OpenBSD::buildAssembler() const { 1734 return new tools::openbsd::Assemble(*this); 1735} 1736 1737Tool *OpenBSD::buildLinker() const { 1738 return new tools::openbsd::Link(*this); 1739} 1740 1741/// Bitrig - Bitrig tool chain which can call as(1) and ld(1) directly. 1742 1743Bitrig::Bitrig(const Driver &D, const llvm::Triple& Triple, const ArgList &Args) 1744 : Generic_ELF(D, Triple, Args) { 1745 getFilePaths().push_back(getDriver().Dir + "/../lib"); 1746 getFilePaths().push_back("/usr/lib"); 1747} 1748 1749Tool *Bitrig::buildAssembler() const { 1750 return new tools::bitrig::Assemble(*this); 1751} 1752 1753Tool *Bitrig::buildLinker() const { 1754 return new tools::bitrig::Link(*this); 1755} 1756 1757void Bitrig::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs, 1758 ArgStringList &CC1Args) const { 1759 if (DriverArgs.hasArg(options::OPT_nostdlibinc) || 1760 DriverArgs.hasArg(options::OPT_nostdincxx)) 1761 return; 1762 1763 switch (GetCXXStdlibType(DriverArgs)) { 1764 case ToolChain::CST_Libcxx: 1765 addSystemInclude(DriverArgs, CC1Args, 1766 getDriver().SysRoot + "/usr/include/c++/"); 1767 break; 1768 case ToolChain::CST_Libstdcxx: 1769 addSystemInclude(DriverArgs, CC1Args, 1770 getDriver().SysRoot + "/usr/include/c++/stdc++"); 1771 addSystemInclude(DriverArgs, CC1Args, 1772 getDriver().SysRoot + "/usr/include/c++/stdc++/backward"); 1773 1774 StringRef Triple = getTriple().str(); 1775 if (Triple.startswith("amd64")) 1776 addSystemInclude(DriverArgs, CC1Args, 1777 getDriver().SysRoot + "/usr/include/c++/stdc++/x86_64" + 1778 Triple.substr(5)); 1779 else 1780 addSystemInclude(DriverArgs, CC1Args, 1781 getDriver().SysRoot + "/usr/include/c++/stdc++/" + 1782 Triple); 1783 break; 1784 } 1785} 1786 1787void Bitrig::AddCXXStdlibLibArgs(const ArgList &Args, 1788 ArgStringList &CmdArgs) const { 1789 switch (GetCXXStdlibType(Args)) { 1790 case ToolChain::CST_Libcxx: 1791 CmdArgs.push_back("-lc++"); 1792 CmdArgs.push_back("-lcxxrt"); 1793 // Include supc++ to provide Unwind until provided by libcxx. 1794 CmdArgs.push_back("-lgcc"); 1795 break; 1796 case ToolChain::CST_Libstdcxx: 1797 CmdArgs.push_back("-lstdc++"); 1798 break; 1799 } 1800} 1801 1802/// FreeBSD - FreeBSD tool chain which can call as(1) and ld(1) directly. 1803 1804FreeBSD::FreeBSD(const Driver &D, const llvm::Triple& Triple, const ArgList &Args) 1805 : Generic_ELF(D, Triple, Args) { 1806 1807 // When targeting 32-bit platforms, look for '/usr/lib32/crt1.o' and fall 1808 // back to '/usr/lib' if it doesn't exist. 1809 if ((Triple.getArch() == llvm::Triple::x86 || 1810 Triple.getArch() == llvm::Triple::ppc) && 1811 llvm::sys::fs::exists(getDriver().SysRoot + "/usr/lib32/crt1.o")) 1812 getFilePaths().push_back(getDriver().SysRoot + "/usr/lib32"); 1813 else 1814 getFilePaths().push_back(getDriver().SysRoot + "/usr/lib"); 1815} 1816 1817Tool *FreeBSD::buildAssembler() const { 1818 return new tools::freebsd::Assemble(*this); 1819} 1820 1821Tool *FreeBSD::buildLinker() const { 1822 return new tools::freebsd::Link(*this); 1823} 1824 1825bool FreeBSD::UseSjLjExceptions() const { 1826 // FreeBSD uses SjLj exceptions on ARM oabi. 1827 switch (getTriple().getEnvironment()) { 1828 case llvm::Triple::GNUEABI: 1829 case llvm::Triple::EABI: 1830 return false; 1831 1832 default: 1833 return (getTriple().getArch() == llvm::Triple::arm || 1834 getTriple().getArch() == llvm::Triple::thumb); 1835 } 1836} 1837 1838/// NetBSD - NetBSD tool chain which can call as(1) and ld(1) directly. 1839 1840NetBSD::NetBSD(const Driver &D, const llvm::Triple& Triple, const ArgList &Args) 1841 : Generic_ELF(D, Triple, Args) { 1842 1843 if (getDriver().UseStdLib) { 1844 // When targeting a 32-bit platform, try the special directory used on 1845 // 64-bit hosts, and only fall back to the main library directory if that 1846 // doesn't work. 1847 // FIXME: It'd be nicer to test if this directory exists, but I'm not sure 1848 // what all logic is needed to emulate the '=' prefix here. 1849 if (Triple.getArch() == llvm::Triple::x86) 1850 getFilePaths().push_back("=/usr/lib/i386"); 1851 1852 getFilePaths().push_back("=/usr/lib"); 1853 } 1854} 1855 1856Tool *NetBSD::buildAssembler() const { 1857 return new tools::netbsd::Assemble(*this); 1858} 1859 1860Tool *NetBSD::buildLinker() const { 1861 return new tools::netbsd::Link(*this); 1862} 1863 1864/// Minix - Minix tool chain which can call as(1) and ld(1) directly. 1865 1866Minix::Minix(const Driver &D, const llvm::Triple& Triple, const ArgList &Args) 1867 : Generic_ELF(D, Triple, Args) { 1868 getFilePaths().push_back(getDriver().Dir + "/../lib"); 1869 getFilePaths().push_back("/usr/lib"); 1870} 1871 1872Tool *Minix::buildAssembler() const { 1873 return new tools::minix::Assemble(*this); 1874} 1875 1876Tool *Minix::buildLinker() const { 1877 return new tools::minix::Link(*this); 1878} 1879 1880/// AuroraUX - AuroraUX tool chain which can call as(1) and ld(1) directly. 1881 1882AuroraUX::AuroraUX(const Driver &D, const llvm::Triple& Triple, 1883 const ArgList &Args) 1884 : Generic_GCC(D, Triple, Args) { 1885 1886 getProgramPaths().push_back(getDriver().getInstalledDir()); 1887 if (getDriver().getInstalledDir() != getDriver().Dir) 1888 getProgramPaths().push_back(getDriver().Dir); 1889 1890 getFilePaths().push_back(getDriver().Dir + "/../lib"); 1891 getFilePaths().push_back("/usr/lib"); 1892 getFilePaths().push_back("/usr/sfw/lib"); 1893 getFilePaths().push_back("/opt/gcc4/lib"); 1894 getFilePaths().push_back("/opt/gcc4/lib/gcc/i386-pc-solaris2.11/4.2.4"); 1895 1896} 1897 1898Tool *AuroraUX::buildAssembler() const { 1899 return new tools::auroraux::Assemble(*this); 1900} 1901 1902Tool *AuroraUX::buildLinker() const { 1903 return new tools::auroraux::Link(*this); 1904} 1905 1906/// Solaris - Solaris tool chain which can call as(1) and ld(1) directly. 1907 1908Solaris::Solaris(const Driver &D, const llvm::Triple& Triple, 1909 const ArgList &Args) 1910 : Generic_GCC(D, Triple, Args) { 1911 1912 getProgramPaths().push_back(getDriver().getInstalledDir()); 1913 if (getDriver().getInstalledDir() != getDriver().Dir) 1914 getProgramPaths().push_back(getDriver().Dir); 1915 1916 getFilePaths().push_back(getDriver().Dir + "/../lib"); 1917 getFilePaths().push_back("/usr/lib"); 1918} 1919 1920Tool *Solaris::buildAssembler() const { 1921 return new tools::solaris::Assemble(*this); 1922} 1923 1924Tool *Solaris::buildLinker() const { 1925 return new tools::solaris::Link(*this); 1926} 1927 1928/// Distribution (very bare-bones at the moment). 1929 1930enum Distro { 1931 ArchLinux, 1932 DebianLenny, 1933 DebianSqueeze, 1934 DebianWheezy, 1935 DebianJessie, 1936 Exherbo, 1937 RHEL4, 1938 RHEL5, 1939 RHEL6, 1940 Fedora13, 1941 Fedora14, 1942 Fedora15, 1943 Fedora16, 1944 FedoraRawhide, 1945 OpenSuse11_3, 1946 OpenSuse11_4, 1947 OpenSuse12_1, 1948 OpenSuse12_2, 1949 UbuntuHardy, 1950 UbuntuIntrepid, 1951 UbuntuJaunty, 1952 UbuntuKarmic, 1953 UbuntuLucid, 1954 UbuntuMaverick, 1955 UbuntuNatty, 1956 UbuntuOneiric, 1957 UbuntuPrecise, 1958 UbuntuQuantal, 1959 UbuntuRaring, 1960 UnknownDistro 1961}; 1962 1963static bool IsRedhat(enum Distro Distro) { 1964 return (Distro >= Fedora13 && Distro <= FedoraRawhide) || 1965 (Distro >= RHEL4 && Distro <= RHEL6); 1966} 1967 1968static bool IsOpenSuse(enum Distro Distro) { 1969 return Distro >= OpenSuse11_3 && Distro <= OpenSuse12_2; 1970} 1971 1972static bool IsDebian(enum Distro Distro) { 1973 return Distro >= DebianLenny && Distro <= DebianJessie; 1974} 1975 1976static bool IsUbuntu(enum Distro Distro) { 1977 return Distro >= UbuntuHardy && Distro <= UbuntuRaring; 1978} 1979 1980static Distro DetectDistro(llvm::Triple::ArchType Arch) { 1981 OwningPtr<llvm::MemoryBuffer> File; 1982 if (!llvm::MemoryBuffer::getFile("/etc/lsb-release", File)) { 1983 StringRef Data = File.get()->getBuffer(); 1984 SmallVector<StringRef, 8> Lines; 1985 Data.split(Lines, "\n"); 1986 Distro Version = UnknownDistro; 1987 for (unsigned i = 0, s = Lines.size(); i != s; ++i) 1988 if (Version == UnknownDistro && Lines[i].startswith("DISTRIB_CODENAME=")) 1989 Version = llvm::StringSwitch<Distro>(Lines[i].substr(17)) 1990 .Case("hardy", UbuntuHardy) 1991 .Case("intrepid", UbuntuIntrepid) 1992 .Case("jaunty", UbuntuJaunty) 1993 .Case("karmic", UbuntuKarmic) 1994 .Case("lucid", UbuntuLucid) 1995 .Case("maverick", UbuntuMaverick) 1996 .Case("natty", UbuntuNatty) 1997 .Case("oneiric", UbuntuOneiric) 1998 .Case("precise", UbuntuPrecise) 1999 .Case("quantal", UbuntuQuantal) 2000 .Case("raring", UbuntuRaring) 2001 .Default(UnknownDistro); 2002 return Version; 2003 } 2004 2005 if (!llvm::MemoryBuffer::getFile("/etc/redhat-release", File)) { 2006 StringRef Data = File.get()->getBuffer(); 2007 if (Data.startswith("Fedora release 16")) 2008 return Fedora16; 2009 else if (Data.startswith("Fedora release 15")) 2010 return Fedora15; 2011 else if (Data.startswith("Fedora release 14")) 2012 return Fedora14; 2013 else if (Data.startswith("Fedora release 13")) 2014 return Fedora13; 2015 else if (Data.startswith("Fedora release") && 2016 Data.find("Rawhide") != StringRef::npos) 2017 return FedoraRawhide; 2018 else if (Data.startswith("Red Hat Enterprise Linux") && 2019 Data.find("release 6") != StringRef::npos) 2020 return RHEL6; 2021 else if ((Data.startswith("Red Hat Enterprise Linux") || 2022 Data.startswith("CentOS")) && 2023 Data.find("release 5") != StringRef::npos) 2024 return RHEL5; 2025 else if ((Data.startswith("Red Hat Enterprise Linux") || 2026 Data.startswith("CentOS")) && 2027 Data.find("release 4") != StringRef::npos) 2028 return RHEL4; 2029 return UnknownDistro; 2030 } 2031 2032 if (!llvm::MemoryBuffer::getFile("/etc/debian_version", File)) { 2033 StringRef Data = File.get()->getBuffer(); 2034 if (Data[0] == '5') 2035 return DebianLenny; 2036 else if (Data.startswith("squeeze/sid") || Data[0] == '6') 2037 return DebianSqueeze; 2038 else if (Data.startswith("wheezy/sid") || Data[0] == '7') 2039 return DebianWheezy; 2040 else if (Data.startswith("jessie/sid") || Data[0] == '8') 2041 return DebianJessie; 2042 return UnknownDistro; 2043 } 2044 2045 if (!llvm::MemoryBuffer::getFile("/etc/SuSE-release", File)) 2046 return llvm::StringSwitch<Distro>(File.get()->getBuffer()) 2047 .StartsWith("openSUSE 11.3", OpenSuse11_3) 2048 .StartsWith("openSUSE 11.4", OpenSuse11_4) 2049 .StartsWith("openSUSE 12.1", OpenSuse12_1) 2050 .StartsWith("openSUSE 12.2", OpenSuse12_2) 2051 .Default(UnknownDistro); 2052 2053 bool Exists; 2054 if (!llvm::sys::fs::exists("/etc/exherbo-release", Exists) && Exists) 2055 return Exherbo; 2056 2057 if (!llvm::sys::fs::exists("/etc/arch-release", Exists) && Exists) 2058 return ArchLinux; 2059 2060 return UnknownDistro; 2061} 2062 2063/// \brief Get our best guess at the multiarch triple for a target. 2064/// 2065/// Debian-based systems are starting to use a multiarch setup where they use 2066/// a target-triple directory in the library and header search paths. 2067/// Unfortunately, this triple does not align with the vanilla target triple, 2068/// so we provide a rough mapping here. 2069static std::string getMultiarchTriple(const llvm::Triple TargetTriple, 2070 StringRef SysRoot) { 2071 // For most architectures, just use whatever we have rather than trying to be 2072 // clever. 2073 switch (TargetTriple.getArch()) { 2074 default: 2075 return TargetTriple.str(); 2076 2077 // We use the existence of '/lib/<triple>' as a directory to detect some 2078 // common linux triples that don't quite match the Clang triple for both 2079 // 32-bit and 64-bit targets. Multiarch fixes its install triples to these 2080 // regardless of what the actual target triple is. 2081 case llvm::Triple::arm: 2082 case llvm::Triple::thumb: 2083 if (TargetTriple.getEnvironment() == llvm::Triple::GNUEABIHF) { 2084 if (llvm::sys::fs::exists(SysRoot + "/lib/arm-linux-gnueabihf")) 2085 return "arm-linux-gnueabihf"; 2086 } else { 2087 if (llvm::sys::fs::exists(SysRoot + "/lib/arm-linux-gnueabi")) 2088 return "arm-linux-gnueabi"; 2089 } 2090 return TargetTriple.str(); 2091 case llvm::Triple::x86: 2092 if (llvm::sys::fs::exists(SysRoot + "/lib/i386-linux-gnu")) 2093 return "i386-linux-gnu"; 2094 return TargetTriple.str(); 2095 case llvm::Triple::x86_64: 2096 if (llvm::sys::fs::exists(SysRoot + "/lib/x86_64-linux-gnu")) 2097 return "x86_64-linux-gnu"; 2098 return TargetTriple.str(); 2099 case llvm::Triple::aarch64: 2100 if (llvm::sys::fs::exists(SysRoot + "/lib/aarch64-linux-gnu")) 2101 return "aarch64-linux-gnu"; 2102 case llvm::Triple::mips: 2103 if (llvm::sys::fs::exists(SysRoot + "/lib/mips-linux-gnu")) 2104 return "mips-linux-gnu"; 2105 return TargetTriple.str(); 2106 case llvm::Triple::mipsel: 2107 if (llvm::sys::fs::exists(SysRoot + "/lib/mipsel-linux-gnu")) 2108 return "mipsel-linux-gnu"; 2109 return TargetTriple.str(); 2110 case llvm::Triple::ppc: 2111 if (llvm::sys::fs::exists(SysRoot + "/lib/powerpc-linux-gnuspe")) 2112 return "powerpc-linux-gnuspe"; 2113 if (llvm::sys::fs::exists(SysRoot + "/lib/powerpc-linux-gnu")) 2114 return "powerpc-linux-gnu"; 2115 return TargetTriple.str(); 2116 case llvm::Triple::ppc64: 2117 if (llvm::sys::fs::exists(SysRoot + "/lib/powerpc64-linux-gnu")) 2118 return "powerpc64-linux-gnu"; 2119 return TargetTriple.str(); 2120 } 2121} 2122 2123static void addPathIfExists(Twine Path, ToolChain::path_list &Paths) { 2124 if (llvm::sys::fs::exists(Path)) Paths.push_back(Path.str()); 2125} 2126 2127static bool isMipsR2Arch(llvm::Triple::ArchType Arch, 2128 const ArgList &Args) { 2129 if (Arch != llvm::Triple::mips && 2130 Arch != llvm::Triple::mipsel) 2131 return false; 2132 2133 Arg *A = Args.getLastArg(options::OPT_march_EQ, 2134 options::OPT_mcpu_EQ, 2135 options::OPT_mips_CPUs_Group); 2136 2137 if (!A) 2138 return false; 2139 2140 if (A->getOption().matches(options::OPT_mips_CPUs_Group)) 2141 return A->getOption().matches(options::OPT_mips32r2); 2142 2143 return A->getValue() == StringRef("mips32r2"); 2144} 2145 2146static StringRef getMultilibDir(const llvm::Triple &Triple, 2147 const ArgList &Args) { 2148 if (!isMipsArch(Triple.getArch())) 2149 return Triple.isArch32Bit() ? "lib32" : "lib64"; 2150 2151 // lib32 directory has a special meaning on MIPS targets. 2152 // It contains N32 ABI binaries. Use this folder if produce 2153 // code for N32 ABI only. 2154 if (hasMipsN32ABIArg(Args)) 2155 return "lib32"; 2156 2157 return Triple.isArch32Bit() ? "lib" : "lib64"; 2158} 2159 2160Linux::Linux(const Driver &D, const llvm::Triple &Triple, const ArgList &Args) 2161 : Generic_ELF(D, Triple, Args) { 2162 llvm::Triple::ArchType Arch = Triple.getArch(); 2163 std::string SysRoot = computeSysRoot(Args); 2164 2165 // OpenSuse stores the linker with the compiler, add that to the search 2166 // path. 2167 ToolChain::path_list &PPaths = getProgramPaths(); 2168 PPaths.push_back(Twine(GCCInstallation.getParentLibPath() + "/../" + 2169 GCCInstallation.getTriple().str() + "/bin").str()); 2170 2171 Linker = GetProgramPath("ld"); 2172 2173 Distro Distro = DetectDistro(Arch); 2174 2175 if (IsOpenSuse(Distro) || IsUbuntu(Distro)) { 2176 ExtraOpts.push_back("-z"); 2177 ExtraOpts.push_back("relro"); 2178 } 2179 2180 if (Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb) 2181 ExtraOpts.push_back("-X"); 2182 2183 const bool IsAndroid = Triple.getEnvironment() == llvm::Triple::Android; 2184 const bool IsMips = isMipsArch(Arch); 2185 2186 if (IsMips && !SysRoot.empty()) 2187 ExtraOpts.push_back("--sysroot=" + SysRoot); 2188 2189 // Do not use 'gnu' hash style for Mips targets because .gnu.hash 2190 // and the MIPS ABI require .dynsym to be sorted in different ways. 2191 // .gnu.hash needs symbols to be grouped by hash code whereas the MIPS 2192 // ABI requires a mapping between the GOT and the symbol table. 2193 // Android loader does not support .gnu.hash. 2194 if (!IsMips && !IsAndroid) { 2195 if (IsRedhat(Distro) || IsOpenSuse(Distro) || 2196 (IsUbuntu(Distro) && Distro >= UbuntuMaverick)) 2197 ExtraOpts.push_back("--hash-style=gnu"); 2198 2199 if (IsDebian(Distro) || IsOpenSuse(Distro) || Distro == UbuntuLucid || 2200 Distro == UbuntuJaunty || Distro == UbuntuKarmic) 2201 ExtraOpts.push_back("--hash-style=both"); 2202 } 2203 2204 if (IsRedhat(Distro)) 2205 ExtraOpts.push_back("--no-add-needed"); 2206 2207 if (Distro == DebianSqueeze || Distro == DebianWheezy || 2208 Distro == DebianJessie || IsOpenSuse(Distro) || 2209 (IsRedhat(Distro) && Distro != RHEL4 && Distro != RHEL5) || 2210 (IsUbuntu(Distro) && Distro >= UbuntuKarmic)) 2211 ExtraOpts.push_back("--build-id"); 2212 2213 if (IsOpenSuse(Distro)) 2214 ExtraOpts.push_back("--enable-new-dtags"); 2215 2216 // The selection of paths to try here is designed to match the patterns which 2217 // the GCC driver itself uses, as this is part of the GCC-compatible driver. 2218 // This was determined by running GCC in a fake filesystem, creating all 2219 // possible permutations of these directories, and seeing which ones it added 2220 // to the link paths. 2221 path_list &Paths = getFilePaths(); 2222 2223 const std::string Multilib = getMultilibDir(Triple, Args); 2224 const std::string MultiarchTriple = getMultiarchTriple(Triple, SysRoot); 2225 2226 // Add the multilib suffixed paths where they are available. 2227 if (GCCInstallation.isValid()) { 2228 const llvm::Triple &GCCTriple = GCCInstallation.getTriple(); 2229 const std::string &LibPath = GCCInstallation.getParentLibPath(); 2230 2231 if (IsAndroid && isMipsR2Arch(Triple.getArch(), Args)) 2232 addPathIfExists(GCCInstallation.getInstallPath() + 2233 GCCInstallation.getMultiarchSuffix() + 2234 "/mips-r2", 2235 Paths); 2236 else 2237 addPathIfExists((GCCInstallation.getInstallPath() + 2238 GCCInstallation.getMultiarchSuffix()), 2239 Paths); 2240 2241 // If the GCC installation we found is inside of the sysroot, we want to 2242 // prefer libraries installed in the parent prefix of the GCC installation. 2243 // It is important to *not* use these paths when the GCC installation is 2244 // outside of the system root as that can pick up unintended libraries. 2245 // This usually happens when there is an external cross compiler on the 2246 // host system, and a more minimal sysroot available that is the target of 2247 // the cross. 2248 if (StringRef(LibPath).startswith(SysRoot)) { 2249 addPathIfExists(LibPath + "/../" + GCCTriple.str() + "/lib/../" + Multilib, 2250 Paths); 2251 addPathIfExists(LibPath + "/" + MultiarchTriple, Paths); 2252 addPathIfExists(LibPath + "/../" + Multilib, Paths); 2253 } 2254 // On Android, libraries in the parent prefix of the GCC installation are 2255 // preferred to the ones under sysroot. 2256 if (IsAndroid) { 2257 addPathIfExists(LibPath + "/../" + GCCTriple.str() + "/lib", Paths); 2258 } 2259 // Sourcery CodeBench MIPS toolchain holds some libraries under 2260 // the parent prefix of the GCC installation. 2261 if (IsMips) { 2262 SmallString<128> Suffix; 2263 appendMipsTargetSuffix(Suffix, Arch, Args); 2264 addPathIfExists(LibPath + "/../" + GCCTriple.str() + "/lib/../" + 2265 Multilib + Suffix.str(), 2266 Paths); 2267 } 2268 } 2269 addPathIfExists(SysRoot + "/lib/" + MultiarchTriple, Paths); 2270 addPathIfExists(SysRoot + "/lib/../" + Multilib, Paths); 2271 addPathIfExists(SysRoot + "/usr/lib/" + MultiarchTriple, Paths); 2272 addPathIfExists(SysRoot + "/usr/lib/../" + Multilib, Paths); 2273 2274 // Try walking via the GCC triple path in case of multiarch GCC 2275 // installations with strange symlinks. 2276 if (GCCInstallation.isValid()) 2277 addPathIfExists(SysRoot + "/usr/lib/" + GCCInstallation.getTriple().str() + 2278 "/../../" + Multilib, Paths); 2279 2280 // Add the non-multilib suffixed paths (if potentially different). 2281 if (GCCInstallation.isValid()) { 2282 const std::string &LibPath = GCCInstallation.getParentLibPath(); 2283 const llvm::Triple &GCCTriple = GCCInstallation.getTriple(); 2284 if (!GCCInstallation.getMultiarchSuffix().empty()) 2285 addPathIfExists(GCCInstallation.getInstallPath(), Paths); 2286 2287 if (StringRef(LibPath).startswith(SysRoot)) { 2288 addPathIfExists(LibPath + "/../" + GCCTriple.str() + "/lib", Paths); 2289 addPathIfExists(LibPath, Paths); 2290 } 2291 } 2292 addPathIfExists(SysRoot + "/lib", Paths); 2293 addPathIfExists(SysRoot + "/usr/lib", Paths); 2294 2295 IsPIEDefault = SanitizerArgs(*this, Args).hasZeroBaseShadow(); 2296} 2297 2298bool Linux::HasNativeLLVMSupport() const { 2299 return true; 2300} 2301 2302Tool *Linux::buildLinker() const { 2303 return new tools::gnutools::Link(*this); 2304} 2305 2306Tool *Linux::buildAssembler() const { 2307 return new tools::gnutools::Assemble(*this); 2308} 2309 2310void Linux::addClangTargetOptions(const ArgList &DriverArgs, 2311 ArgStringList &CC1Args) const { 2312 const Generic_GCC::GCCVersion &V = GCCInstallation.getVersion(); 2313 bool UseInitArrayDefault 2314 = V >= Generic_GCC::GCCVersion::Parse("4.7.0") || 2315 getTriple().getArch() == llvm::Triple::aarch64 || 2316 getTriple().getEnvironment() == llvm::Triple::Android; 2317 if (DriverArgs.hasFlag(options::OPT_fuse_init_array, 2318 options::OPT_fno_use_init_array, 2319 UseInitArrayDefault)) 2320 CC1Args.push_back("-fuse-init-array"); 2321} 2322 2323std::string Linux::computeSysRoot(const ArgList &Args) const { 2324 if (!getDriver().SysRoot.empty()) 2325 return getDriver().SysRoot; 2326 2327 if (!GCCInstallation.isValid() || !isMipsArch(getTriple().getArch())) 2328 return std::string(); 2329 2330 SmallString<128> Path; 2331 llvm::sys::path::append(Path, GCCInstallation.getInstallPath(), 2332 "../../../..", 2333 GCCInstallation.getTriple().str(), 2334 "libc"); 2335 appendMipsTargetSuffix(Path, getTriple().getArch(), Args); 2336 2337 return llvm::sys::fs::exists(Path.str()) ? Path.str() : ""; 2338} 2339 2340void Linux::AddClangSystemIncludeArgs(const ArgList &DriverArgs, 2341 ArgStringList &CC1Args) const { 2342 const Driver &D = getDriver(); 2343 std::string SysRoot = computeSysRoot(DriverArgs); 2344 2345 if (DriverArgs.hasArg(options::OPT_nostdinc)) 2346 return; 2347 2348 if (!DriverArgs.hasArg(options::OPT_nostdlibinc)) 2349 addSystemInclude(DriverArgs, CC1Args, SysRoot + "/usr/local/include"); 2350 2351 if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) { 2352 llvm::sys::Path P(D.ResourceDir); 2353 P.appendComponent("include"); 2354 addSystemInclude(DriverArgs, CC1Args, P.str()); 2355 } 2356 2357 if (DriverArgs.hasArg(options::OPT_nostdlibinc)) 2358 return; 2359 2360 // Check for configure-time C include directories. 2361 StringRef CIncludeDirs(C_INCLUDE_DIRS); 2362 if (CIncludeDirs != "") { 2363 SmallVector<StringRef, 5> dirs; 2364 CIncludeDirs.split(dirs, ":"); 2365 for (SmallVectorImpl<StringRef>::iterator I = dirs.begin(), E = dirs.end(); 2366 I != E; ++I) { 2367 StringRef Prefix = llvm::sys::path::is_absolute(*I) ? SysRoot : ""; 2368 addExternCSystemInclude(DriverArgs, CC1Args, Prefix + *I); 2369 } 2370 return; 2371 } 2372 2373 // Lacking those, try to detect the correct set of system includes for the 2374 // target triple. 2375 2376 // Sourcery CodeBench and modern FSF Mips toolchains put extern C 2377 // system includes under three additional directories. 2378 if (GCCInstallation.isValid() && isMipsArch(getTriple().getArch())) { 2379 addExternCSystemIncludeIfExists(DriverArgs, CC1Args, 2380 GCCInstallation.getInstallPath() + 2381 "/include"); 2382 2383 addExternCSystemIncludeIfExists(DriverArgs, CC1Args, 2384 GCCInstallation.getInstallPath() + 2385 "/include-fixed" + 2386 GCCInstallation.getMultiarchSuffix()); 2387 2388 addExternCSystemIncludeIfExists(DriverArgs, CC1Args, 2389 GCCInstallation.getInstallPath() + 2390 "/../../../../" + 2391 GCCInstallation.getTriple().str() + 2392 "/libc/usr/include"); 2393 } 2394 2395 // Implement generic Debian multiarch support. 2396 const StringRef X86_64MultiarchIncludeDirs[] = { 2397 "/usr/include/x86_64-linux-gnu", 2398 2399 // FIXME: These are older forms of multiarch. It's not clear that they're 2400 // in use in any released version of Debian, so we should consider 2401 // removing them. 2402 "/usr/include/i686-linux-gnu/64", 2403 "/usr/include/i486-linux-gnu/64" 2404 }; 2405 const StringRef X86MultiarchIncludeDirs[] = { 2406 "/usr/include/i386-linux-gnu", 2407 2408 // FIXME: These are older forms of multiarch. It's not clear that they're 2409 // in use in any released version of Debian, so we should consider 2410 // removing them. 2411 "/usr/include/x86_64-linux-gnu/32", 2412 "/usr/include/i686-linux-gnu", 2413 "/usr/include/i486-linux-gnu" 2414 }; 2415 const StringRef AArch64MultiarchIncludeDirs[] = { 2416 "/usr/include/aarch64-linux-gnu" 2417 }; 2418 const StringRef ARMMultiarchIncludeDirs[] = { 2419 "/usr/include/arm-linux-gnueabi" 2420 }; 2421 const StringRef ARMHFMultiarchIncludeDirs[] = { 2422 "/usr/include/arm-linux-gnueabihf" 2423 }; 2424 const StringRef MIPSMultiarchIncludeDirs[] = { 2425 "/usr/include/mips-linux-gnu" 2426 }; 2427 const StringRef MIPSELMultiarchIncludeDirs[] = { 2428 "/usr/include/mipsel-linux-gnu" 2429 }; 2430 const StringRef PPCMultiarchIncludeDirs[] = { 2431 "/usr/include/powerpc-linux-gnu" 2432 }; 2433 const StringRef PPC64MultiarchIncludeDirs[] = { 2434 "/usr/include/powerpc64-linux-gnu" 2435 }; 2436 ArrayRef<StringRef> MultiarchIncludeDirs; 2437 if (getTriple().getArch() == llvm::Triple::x86_64) { 2438 MultiarchIncludeDirs = X86_64MultiarchIncludeDirs; 2439 } else if (getTriple().getArch() == llvm::Triple::x86) { 2440 MultiarchIncludeDirs = X86MultiarchIncludeDirs; 2441 } else if (getTriple().getArch() == llvm::Triple::aarch64) { 2442 MultiarchIncludeDirs = AArch64MultiarchIncludeDirs; 2443 } else if (getTriple().getArch() == llvm::Triple::arm) { 2444 if (getTriple().getEnvironment() == llvm::Triple::GNUEABIHF) 2445 MultiarchIncludeDirs = ARMHFMultiarchIncludeDirs; 2446 else 2447 MultiarchIncludeDirs = ARMMultiarchIncludeDirs; 2448 } else if (getTriple().getArch() == llvm::Triple::mips) { 2449 MultiarchIncludeDirs = MIPSMultiarchIncludeDirs; 2450 } else if (getTriple().getArch() == llvm::Triple::mipsel) { 2451 MultiarchIncludeDirs = MIPSELMultiarchIncludeDirs; 2452 } else if (getTriple().getArch() == llvm::Triple::ppc) { 2453 MultiarchIncludeDirs = PPCMultiarchIncludeDirs; 2454 } else if (getTriple().getArch() == llvm::Triple::ppc64) { 2455 MultiarchIncludeDirs = PPC64MultiarchIncludeDirs; 2456 } 2457 for (ArrayRef<StringRef>::iterator I = MultiarchIncludeDirs.begin(), 2458 E = MultiarchIncludeDirs.end(); 2459 I != E; ++I) { 2460 if (llvm::sys::fs::exists(SysRoot + *I)) { 2461 addExternCSystemInclude(DriverArgs, CC1Args, SysRoot + *I); 2462 break; 2463 } 2464 } 2465 2466 if (getTriple().getOS() == llvm::Triple::RTEMS) 2467 return; 2468 2469 // Add an include of '/include' directly. This isn't provided by default by 2470 // system GCCs, but is often used with cross-compiling GCCs, and harmless to 2471 // add even when Clang is acting as-if it were a system compiler. 2472 addExternCSystemInclude(DriverArgs, CC1Args, SysRoot + "/include"); 2473 2474 addExternCSystemInclude(DriverArgs, CC1Args, SysRoot + "/usr/include"); 2475} 2476 2477/// \brief Helper to add the three variant paths for a libstdc++ installation. 2478/*static*/ bool Linux::addLibStdCXXIncludePaths(Twine Base, Twine TargetArchDir, 2479 const ArgList &DriverArgs, 2480 ArgStringList &CC1Args) { 2481 if (!llvm::sys::fs::exists(Base)) 2482 return false; 2483 addSystemInclude(DriverArgs, CC1Args, Base); 2484 addSystemInclude(DriverArgs, CC1Args, Base + "/" + TargetArchDir); 2485 addSystemInclude(DriverArgs, CC1Args, Base + "/backward"); 2486 return true; 2487} 2488 2489/// \brief Helper to add an extra variant path for an (Ubuntu) multilib 2490/// libstdc++ installation. 2491/*static*/ bool Linux::addLibStdCXXIncludePaths(Twine Base, Twine Suffix, 2492 Twine TargetArchDir, 2493 Twine MultiLibSuffix, 2494 const ArgList &DriverArgs, 2495 ArgStringList &CC1Args) { 2496 if (!addLibStdCXXIncludePaths(Base+Suffix, TargetArchDir + MultiLibSuffix, 2497 DriverArgs, CC1Args)) 2498 return false; 2499 2500 addSystemInclude(DriverArgs, CC1Args, Base + "/" + TargetArchDir + Suffix 2501 + MultiLibSuffix); 2502 return true; 2503} 2504 2505void Linux::AddClangCXXStdlibIncludeArgs(const ArgList &DriverArgs, 2506 ArgStringList &CC1Args) const { 2507 if (DriverArgs.hasArg(options::OPT_nostdlibinc) || 2508 DriverArgs.hasArg(options::OPT_nostdincxx)) 2509 return; 2510 2511 // Check if libc++ has been enabled and provide its include paths if so. 2512 if (GetCXXStdlibType(DriverArgs) == ToolChain::CST_Libcxx) { 2513 // libc++ is always installed at a fixed path on Linux currently. 2514 addSystemInclude(DriverArgs, CC1Args, 2515 getDriver().SysRoot + "/usr/include/c++/v1"); 2516 return; 2517 } 2518 2519 // We need a detected GCC installation on Linux to provide libstdc++'s 2520 // headers. We handled the libc++ case above. 2521 if (!GCCInstallation.isValid()) 2522 return; 2523 2524 // By default, look for the C++ headers in an include directory adjacent to 2525 // the lib directory of the GCC installation. Note that this is expect to be 2526 // equivalent to '/usr/include/c++/X.Y' in almost all cases. 2527 StringRef LibDir = GCCInstallation.getParentLibPath(); 2528 StringRef InstallDir = GCCInstallation.getInstallPath(); 2529 StringRef Version = GCCInstallation.getVersion().Text; 2530 StringRef TripleStr = GCCInstallation.getTriple().str(); 2531 2532 if (addLibStdCXXIncludePaths(LibDir.str() + "/../include", 2533 "/c++/" + Version.str(), 2534 TripleStr, 2535 GCCInstallation.getMultiarchSuffix(), 2536 DriverArgs, CC1Args)) 2537 return; 2538 2539 const std::string IncludePathCandidates[] = { 2540 // Gentoo is weird and places its headers inside the GCC install, so if the 2541 // first attempt to find the headers fails, try this pattern. 2542 InstallDir.str() + "/include/g++-v4", 2543 // Android standalone toolchain has C++ headers in yet another place. 2544 LibDir.str() + "/../" + TripleStr.str() + "/include/c++/" + Version.str(), 2545 // Freescale SDK C++ headers are directly in <sysroot>/usr/include/c++, 2546 // without a subdirectory corresponding to the gcc version. 2547 LibDir.str() + "/../include/c++", 2548 }; 2549 2550 for (unsigned i = 0; i < llvm::array_lengthof(IncludePathCandidates); ++i) { 2551 if (addLibStdCXXIncludePaths(IncludePathCandidates[i], (TripleStr + 2552 GCCInstallation.getMultiarchSuffix()), 2553 DriverArgs, CC1Args)) 2554 break; 2555 } 2556} 2557 2558bool Linux::isPIEDefault() const { 2559 return IsPIEDefault; 2560} 2561 2562/// DragonFly - DragonFly tool chain which can call as(1) and ld(1) directly. 2563 2564DragonFly::DragonFly(const Driver &D, const llvm::Triple& Triple, const ArgList &Args) 2565 : Generic_ELF(D, Triple, Args) { 2566 2567 // Path mangling to find libexec 2568 getProgramPaths().push_back(getDriver().getInstalledDir()); 2569 if (getDriver().getInstalledDir() != getDriver().Dir) 2570 getProgramPaths().push_back(getDriver().Dir); 2571 2572 getFilePaths().push_back(getDriver().Dir + "/../lib"); 2573 getFilePaths().push_back("/usr/lib"); 2574 if (llvm::sys::fs::exists("/usr/lib/gcc47")) 2575 getFilePaths().push_back("/usr/lib/gcc47"); 2576 else 2577 getFilePaths().push_back("/usr/lib/gcc44"); 2578} 2579 2580Tool *DragonFly::buildAssembler() const { 2581 return new tools::dragonfly::Assemble(*this); 2582} 2583 2584Tool *DragonFly::buildLinker() const { 2585 return new tools::dragonfly::Link(*this); 2586} 2587