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