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