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