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