ToolChains.cpp revision 221345
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 12#include "clang/Driver/Arg.h" 13#include "clang/Driver/ArgList.h" 14#include "clang/Driver/Compilation.h" 15#include "clang/Driver/Driver.h" 16#include "clang/Driver/DriverDiagnostic.h" 17#include "clang/Driver/HostInfo.h" 18#include "clang/Driver/OptTable.h" 19#include "clang/Driver/Option.h" 20#include "clang/Driver/Options.h" 21#include "clang/Basic/Version.h" 22 23#include "llvm/ADT/SmallString.h" 24#include "llvm/ADT/StringExtras.h" 25#include "llvm/Support/ErrorHandling.h" 26#include "llvm/Support/FileSystem.h" 27#include "llvm/Support/MemoryBuffer.h" 28#include "llvm/Support/raw_ostream.h" 29#include "llvm/Support/Path.h" 30#include "llvm/Support/system_error.h" 31 32#include <cstdlib> // ::getenv 33 34#ifndef CLANG_PREFIX 35#define CLANG_PREFIX 36#endif 37 38using namespace clang::driver; 39using namespace clang::driver::toolchains; 40 41/// Darwin - Darwin tool chain for i386 and x86_64. 42 43Darwin::Darwin(const HostInfo &Host, const llvm::Triple& Triple) 44 : ToolChain(Host, Triple), TargetInitialized(false) 45{ 46 // Compute the initial Darwin version based on the host. 47 bool HadExtra; 48 std::string OSName = Triple.getOSName(); 49 if (!Driver::GetReleaseVersion(&OSName.c_str()[6], 50 DarwinVersion[0], DarwinVersion[1], 51 DarwinVersion[2], HadExtra)) 52 getDriver().Diag(clang::diag::err_drv_invalid_darwin_version) << OSName; 53 54 llvm::raw_string_ostream(MacosxVersionMin) 55 << "10." << std::max(0, (int)DarwinVersion[0] - 4) << '.' 56 << DarwinVersion[1]; 57} 58 59types::ID Darwin::LookupTypeForExtension(const char *Ext) const { 60 types::ID Ty = types::lookupTypeForExtension(Ext); 61 62 // Darwin always preprocesses assembly files (unless -x is used explicitly). 63 if (Ty == types::TY_PP_Asm) 64 return types::TY_Asm; 65 66 return Ty; 67} 68 69bool Darwin::HasNativeLLVMSupport() const { 70 return true; 71} 72 73// FIXME: Can we tablegen this? 74static const char *GetArmArchForMArch(llvm::StringRef Value) { 75 if (Value == "armv6k") 76 return "armv6"; 77 78 if (Value == "armv5tej") 79 return "armv5"; 80 81 if (Value == "xscale") 82 return "xscale"; 83 84 if (Value == "armv4t") 85 return "armv4t"; 86 87 if (Value == "armv7" || Value == "armv7-a" || Value == "armv7-r" || 88 Value == "armv7-m" || Value == "armv7a" || Value == "armv7r" || 89 Value == "armv7m") 90 return "armv7"; 91 92 return 0; 93} 94 95// FIXME: Can we tablegen this? 96static const char *GetArmArchForMCpu(llvm::StringRef Value) { 97 if (Value == "arm10tdmi" || Value == "arm1020t" || Value == "arm9e" || 98 Value == "arm946e-s" || Value == "arm966e-s" || 99 Value == "arm968e-s" || Value == "arm10e" || 100 Value == "arm1020e" || Value == "arm1022e" || Value == "arm926ej-s" || 101 Value == "arm1026ej-s") 102 return "armv5"; 103 104 if (Value == "xscale") 105 return "xscale"; 106 107 if (Value == "arm1136j-s" || Value == "arm1136jf-s" || 108 Value == "arm1176jz-s" || Value == "arm1176jzf-s" || 109 Value == "cortex-m0" ) 110 return "armv6"; 111 112 if (Value == "cortex-a8" || Value == "cortex-r4" || Value == "cortex-m3") 113 return "armv7"; 114 115 return 0; 116} 117 118llvm::StringRef Darwin::getDarwinArchName(const ArgList &Args) const { 119 switch (getTriple().getArch()) { 120 default: 121 return getArchName(); 122 123 case llvm::Triple::thumb: 124 case llvm::Triple::arm: { 125 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) 126 if (const char *Arch = GetArmArchForMArch(A->getValue(Args))) 127 return Arch; 128 129 if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) 130 if (const char *Arch = GetArmArchForMCpu(A->getValue(Args))) 131 return Arch; 132 133 return "arm"; 134 } 135 } 136} 137 138Darwin::~Darwin() { 139 // Free tool implementations. 140 for (llvm::DenseMap<unsigned, Tool*>::iterator 141 it = Tools.begin(), ie = Tools.end(); it != ie; ++it) 142 delete it->second; 143} 144 145std::string Darwin::ComputeEffectiveClangTriple(const ArgList &Args) const { 146 llvm::Triple Triple(ComputeLLVMTriple(Args)); 147 148 // If the target isn't initialized (e.g., an unknown Darwin platform, return 149 // the default triple). 150 if (!isTargetInitialized()) 151 return Triple.getTriple(); 152 153 unsigned Version[3]; 154 getTargetVersion(Version); 155 156 llvm::SmallString<16> Str; 157 llvm::raw_svector_ostream(Str) 158 << (isTargetIPhoneOS() ? "ios" : "macosx") 159 << Version[0] << "." << Version[1] << "." << Version[2]; 160 Triple.setOSName(Str.str()); 161 162 return Triple.getTriple(); 163} 164 165Tool &Darwin::SelectTool(const Compilation &C, const JobAction &JA, 166 const ActionList &Inputs) const { 167 Action::ActionClass Key; 168 169 if (getDriver().ShouldUseClangCompiler(C, JA, getTriple())) { 170 // Fallback to llvm-gcc for i386 kext compiles, we don't support that ABI. 171 if (Inputs.size() == 1 && 172 types::isCXX(Inputs[0]->getType()) && 173 getTriple().getOS() == llvm::Triple::Darwin && 174 getTriple().getArch() == llvm::Triple::x86 && 175 C.getArgs().getLastArg(options::OPT_fapple_kext)) 176 Key = JA.getKind(); 177 else 178 Key = Action::AnalyzeJobClass; 179 } else 180 Key = JA.getKind(); 181 182 // FIXME: This doesn't belong here, but ideally we will support static soon 183 // anyway. 184 bool HasStatic = (C.getArgs().hasArg(options::OPT_mkernel) || 185 C.getArgs().hasArg(options::OPT_static) || 186 C.getArgs().hasArg(options::OPT_fapple_kext)); 187 bool IsIADefault = IsIntegratedAssemblerDefault() && !HasStatic; 188 bool UseIntegratedAs = C.getArgs().hasFlag(options::OPT_integrated_as, 189 options::OPT_no_integrated_as, 190 IsIADefault); 191 192 Tool *&T = Tools[Key]; 193 if (!T) { 194 switch (Key) { 195 case Action::InputClass: 196 case Action::BindArchClass: 197 assert(0 && "Invalid tool kind."); 198 case Action::PreprocessJobClass: 199 T = new tools::darwin::Preprocess(*this); break; 200 case Action::AnalyzeJobClass: 201 T = new tools::Clang(*this); break; 202 case Action::PrecompileJobClass: 203 case Action::CompileJobClass: 204 T = new tools::darwin::Compile(*this); break; 205 case Action::AssembleJobClass: { 206 if (UseIntegratedAs) 207 T = new tools::ClangAs(*this); 208 else 209 T = new tools::darwin::Assemble(*this); 210 break; 211 } 212 case Action::LinkJobClass: 213 T = new tools::darwin::Link(*this); break; 214 case Action::LipoJobClass: 215 T = new tools::darwin::Lipo(*this); break; 216 case Action::DsymutilJobClass: 217 T = new tools::darwin::Dsymutil(*this); break; 218 } 219 } 220 221 return *T; 222} 223 224 225DarwinClang::DarwinClang(const HostInfo &Host, const llvm::Triple& Triple) 226 : Darwin(Host, Triple) 227{ 228 std::string UsrPrefix = "llvm-gcc-4.2/"; 229 230 getProgramPaths().push_back(getDriver().getInstalledDir()); 231 if (getDriver().getInstalledDir() != getDriver().Dir) 232 getProgramPaths().push_back(getDriver().Dir); 233 234 // We expect 'as', 'ld', etc. to be adjacent to our install dir. 235 getProgramPaths().push_back(getDriver().getInstalledDir()); 236 if (getDriver().getInstalledDir() != getDriver().Dir) 237 getProgramPaths().push_back(getDriver().Dir); 238 239 // For fallback, we need to know how to find the GCC cc1 executables, so we 240 // also add the GCC libexec paths. This is legacy code that can be removed 241 // once fallback is no longer useful. 242 std::string ToolChainDir = "i686-apple-darwin"; 243 ToolChainDir += llvm::utostr(DarwinVersion[0]); 244 ToolChainDir += "/4.2.1"; 245 246 std::string Path = getDriver().Dir; 247 Path += "/../" + UsrPrefix + "libexec/gcc/"; 248 Path += ToolChainDir; 249 getProgramPaths().push_back(Path); 250 251 Path = "/usr/" + UsrPrefix + "libexec/gcc/"; 252 Path += ToolChainDir; 253 getProgramPaths().push_back(Path); 254} 255 256void DarwinClang::AddLinkSearchPathArgs(const ArgList &Args, 257 ArgStringList &CmdArgs) const { 258 // The Clang toolchain uses explicit paths for internal libraries. 259 260 // Unfortunately, we still might depend on a few of the libraries that are 261 // only available in the gcc library directory (in particular 262 // libstdc++.dylib). For now, hardcode the path to the known install location. 263 llvm::sys::Path P(getDriver().Dir); 264 P.eraseComponent(); // .../usr/bin -> ../usr 265 P.appendComponent("lib"); 266 P.appendComponent("gcc"); 267 switch (getTriple().getArch()) { 268 default: 269 assert(0 && "Invalid Darwin arch!"); 270 case llvm::Triple::x86: 271 case llvm::Triple::x86_64: 272 P.appendComponent("i686-apple-darwin10"); 273 break; 274 case llvm::Triple::arm: 275 case llvm::Triple::thumb: 276 P.appendComponent("arm-apple-darwin10"); 277 break; 278 case llvm::Triple::ppc: 279 case llvm::Triple::ppc64: 280 P.appendComponent("powerpc-apple-darwin10"); 281 break; 282 } 283 P.appendComponent("4.2.1"); 284 285 // Determine the arch specific GCC subdirectory. 286 const char *ArchSpecificDir = 0; 287 switch (getTriple().getArch()) { 288 default: 289 break; 290 case llvm::Triple::arm: 291 case llvm::Triple::thumb: { 292 std::string Triple = ComputeLLVMTriple(Args); 293 llvm::StringRef TripleStr = Triple; 294 if (TripleStr.startswith("armv5") || TripleStr.startswith("thumbv5")) 295 ArchSpecificDir = "v5"; 296 else if (TripleStr.startswith("armv6") || TripleStr.startswith("thumbv6")) 297 ArchSpecificDir = "v6"; 298 else if (TripleStr.startswith("armv7") || TripleStr.startswith("thumbv7")) 299 ArchSpecificDir = "v7"; 300 break; 301 } 302 case llvm::Triple::ppc64: 303 ArchSpecificDir = "ppc64"; 304 break; 305 case llvm::Triple::x86_64: 306 ArchSpecificDir = "x86_64"; 307 break; 308 } 309 310 if (ArchSpecificDir) { 311 P.appendComponent(ArchSpecificDir); 312 bool Exists; 313 if (!llvm::sys::fs::exists(P.str(), Exists) && Exists) 314 CmdArgs.push_back(Args.MakeArgString("-L" + P.str())); 315 P.eraseComponent(); 316 } 317 318 bool Exists; 319 if (!llvm::sys::fs::exists(P.str(), Exists) && Exists) 320 CmdArgs.push_back(Args.MakeArgString("-L" + P.str())); 321} 322 323void DarwinClang::AddLinkRuntimeLibArgs(const ArgList &Args, 324 ArgStringList &CmdArgs) const { 325 // Darwin doesn't support real static executables, don't link any runtime 326 // libraries with -static. 327 if (Args.hasArg(options::OPT_static)) 328 return; 329 330 // Reject -static-libgcc for now, we can deal with this when and if someone 331 // cares. This is useful in situations where someone wants to statically link 332 // something like libstdc++, and needs its runtime support routines. 333 if (const Arg *A = Args.getLastArg(options::OPT_static_libgcc)) { 334 getDriver().Diag(clang::diag::err_drv_unsupported_opt) 335 << A->getAsString(Args); 336 return; 337 } 338 339 // Otherwise link libSystem, then the dynamic runtime library, and finally any 340 // target specific static runtime library. 341 CmdArgs.push_back("-lSystem"); 342 343 // Select the dynamic runtime library and the target specific static library. 344 const char *DarwinStaticLib = 0; 345 if (isTargetIPhoneOS()) { 346 // If we are compiling as iOS / simulator, don't attempt to link libgcc_s.1, 347 // it never went into the SDK. 348 if (!isTargetIOSSimulator()) 349 CmdArgs.push_back("-lgcc_s.1"); 350 351 // We currently always need a static runtime library for iOS. 352 DarwinStaticLib = "libclang_rt.ios.a"; 353 } else { 354 // The dynamic runtime library was merged with libSystem for 10.6 and 355 // beyond; only 10.4 and 10.5 need an additional runtime library. 356 if (isMacosxVersionLT(10, 5)) 357 CmdArgs.push_back("-lgcc_s.10.4"); 358 else if (isMacosxVersionLT(10, 6)) 359 CmdArgs.push_back("-lgcc_s.10.5"); 360 361 // For OS X, we thought we would only need a static runtime library when 362 // targeting 10.4, to provide versions of the static functions which were 363 // omitted from 10.4.dylib. 364 // 365 // Unfortunately, that turned out to not be true, because Darwin system 366 // headers can still use eprintf on i386, and it is not exported from 367 // libSystem. Therefore, we still must provide a runtime library just for 368 // the tiny tiny handful of projects that *might* use that symbol. 369 if (isMacosxVersionLT(10, 5)) { 370 DarwinStaticLib = "libclang_rt.10.4.a"; 371 } else { 372 if (getTriple().getArch() == llvm::Triple::x86) 373 DarwinStaticLib = "libclang_rt.eprintf.a"; 374 } 375 } 376 377 /// Add the target specific static library, if needed. 378 if (DarwinStaticLib) { 379 llvm::sys::Path P(getDriver().ResourceDir); 380 P.appendComponent("lib"); 381 P.appendComponent("darwin"); 382 P.appendComponent(DarwinStaticLib); 383 384 // For now, allow missing resource libraries to support developers who may 385 // not have compiler-rt checked out or integrated into their build. 386 bool Exists; 387 if (!llvm::sys::fs::exists(P.str(), Exists) && Exists) 388 CmdArgs.push_back(Args.MakeArgString(P.str())); 389 } 390} 391 392void Darwin::AddDeploymentTarget(DerivedArgList &Args) const { 393 const OptTable &Opts = getDriver().getOpts(); 394 395 Arg *OSXVersion = Args.getLastArg(options::OPT_mmacosx_version_min_EQ); 396 Arg *iOSVersion = Args.getLastArg(options::OPT_miphoneos_version_min_EQ); 397 Arg *iOSSimVersion = Args.getLastArg( 398 options::OPT_mios_simulator_version_min_EQ); 399 if (OSXVersion && (iOSVersion || iOSSimVersion)) { 400 getDriver().Diag(clang::diag::err_drv_argument_not_allowed_with) 401 << OSXVersion->getAsString(Args) 402 << (iOSVersion ? iOSVersion : iOSSimVersion)->getAsString(Args); 403 iOSVersion = iOSSimVersion = 0; 404 } else if (iOSVersion && iOSSimVersion) { 405 getDriver().Diag(clang::diag::err_drv_argument_not_allowed_with) 406 << iOSVersion->getAsString(Args) 407 << iOSSimVersion->getAsString(Args); 408 iOSSimVersion = 0; 409 } else if (!OSXVersion && !iOSVersion && !iOSSimVersion) { 410 // If not deployment target was specified on the command line, check for 411 // environment defines. 412 const char *OSXTarget = ::getenv("MACOSX_DEPLOYMENT_TARGET"); 413 const char *iOSTarget = ::getenv("IPHONEOS_DEPLOYMENT_TARGET"); 414 const char *iOSSimTarget = ::getenv("IOS_SIMULATOR_DEPLOYMENT_TARGET"); 415 416 // Ignore empty strings. 417 if (OSXTarget && OSXTarget[0] == '\0') 418 OSXTarget = 0; 419 if (iOSTarget && iOSTarget[0] == '\0') 420 iOSTarget = 0; 421 if (iOSSimTarget && iOSSimTarget[0] == '\0') 422 iOSSimTarget = 0; 423 424 // Handle conflicting deployment targets 425 // 426 // FIXME: Don't hardcode default here. 427 428 // Do not allow conflicts with the iOS simulator target. 429 if (iOSSimTarget && (OSXTarget || iOSTarget)) { 430 getDriver().Diag(clang::diag::err_drv_conflicting_deployment_targets) 431 << "IOS_SIMULATOR_DEPLOYMENT_TARGET" 432 << (OSXTarget ? "MACOSX_DEPLOYMENT_TARGET" : 433 "IPHONEOS_DEPLOYMENT_TARGET"); 434 } 435 436 // Allow conflicts among OSX and iOS for historical reasons, but choose the 437 // default platform. 438 if (OSXTarget && iOSTarget) { 439 if (getTriple().getArch() == llvm::Triple::arm || 440 getTriple().getArch() == llvm::Triple::thumb) 441 OSXTarget = 0; 442 else 443 iOSTarget = 0; 444 } 445 446 if (OSXTarget) { 447 const Option *O = Opts.getOption(options::OPT_mmacosx_version_min_EQ); 448 OSXVersion = Args.MakeJoinedArg(0, O, OSXTarget); 449 Args.append(OSXVersion); 450 } else if (iOSTarget) { 451 const Option *O = Opts.getOption(options::OPT_miphoneos_version_min_EQ); 452 iOSVersion = Args.MakeJoinedArg(0, O, iOSTarget); 453 Args.append(iOSVersion); 454 } else if (iOSSimTarget) { 455 const Option *O = Opts.getOption( 456 options::OPT_mios_simulator_version_min_EQ); 457 iOSSimVersion = Args.MakeJoinedArg(0, O, iOSSimTarget); 458 Args.append(iOSSimVersion); 459 } else { 460 // Otherwise, assume we are targeting OS X. 461 const Option *O = Opts.getOption(options::OPT_mmacosx_version_min_EQ); 462 OSXVersion = Args.MakeJoinedArg(0, O, MacosxVersionMin); 463 Args.append(OSXVersion); 464 } 465 } 466 467 // Reject invalid architecture combinations. 468 if (iOSSimVersion && (getTriple().getArch() != llvm::Triple::x86 && 469 getTriple().getArch() != llvm::Triple::x86_64)) { 470 getDriver().Diag(clang::diag::err_drv_invalid_arch_for_deployment_target) 471 << getTriple().getArchName() << iOSSimVersion->getAsString(Args); 472 } 473 474 // Set the tool chain target information. 475 unsigned Major, Minor, Micro; 476 bool HadExtra; 477 if (OSXVersion) { 478 assert((!iOSVersion && !iOSSimVersion) && "Unknown target platform!"); 479 if (!Driver::GetReleaseVersion(OSXVersion->getValue(Args), Major, Minor, 480 Micro, HadExtra) || HadExtra || 481 Major != 10 || Minor >= 100 || Micro >= 100) 482 getDriver().Diag(clang::diag::err_drv_invalid_version_number) 483 << OSXVersion->getAsString(Args); 484 } else { 485 const Arg *Version = iOSVersion ? iOSVersion : iOSSimVersion; 486 assert(Version && "Unknown target platform!"); 487 if (!Driver::GetReleaseVersion(Version->getValue(Args), Major, Minor, 488 Micro, HadExtra) || HadExtra || 489 Major >= 10 || Minor >= 100 || Micro >= 100) 490 getDriver().Diag(clang::diag::err_drv_invalid_version_number) 491 << Version->getAsString(Args); 492 } 493 494 bool IsIOSSim = bool(iOSSimVersion); 495 496 // In GCC, the simulator historically was treated as being OS X in some 497 // contexts, like determining the link logic, despite generally being called 498 // with an iOS deployment target. For compatibility, we detect the 499 // simulator as iOS + x86, and treat it differently in a few contexts. 500 if (iOSVersion && (getTriple().getArch() == llvm::Triple::x86 || 501 getTriple().getArch() == llvm::Triple::x86_64)) 502 IsIOSSim = true; 503 504 setTarget(/*IsIPhoneOS=*/ !OSXVersion, Major, Minor, Micro, IsIOSSim); 505} 506 507void DarwinClang::AddCXXStdlibLibArgs(const ArgList &Args, 508 ArgStringList &CmdArgs) const { 509 CXXStdlibType Type = GetCXXStdlibType(Args); 510 511 switch (Type) { 512 case ToolChain::CST_Libcxx: 513 CmdArgs.push_back("-lc++"); 514 break; 515 516 case ToolChain::CST_Libstdcxx: { 517 // Unfortunately, -lstdc++ doesn't always exist in the standard search path; 518 // it was previously found in the gcc lib dir. However, for all the Darwin 519 // platforms we care about it was -lstdc++.6, so we search for that 520 // explicitly if we can't see an obvious -lstdc++ candidate. 521 522 // Check in the sysroot first. 523 bool Exists; 524 if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) { 525 llvm::sys::Path P(A->getValue(Args)); 526 P.appendComponent("usr"); 527 P.appendComponent("lib"); 528 P.appendComponent("libstdc++.dylib"); 529 530 if (llvm::sys::fs::exists(P.str(), Exists) || !Exists) { 531 P.eraseComponent(); 532 P.appendComponent("libstdc++.6.dylib"); 533 if (!llvm::sys::fs::exists(P.str(), Exists) && Exists) { 534 CmdArgs.push_back(Args.MakeArgString(P.str())); 535 return; 536 } 537 } 538 } 539 540 // Otherwise, look in the root. 541 if ((llvm::sys::fs::exists("/usr/lib/libstdc++.dylib", Exists) || !Exists)&& 542 (!llvm::sys::fs::exists("/usr/lib/libstdc++.6.dylib", Exists) && Exists)){ 543 CmdArgs.push_back("/usr/lib/libstdc++.6.dylib"); 544 return; 545 } 546 547 // Otherwise, let the linker search. 548 CmdArgs.push_back("-lstdc++"); 549 break; 550 } 551 } 552} 553 554void DarwinClang::AddCCKextLibArgs(const ArgList &Args, 555 ArgStringList &CmdArgs) const { 556 557 // For Darwin platforms, use the compiler-rt-based support library 558 // instead of the gcc-provided one (which is also incidentally 559 // only present in the gcc lib dir, which makes it hard to find). 560 561 llvm::sys::Path P(getDriver().ResourceDir); 562 P.appendComponent("lib"); 563 P.appendComponent("darwin"); 564 P.appendComponent("libclang_rt.cc_kext.a"); 565 566 // For now, allow missing resource libraries to support developers who may 567 // not have compiler-rt checked out or integrated into their build. 568 bool Exists; 569 if (!llvm::sys::fs::exists(P.str(), Exists) && Exists) 570 CmdArgs.push_back(Args.MakeArgString(P.str())); 571} 572 573DerivedArgList *Darwin::TranslateArgs(const DerivedArgList &Args, 574 const char *BoundArch) const { 575 DerivedArgList *DAL = new DerivedArgList(Args.getBaseArgs()); 576 const OptTable &Opts = getDriver().getOpts(); 577 578 // FIXME: We really want to get out of the tool chain level argument 579 // translation business, as it makes the driver functionality much 580 // more opaque. For now, we follow gcc closely solely for the 581 // purpose of easily achieving feature parity & testability. Once we 582 // have something that works, we should reevaluate each translation 583 // and try to push it down into tool specific logic. 584 585 for (ArgList::const_iterator it = Args.begin(), 586 ie = Args.end(); it != ie; ++it) { 587 Arg *A = *it; 588 589 if (A->getOption().matches(options::OPT_Xarch__)) { 590 // FIXME: Canonicalize name. 591 if (getArchName() != A->getValue(Args, 0)) 592 continue; 593 594 Arg *OriginalArg = A; 595 unsigned Index = Args.getBaseArgs().MakeIndex(A->getValue(Args, 1)); 596 unsigned Prev = Index; 597 Arg *XarchArg = Opts.ParseOneArg(Args, Index); 598 599 // If the argument parsing failed or more than one argument was 600 // consumed, the -Xarch_ argument's parameter tried to consume 601 // extra arguments. Emit an error and ignore. 602 // 603 // We also want to disallow any options which would alter the 604 // driver behavior; that isn't going to work in our model. We 605 // use isDriverOption() as an approximation, although things 606 // like -O4 are going to slip through. 607 if (!XarchArg || Index > Prev + 1) { 608 getDriver().Diag(clang::diag::err_drv_invalid_Xarch_argument_with_args) 609 << A->getAsString(Args); 610 continue; 611 } else if (XarchArg->getOption().isDriverOption()) { 612 getDriver().Diag(clang::diag::err_drv_invalid_Xarch_argument_isdriver) 613 << A->getAsString(Args); 614 continue; 615 } 616 617 XarchArg->setBaseArg(A); 618 A = XarchArg; 619 620 DAL->AddSynthesizedArg(A); 621 622 // Linker input arguments require custom handling. The problem is that we 623 // have already constructed the phase actions, so we can not treat them as 624 // "input arguments". 625 if (A->getOption().isLinkerInput()) { 626 // Convert the argument into individual Zlinker_input_args. 627 for (unsigned i = 0, e = A->getNumValues(); i != e; ++i) { 628 DAL->AddSeparateArg(OriginalArg, 629 Opts.getOption(options::OPT_Zlinker_input), 630 A->getValue(Args, i)); 631 632 } 633 continue; 634 } 635 } 636 637 // Sob. These is strictly gcc compatible for the time being. Apple 638 // gcc translates options twice, which means that self-expanding 639 // options add duplicates. 640 switch ((options::ID) A->getOption().getID()) { 641 default: 642 DAL->append(A); 643 break; 644 645 case options::OPT_mkernel: 646 case options::OPT_fapple_kext: 647 DAL->append(A); 648 DAL->AddFlagArg(A, Opts.getOption(options::OPT_static)); 649 DAL->AddFlagArg(A, Opts.getOption(options::OPT_static)); 650 break; 651 652 case options::OPT_dependency_file: 653 DAL->AddSeparateArg(A, Opts.getOption(options::OPT_MF), 654 A->getValue(Args)); 655 break; 656 657 case options::OPT_gfull: 658 DAL->AddFlagArg(A, Opts.getOption(options::OPT_g_Flag)); 659 DAL->AddFlagArg(A, 660 Opts.getOption(options::OPT_fno_eliminate_unused_debug_symbols)); 661 break; 662 663 case options::OPT_gused: 664 DAL->AddFlagArg(A, Opts.getOption(options::OPT_g_Flag)); 665 DAL->AddFlagArg(A, 666 Opts.getOption(options::OPT_feliminate_unused_debug_symbols)); 667 break; 668 669 case options::OPT_fterminated_vtables: 670 case options::OPT_findirect_virtual_calls: 671 DAL->AddFlagArg(A, Opts.getOption(options::OPT_fapple_kext)); 672 DAL->AddFlagArg(A, Opts.getOption(options::OPT_static)); 673 break; 674 675 case options::OPT_shared: 676 DAL->AddFlagArg(A, Opts.getOption(options::OPT_dynamiclib)); 677 break; 678 679 case options::OPT_fconstant_cfstrings: 680 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mconstant_cfstrings)); 681 break; 682 683 case options::OPT_fno_constant_cfstrings: 684 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mno_constant_cfstrings)); 685 break; 686 687 case options::OPT_Wnonportable_cfstrings: 688 DAL->AddFlagArg(A, 689 Opts.getOption(options::OPT_mwarn_nonportable_cfstrings)); 690 break; 691 692 case options::OPT_Wno_nonportable_cfstrings: 693 DAL->AddFlagArg(A, 694 Opts.getOption(options::OPT_mno_warn_nonportable_cfstrings)); 695 break; 696 697 case options::OPT_fpascal_strings: 698 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mpascal_strings)); 699 break; 700 701 case options::OPT_fno_pascal_strings: 702 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mno_pascal_strings)); 703 break; 704 } 705 } 706 707 if (getTriple().getArch() == llvm::Triple::x86 || 708 getTriple().getArch() == llvm::Triple::x86_64) 709 if (!Args.hasArgNoClaim(options::OPT_mtune_EQ)) 710 DAL->AddJoinedArg(0, Opts.getOption(options::OPT_mtune_EQ), "core2"); 711 712 // Add the arch options based on the particular spelling of -arch, to match 713 // how the driver driver works. 714 if (BoundArch) { 715 llvm::StringRef Name = BoundArch; 716 const Option *MCpu = Opts.getOption(options::OPT_mcpu_EQ); 717 const Option *MArch = Opts.getOption(options::OPT_march_EQ); 718 719 // This code must be kept in sync with LLVM's getArchTypeForDarwinArch, 720 // which defines the list of which architectures we accept. 721 if (Name == "ppc") 722 ; 723 else if (Name == "ppc601") 724 DAL->AddJoinedArg(0, MCpu, "601"); 725 else if (Name == "ppc603") 726 DAL->AddJoinedArg(0, MCpu, "603"); 727 else if (Name == "ppc604") 728 DAL->AddJoinedArg(0, MCpu, "604"); 729 else if (Name == "ppc604e") 730 DAL->AddJoinedArg(0, MCpu, "604e"); 731 else if (Name == "ppc750") 732 DAL->AddJoinedArg(0, MCpu, "750"); 733 else if (Name == "ppc7400") 734 DAL->AddJoinedArg(0, MCpu, "7400"); 735 else if (Name == "ppc7450") 736 DAL->AddJoinedArg(0, MCpu, "7450"); 737 else if (Name == "ppc970") 738 DAL->AddJoinedArg(0, MCpu, "970"); 739 740 else if (Name == "ppc64") 741 DAL->AddFlagArg(0, Opts.getOption(options::OPT_m64)); 742 743 else if (Name == "i386") 744 ; 745 else if (Name == "i486") 746 DAL->AddJoinedArg(0, MArch, "i486"); 747 else if (Name == "i586") 748 DAL->AddJoinedArg(0, MArch, "i586"); 749 else if (Name == "i686") 750 DAL->AddJoinedArg(0, MArch, "i686"); 751 else if (Name == "pentium") 752 DAL->AddJoinedArg(0, MArch, "pentium"); 753 else if (Name == "pentium2") 754 DAL->AddJoinedArg(0, MArch, "pentium2"); 755 else if (Name == "pentpro") 756 DAL->AddJoinedArg(0, MArch, "pentiumpro"); 757 else if (Name == "pentIIm3") 758 DAL->AddJoinedArg(0, MArch, "pentium2"); 759 760 else if (Name == "x86_64") 761 DAL->AddFlagArg(0, Opts.getOption(options::OPT_m64)); 762 763 else if (Name == "arm") 764 DAL->AddJoinedArg(0, MArch, "armv4t"); 765 else if (Name == "armv4t") 766 DAL->AddJoinedArg(0, MArch, "armv4t"); 767 else if (Name == "armv5") 768 DAL->AddJoinedArg(0, MArch, "armv5tej"); 769 else if (Name == "xscale") 770 DAL->AddJoinedArg(0, MArch, "xscale"); 771 else if (Name == "armv6") 772 DAL->AddJoinedArg(0, MArch, "armv6k"); 773 else if (Name == "armv7") 774 DAL->AddJoinedArg(0, MArch, "armv7a"); 775 776 else 777 llvm_unreachable("invalid Darwin arch"); 778 } 779 780 // Add an explicit version min argument for the deployment target. We do this 781 // after argument translation because -Xarch_ arguments may add a version min 782 // argument. 783 AddDeploymentTarget(*DAL); 784 785 return DAL; 786} 787 788bool Darwin::IsUnwindTablesDefault() const { 789 // FIXME: Gross; we should probably have some separate target 790 // definition, possibly even reusing the one in clang. 791 return getArchName() == "x86_64"; 792} 793 794bool Darwin::UseDwarfDebugFlags() const { 795 if (const char *S = ::getenv("RC_DEBUG_OPTIONS")) 796 return S[0] != '\0'; 797 return false; 798} 799 800bool Darwin::UseSjLjExceptions() const { 801 // Darwin uses SjLj exceptions on ARM. 802 return (getTriple().getArch() == llvm::Triple::arm || 803 getTriple().getArch() == llvm::Triple::thumb); 804} 805 806const char *Darwin::GetDefaultRelocationModel() const { 807 return "pic"; 808} 809 810const char *Darwin::GetForcedPicModel() const { 811 if (getArchName() == "x86_64") 812 return "pic"; 813 return 0; 814} 815 816bool Darwin::SupportsProfiling() const { 817 // Profiling instrumentation is only supported on x86. 818 return getArchName() == "i386" || getArchName() == "x86_64"; 819} 820 821bool Darwin::SupportsObjCGC() const { 822 // Garbage collection is supported everywhere except on iPhone OS. 823 return !isTargetIPhoneOS(); 824} 825 826std::string 827Darwin_Generic_GCC::ComputeEffectiveClangTriple(const ArgList &Args) const { 828 return ComputeLLVMTriple(Args); 829} 830 831/// Generic_GCC - A tool chain using the 'gcc' command to perform 832/// all subcommands; this relies on gcc translating the majority of 833/// command line options. 834 835Generic_GCC::Generic_GCC(const HostInfo &Host, const llvm::Triple& Triple) 836 : ToolChain(Host, Triple) { 837 getProgramPaths().push_back(getDriver().getInstalledDir()); 838 if (getDriver().getInstalledDir() != getDriver().Dir) 839 getProgramPaths().push_back(getDriver().Dir); 840} 841 842Generic_GCC::~Generic_GCC() { 843 // Free tool implementations. 844 for (llvm::DenseMap<unsigned, Tool*>::iterator 845 it = Tools.begin(), ie = Tools.end(); it != ie; ++it) 846 delete it->second; 847} 848 849Tool &Generic_GCC::SelectTool(const Compilation &C, 850 const JobAction &JA, 851 const ActionList &Inputs) const { 852 Action::ActionClass Key; 853 if (getDriver().ShouldUseClangCompiler(C, JA, getTriple())) 854 Key = Action::AnalyzeJobClass; 855 else 856 Key = JA.getKind(); 857 858 Tool *&T = Tools[Key]; 859 if (!T) { 860 switch (Key) { 861 case Action::InputClass: 862 case Action::BindArchClass: 863 assert(0 && "Invalid tool kind."); 864 case Action::PreprocessJobClass: 865 T = new tools::gcc::Preprocess(*this); break; 866 case Action::PrecompileJobClass: 867 T = new tools::gcc::Precompile(*this); break; 868 case Action::AnalyzeJobClass: 869 T = new tools::Clang(*this); break; 870 case Action::CompileJobClass: 871 T = new tools::gcc::Compile(*this); break; 872 case Action::AssembleJobClass: 873 T = new tools::gcc::Assemble(*this); break; 874 case Action::LinkJobClass: 875 T = new tools::gcc::Link(*this); break; 876 877 // This is a bit ungeneric, but the only platform using a driver 878 // driver is Darwin. 879 case Action::LipoJobClass: 880 T = new tools::darwin::Lipo(*this); break; 881 case Action::DsymutilJobClass: 882 T = new tools::darwin::Dsymutil(*this); break; 883 } 884 } 885 886 return *T; 887} 888 889bool Generic_GCC::IsUnwindTablesDefault() const { 890 // FIXME: Gross; we should probably have some separate target 891 // definition, possibly even reusing the one in clang. 892 return getArchName() == "x86_64"; 893} 894 895const char *Generic_GCC::GetDefaultRelocationModel() const { 896 return "static"; 897} 898 899const char *Generic_GCC::GetForcedPicModel() const { 900 return 0; 901} 902 903/// TCEToolChain - A tool chain using the llvm bitcode tools to perform 904/// all subcommands. See http://tce.cs.tut.fi for our peculiar target. 905/// Currently does not support anything else but compilation. 906 907TCEToolChain::TCEToolChain(const HostInfo &Host, const llvm::Triple& Triple) 908 : ToolChain(Host, Triple) { 909 // Path mangling to find libexec 910 std::string Path(getDriver().Dir); 911 912 Path += "/../libexec"; 913 getProgramPaths().push_back(Path); 914} 915 916TCEToolChain::~TCEToolChain() { 917 for (llvm::DenseMap<unsigned, Tool*>::iterator 918 it = Tools.begin(), ie = Tools.end(); it != ie; ++it) 919 delete it->second; 920} 921 922bool TCEToolChain::IsMathErrnoDefault() const { 923 return true; 924} 925 926bool TCEToolChain::IsUnwindTablesDefault() const { 927 return false; 928} 929 930const char *TCEToolChain::GetDefaultRelocationModel() const { 931 return "static"; 932} 933 934const char *TCEToolChain::GetForcedPicModel() const { 935 return 0; 936} 937 938Tool &TCEToolChain::SelectTool(const Compilation &C, 939 const JobAction &JA, 940 const ActionList &Inputs) const { 941 Action::ActionClass Key; 942 Key = Action::AnalyzeJobClass; 943 944 Tool *&T = Tools[Key]; 945 if (!T) { 946 switch (Key) { 947 case Action::PreprocessJobClass: 948 T = new tools::gcc::Preprocess(*this); break; 949 case Action::AnalyzeJobClass: 950 T = new tools::Clang(*this); break; 951 default: 952 assert(false && "Unsupported action for TCE target."); 953 } 954 } 955 return *T; 956} 957 958/// OpenBSD - OpenBSD tool chain which can call as(1) and ld(1) directly. 959 960OpenBSD::OpenBSD(const HostInfo &Host, const llvm::Triple& Triple) 961 : Generic_ELF(Host, Triple) { 962 getFilePaths().push_back(getDriver().Dir + "/../lib"); 963 getFilePaths().push_back("/usr/lib"); 964} 965 966Tool &OpenBSD::SelectTool(const Compilation &C, const JobAction &JA, 967 const ActionList &Inputs) const { 968 Action::ActionClass Key; 969 if (getDriver().ShouldUseClangCompiler(C, JA, getTriple())) 970 Key = Action::AnalyzeJobClass; 971 else 972 Key = JA.getKind(); 973 974 bool UseIntegratedAs = C.getArgs().hasFlag(options::OPT_integrated_as, 975 options::OPT_no_integrated_as, 976 IsIntegratedAssemblerDefault()); 977 978 Tool *&T = Tools[Key]; 979 if (!T) { 980 switch (Key) { 981 case Action::AssembleJobClass: { 982 if (UseIntegratedAs) 983 T = new tools::ClangAs(*this); 984 else 985 T = new tools::openbsd::Assemble(*this); 986 break; 987 } 988 case Action::LinkJobClass: 989 T = new tools::openbsd::Link(*this); break; 990 default: 991 T = &Generic_GCC::SelectTool(C, JA, Inputs); 992 } 993 } 994 995 return *T; 996} 997 998/// FreeBSD - FreeBSD tool chain which can call as(1) and ld(1) directly. 999 1000FreeBSD::FreeBSD(const HostInfo &Host, const llvm::Triple& Triple) 1001 : Generic_ELF(Host, Triple) { 1002 1003 // Determine if we are compiling 32-bit code on an x86_64 platform. 1004 bool Lib32 = false; 1005 if (Triple.getArch() == llvm::Triple::x86 && 1006 llvm::Triple(getDriver().DefaultHostTriple).getArch() == 1007 llvm::Triple::x86_64) 1008 Lib32 = true; 1009 1010 if (Lib32) { 1011 getFilePaths().push_back(CLANG_PREFIX "/usr/lib32"); 1012 } else { 1013 getFilePaths().push_back(CLANG_PREFIX "/usr/lib"); 1014 } 1015} 1016 1017Tool &FreeBSD::SelectTool(const Compilation &C, const JobAction &JA, 1018 const ActionList &Inputs) const { 1019 Action::ActionClass Key; 1020 if (getDriver().ShouldUseClangCompiler(C, JA, getTriple())) 1021 Key = Action::AnalyzeJobClass; 1022 else 1023 Key = JA.getKind(); 1024 1025 bool UseIntegratedAs = C.getArgs().hasFlag(options::OPT_integrated_as, 1026 options::OPT_no_integrated_as, 1027 IsIntegratedAssemblerDefault()); 1028 1029 Tool *&T = Tools[Key]; 1030 if (!T) { 1031 switch (Key) { 1032 case Action::AssembleJobClass: 1033 if (UseIntegratedAs) 1034 T = new tools::ClangAs(*this); 1035 else 1036 T = new tools::freebsd::Assemble(*this); 1037 break; 1038 case Action::LinkJobClass: 1039 T = new tools::freebsd::Link(*this); break; 1040 default: 1041 T = &Generic_GCC::SelectTool(C, JA, Inputs); 1042 } 1043 } 1044 1045 return *T; 1046} 1047 1048/// NetBSD - NetBSD tool chain which can call as(1) and ld(1) directly. 1049 1050NetBSD::NetBSD(const HostInfo &Host, const llvm::Triple& Triple) 1051 : Generic_ELF(Host, Triple) { 1052 1053 // Determine if we are compiling 32-bit code on an x86_64 platform. 1054 bool Lib32 = false; 1055 if (Triple.getArch() == llvm::Triple::x86 && 1056 llvm::Triple(getDriver().DefaultHostTriple).getArch() == 1057 llvm::Triple::x86_64) 1058 Lib32 = true; 1059 1060 if (getDriver().UseStdLib) { 1061 if (Lib32) 1062 getFilePaths().push_back("=/usr/lib/i386"); 1063 else 1064 getFilePaths().push_back("=/usr/lib"); 1065 } 1066} 1067 1068Tool &NetBSD::SelectTool(const Compilation &C, const JobAction &JA, 1069 const ActionList &Inputs) const { 1070 Action::ActionClass Key; 1071 if (getDriver().ShouldUseClangCompiler(C, JA, getTriple())) 1072 Key = Action::AnalyzeJobClass; 1073 else 1074 Key = JA.getKind(); 1075 1076 bool UseIntegratedAs = C.getArgs().hasFlag(options::OPT_integrated_as, 1077 options::OPT_no_integrated_as, 1078 IsIntegratedAssemblerDefault()); 1079 1080 Tool *&T = Tools[Key]; 1081 if (!T) { 1082 switch (Key) { 1083 case Action::AssembleJobClass: 1084 if (UseIntegratedAs) 1085 T = new tools::ClangAs(*this); 1086 else 1087 T = new tools::netbsd::Assemble(*this); 1088 break; 1089 case Action::LinkJobClass: 1090 T = new tools::netbsd::Link(*this); break; 1091 default: 1092 T = &Generic_GCC::SelectTool(C, JA, Inputs); 1093 } 1094 } 1095 1096 return *T; 1097} 1098 1099/// Minix - Minix tool chain which can call as(1) and ld(1) directly. 1100 1101Minix::Minix(const HostInfo &Host, const llvm::Triple& Triple) 1102 : Generic_GCC(Host, Triple) { 1103 getFilePaths().push_back(getDriver().Dir + "/../lib"); 1104 getFilePaths().push_back("/usr/lib"); 1105 getFilePaths().push_back("/usr/gnu/lib"); 1106 getFilePaths().push_back("/usr/gnu/lib/gcc/i686-pc-minix/4.4.3"); 1107} 1108 1109Tool &Minix::SelectTool(const Compilation &C, const JobAction &JA, 1110 const ActionList &Inputs) const { 1111 Action::ActionClass Key; 1112 if (getDriver().ShouldUseClangCompiler(C, JA, getTriple())) 1113 Key = Action::AnalyzeJobClass; 1114 else 1115 Key = JA.getKind(); 1116 1117 Tool *&T = Tools[Key]; 1118 if (!T) { 1119 switch (Key) { 1120 case Action::AssembleJobClass: 1121 T = new tools::minix::Assemble(*this); break; 1122 case Action::LinkJobClass: 1123 T = new tools::minix::Link(*this); break; 1124 default: 1125 T = &Generic_GCC::SelectTool(C, JA, Inputs); 1126 } 1127 } 1128 1129 return *T; 1130} 1131 1132/// AuroraUX - AuroraUX tool chain which can call as(1) and ld(1) directly. 1133 1134AuroraUX::AuroraUX(const HostInfo &Host, const llvm::Triple& Triple) 1135 : Generic_GCC(Host, Triple) { 1136 1137 getProgramPaths().push_back(getDriver().getInstalledDir()); 1138 if (getDriver().getInstalledDir() != getDriver().Dir) 1139 getProgramPaths().push_back(getDriver().Dir); 1140 1141 getFilePaths().push_back(getDriver().Dir + "/../lib"); 1142 getFilePaths().push_back("/usr/lib"); 1143 getFilePaths().push_back("/usr/sfw/lib"); 1144 getFilePaths().push_back("/opt/gcc4/lib"); 1145 getFilePaths().push_back("/opt/gcc4/lib/gcc/i386-pc-solaris2.11/4.2.4"); 1146 1147} 1148 1149Tool &AuroraUX::SelectTool(const Compilation &C, const JobAction &JA, 1150 const ActionList &Inputs) const { 1151 Action::ActionClass Key; 1152 if (getDriver().ShouldUseClangCompiler(C, JA, getTriple())) 1153 Key = Action::AnalyzeJobClass; 1154 else 1155 Key = JA.getKind(); 1156 1157 Tool *&T = Tools[Key]; 1158 if (!T) { 1159 switch (Key) { 1160 case Action::AssembleJobClass: 1161 T = new tools::auroraux::Assemble(*this); break; 1162 case Action::LinkJobClass: 1163 T = new tools::auroraux::Link(*this); break; 1164 default: 1165 T = &Generic_GCC::SelectTool(C, JA, Inputs); 1166 } 1167 } 1168 1169 return *T; 1170} 1171 1172 1173/// Linux toolchain (very bare-bones at the moment). 1174 1175enum LinuxDistro { 1176 ArchLinux, 1177 DebianLenny, 1178 DebianSqueeze, 1179 Exherbo, 1180 Fedora13, 1181 Fedora14, 1182 Fedora15, 1183 FedoraRawhide, 1184 OpenSuse11_3, 1185 UbuntuHardy, 1186 UbuntuIntrepid, 1187 UbuntuJaunty, 1188 UbuntuKarmic, 1189 UbuntuLucid, 1190 UbuntuMaverick, 1191 UbuntuNatty, 1192 UnknownDistro 1193}; 1194 1195static bool IsFedora(enum LinuxDistro Distro) { 1196 return Distro == Fedora13 || Distro == Fedora14 || 1197 Distro == Fedora15 || Distro == FedoraRawhide; 1198} 1199 1200static bool IsOpenSuse(enum LinuxDistro Distro) { 1201 return Distro == OpenSuse11_3; 1202} 1203 1204static bool IsDebian(enum LinuxDistro Distro) { 1205 return Distro == DebianLenny || Distro == DebianSqueeze; 1206} 1207 1208static bool IsUbuntu(enum LinuxDistro Distro) { 1209 return Distro == UbuntuHardy || Distro == UbuntuIntrepid || 1210 Distro == UbuntuLucid || Distro == UbuntuMaverick || 1211 Distro == UbuntuJaunty || Distro == UbuntuKarmic || 1212 Distro == UbuntuNatty; 1213} 1214 1215static bool IsDebianBased(enum LinuxDistro Distro) { 1216 return IsDebian(Distro) || IsUbuntu(Distro); 1217} 1218 1219static bool HasMultilib(llvm::Triple::ArchType Arch, enum LinuxDistro Distro) { 1220 if (Arch == llvm::Triple::x86_64) { 1221 bool Exists; 1222 if (Distro == Exherbo && 1223 (llvm::sys::fs::exists("/usr/lib32/libc.so", Exists) || !Exists)) 1224 return false; 1225 1226 return true; 1227 } 1228 if (Arch == llvm::Triple::ppc64) 1229 return true; 1230 if ((Arch == llvm::Triple::x86 || Arch == llvm::Triple::ppc) && IsDebianBased(Distro)) 1231 return true; 1232 return false; 1233} 1234 1235static LinuxDistro DetectLinuxDistro(llvm::Triple::ArchType Arch) { 1236 llvm::OwningPtr<llvm::MemoryBuffer> File; 1237 if (!llvm::MemoryBuffer::getFile("/etc/lsb-release", File)) { 1238 llvm::StringRef Data = File.get()->getBuffer(); 1239 llvm::SmallVector<llvm::StringRef, 8> Lines; 1240 Data.split(Lines, "\n"); 1241 for (unsigned int i = 0, s = Lines.size(); i < s; ++ i) { 1242 if (Lines[i] == "DISTRIB_CODENAME=hardy") 1243 return UbuntuHardy; 1244 else if (Lines[i] == "DISTRIB_CODENAME=intrepid") 1245 return UbuntuIntrepid; 1246 else if (Lines[i] == "DISTRIB_CODENAME=jaunty") 1247 return UbuntuJaunty; 1248 else if (Lines[i] == "DISTRIB_CODENAME=karmic") 1249 return UbuntuKarmic; 1250 else if (Lines[i] == "DISTRIB_CODENAME=lucid") 1251 return UbuntuLucid; 1252 else if (Lines[i] == "DISTRIB_CODENAME=maverick") 1253 return UbuntuMaverick; 1254 else if (Lines[i] == "DISTRIB_CODENAME=natty") 1255 return UbuntuNatty; 1256 } 1257 return UnknownDistro; 1258 } 1259 1260 if (!llvm::MemoryBuffer::getFile("/etc/redhat-release", File)) { 1261 llvm::StringRef Data = File.get()->getBuffer(); 1262 if (Data.startswith("Fedora release 15")) 1263 return Fedora15; 1264 else if (Data.startswith("Fedora release 14")) 1265 return Fedora14; 1266 else if (Data.startswith("Fedora release 13")) 1267 return Fedora13; 1268 else if (Data.startswith("Fedora release") && 1269 Data.find("Rawhide") != llvm::StringRef::npos) 1270 return FedoraRawhide; 1271 return UnknownDistro; 1272 } 1273 1274 if (!llvm::MemoryBuffer::getFile("/etc/debian_version", File)) { 1275 llvm::StringRef Data = File.get()->getBuffer(); 1276 if (Data[0] == '5') 1277 return DebianLenny; 1278 else if (Data.startswith("squeeze/sid")) 1279 return DebianSqueeze; 1280 return UnknownDistro; 1281 } 1282 1283 if (!llvm::MemoryBuffer::getFile("/etc/SuSE-release", File)) { 1284 llvm::StringRef Data = File.get()->getBuffer(); 1285 if (Data.startswith("openSUSE 11.3")) 1286 return OpenSuse11_3; 1287 return UnknownDistro; 1288 } 1289 1290 bool Exists; 1291 if (!llvm::sys::fs::exists("/etc/exherbo-release", Exists) && Exists) 1292 return Exherbo; 1293 1294 if (!llvm::sys::fs::exists("/etc/arch-release", Exists) && Exists) 1295 return ArchLinux; 1296 1297 return UnknownDistro; 1298} 1299 1300Linux::Linux(const HostInfo &Host, const llvm::Triple &Triple) 1301 : Generic_ELF(Host, Triple) { 1302 llvm::Triple::ArchType Arch = 1303 llvm::Triple(getDriver().DefaultHostTriple).getArch(); 1304 1305 std::string Suffix32 = ""; 1306 if (Arch == llvm::Triple::x86_64) 1307 Suffix32 = "/32"; 1308 1309 std::string Suffix64 = ""; 1310 if (Arch == llvm::Triple::x86 || Arch == llvm::Triple::ppc) 1311 Suffix64 = "/64"; 1312 1313 std::string Lib32 = "lib"; 1314 1315 bool Exists; 1316 if (!llvm::sys::fs::exists("/lib32", Exists) && Exists) 1317 Lib32 = "lib32"; 1318 1319 std::string Lib64 = "lib"; 1320 bool Symlink; 1321 if (!llvm::sys::fs::exists("/lib64", Exists) && Exists && 1322 (llvm::sys::fs::is_symlink("/lib64", Symlink) || !Symlink)) 1323 Lib64 = "lib64"; 1324 1325 std::string GccTriple = ""; 1326 if (Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb) { 1327 if (!llvm::sys::fs::exists("/usr/lib/gcc/arm-linux-gnueabi", Exists) && 1328 Exists) 1329 GccTriple = "arm-linux-gnueabi"; 1330 } else if (Arch == llvm::Triple::x86_64) { 1331 if (!llvm::sys::fs::exists("/usr/lib/gcc/x86_64-linux-gnu", Exists) && 1332 Exists) 1333 GccTriple = "x86_64-linux-gnu"; 1334 else if (!llvm::sys::fs::exists("/usr/lib/gcc/x86_64-unknown-linux-gnu", 1335 Exists) && Exists) 1336 GccTriple = "x86_64-unknown-linux-gnu"; 1337 else if (!llvm::sys::fs::exists("/usr/lib/gcc/x86_64-pc-linux-gnu", 1338 Exists) && Exists) 1339 GccTriple = "x86_64-pc-linux-gnu"; 1340 else if (!llvm::sys::fs::exists("/usr/lib/gcc/x86_64-redhat-linux", 1341 Exists) && Exists) 1342 GccTriple = "x86_64-redhat-linux"; 1343 else if (!llvm::sys::fs::exists("/usr/lib64/gcc/x86_64-suse-linux", 1344 Exists) && Exists) 1345 GccTriple = "x86_64-suse-linux"; 1346 else if (!llvm::sys::fs::exists("/usr/lib/gcc/x86_64-manbo-linux-gnu", 1347 Exists) && Exists) 1348 GccTriple = "x86_64-manbo-linux-gnu"; 1349 else if (!llvm::sys::fs::exists("/usr/lib/x86_64-linux-gnu/gcc", 1350 Exists) && Exists) 1351 GccTriple = "x86_64-linux-gnu"; 1352 } else if (Arch == llvm::Triple::x86) { 1353 if (!llvm::sys::fs::exists("/usr/lib/gcc/i686-linux-gnu", Exists) && Exists) 1354 GccTriple = "i686-linux-gnu"; 1355 else if (!llvm::sys::fs::exists("/usr/lib/gcc/i686-pc-linux-gnu", Exists) && 1356 Exists) 1357 GccTriple = "i686-pc-linux-gnu"; 1358 else if (!llvm::sys::fs::exists("/usr/lib/gcc/i486-linux-gnu", Exists) && 1359 Exists) 1360 GccTriple = "i486-linux-gnu"; 1361 else if (!llvm::sys::fs::exists("/usr/lib/gcc/i686-redhat-linux", Exists) && 1362 Exists) 1363 GccTriple = "i686-redhat-linux"; 1364 else if (!llvm::sys::fs::exists("/usr/lib/gcc/i586-suse-linux", Exists) && 1365 Exists) 1366 GccTriple = "i586-suse-linux"; 1367 else if (!llvm::sys::fs::exists("/usr/lib/gcc/i486-slackware-linux", Exists) 1368 && Exists) 1369 GccTriple = "i486-slackware-linux"; 1370 } else if (Arch == llvm::Triple::ppc) { 1371 if (!llvm::sys::fs::exists("/usr/lib/powerpc-linux-gnu", Exists) && Exists) 1372 GccTriple = "powerpc-linux-gnu"; 1373 else if (!llvm::sys::fs::exists("/usr/lib/gcc/powerpc-unknown-linux-gnu", Exists) && Exists) 1374 GccTriple = "powerpc-unknown-linux-gnu"; 1375 } else if (Arch == llvm::Triple::ppc64) { 1376 if (!llvm::sys::fs::exists("/usr/lib/gcc/powerpc64-unknown-linux-gnu", Exists) && Exists) 1377 GccTriple = "powerpc64-unknown-linux-gnu"; 1378 else if (!llvm::sys::fs::exists("/usr/lib64/gcc/powerpc64-unknown-linux-gnu", Exists) && Exists) 1379 GccTriple = "powerpc64-unknown-linux-gnu"; 1380 } 1381 1382 const char* GccVersions[] = {"4.6.0", 1383 "4.5.2", "4.5.1", "4.5", 1384 "4.4.5", "4.4.4", "4.4.3", "4.4", 1385 "4.3.4", "4.3.3", "4.3.2", "4.3", 1386 "4.2.4", "4.2.3", "4.2.2", "4.2.1", "4.2"}; 1387 std::string Base = ""; 1388 for (unsigned i = 0; i < sizeof(GccVersions)/sizeof(char*); ++i) { 1389 std::string Suffix = GccTriple + "/" + GccVersions[i]; 1390 std::string t1 = "/usr/lib/gcc/" + Suffix; 1391 if (!llvm::sys::fs::exists(t1 + "/crtbegin.o", Exists) && Exists) { 1392 Base = t1; 1393 break; 1394 } 1395 std::string t2 = "/usr/lib64/gcc/" + Suffix; 1396 if (!llvm::sys::fs::exists(t2 + "/crtbegin.o", Exists) && Exists) { 1397 Base = t2; 1398 break; 1399 } 1400 std::string t3 = "/usr/lib/" + GccTriple + "/gcc/" + Suffix; 1401 if (!llvm::sys::fs::exists(t3 + "/crtbegin.o", Exists) && Exists) { 1402 Base = t3; 1403 break; 1404 } 1405 } 1406 1407 path_list &Paths = getFilePaths(); 1408 bool Is32Bits = (getArch() == llvm::Triple::x86 || getArch() == llvm::Triple::ppc); 1409 1410 std::string Suffix; 1411 std::string Lib; 1412 1413 if (Is32Bits) { 1414 Suffix = Suffix32; 1415 Lib = Lib32; 1416 } else { 1417 Suffix = Suffix64; 1418 Lib = Lib64; 1419 } 1420 1421 llvm::sys::Path LinkerPath(Base + "/../../../../" + GccTriple + "/bin/ld"); 1422 if (!llvm::sys::fs::exists(LinkerPath.str(), Exists) && Exists) 1423 Linker = LinkerPath.str(); 1424 else 1425 Linker = GetProgramPath("ld"); 1426 1427 LinuxDistro Distro = DetectLinuxDistro(Arch); 1428 1429 if (IsUbuntu(Distro)) { 1430 ExtraOpts.push_back("-z"); 1431 ExtraOpts.push_back("relro"); 1432 } 1433 1434 if (Arch == llvm::Triple::arm || Arch == llvm::Triple::thumb) 1435 ExtraOpts.push_back("-X"); 1436 1437 if (IsFedora(Distro) || Distro == UbuntuMaverick || Distro == UbuntuNatty) 1438 ExtraOpts.push_back("--hash-style=gnu"); 1439 1440 if (IsDebian(Distro) || Distro == UbuntuLucid || Distro == UbuntuJaunty || 1441 Distro == UbuntuKarmic) 1442 ExtraOpts.push_back("--hash-style=both"); 1443 1444 if (IsFedora(Distro)) 1445 ExtraOpts.push_back("--no-add-needed"); 1446 1447 if (Distro == DebianSqueeze || IsOpenSuse(Distro) || 1448 IsFedora(Distro) || Distro == UbuntuLucid || Distro == UbuntuMaverick || 1449 Distro == UbuntuKarmic || Distro == UbuntuNatty) 1450 ExtraOpts.push_back("--build-id"); 1451 1452 if (Distro == ArchLinux) 1453 Lib = "lib"; 1454 1455 Paths.push_back(Base + Suffix); 1456 if (HasMultilib(Arch, Distro)) { 1457 if (IsOpenSuse(Distro) && Is32Bits) 1458 Paths.push_back(Base + "/../../../../" + GccTriple + "/lib/../lib"); 1459 Paths.push_back(Base + "/../../../../" + Lib); 1460 Paths.push_back("/lib/../" + Lib); 1461 Paths.push_back("/usr/lib/../" + Lib); 1462 } 1463 if (!Suffix.empty()) 1464 Paths.push_back(Base); 1465 if (IsOpenSuse(Distro)) 1466 Paths.push_back(Base + "/../../../../" + GccTriple + "/lib"); 1467 Paths.push_back(Base + "/../../.."); 1468 if (Arch == getArch() && IsUbuntu(Distro)) 1469 Paths.push_back("/usr/lib/" + GccTriple); 1470} 1471 1472bool Linux::HasNativeLLVMSupport() const { 1473 return true; 1474} 1475 1476Tool &Linux::SelectTool(const Compilation &C, const JobAction &JA, 1477 const ActionList &Inputs) const { 1478 Action::ActionClass Key; 1479 if (getDriver().ShouldUseClangCompiler(C, JA, getTriple())) 1480 Key = Action::AnalyzeJobClass; 1481 else 1482 Key = JA.getKind(); 1483 1484 bool UseIntegratedAs = C.getArgs().hasFlag(options::OPT_integrated_as, 1485 options::OPT_no_integrated_as, 1486 IsIntegratedAssemblerDefault()); 1487 1488 Tool *&T = Tools[Key]; 1489 if (!T) { 1490 switch (Key) { 1491 case Action::AssembleJobClass: 1492 if (UseIntegratedAs) 1493 T = new tools::ClangAs(*this); 1494 else 1495 T = new tools::linuxtools::Assemble(*this); 1496 break; 1497 case Action::LinkJobClass: 1498 T = new tools::linuxtools::Link(*this); break; 1499 default: 1500 T = &Generic_GCC::SelectTool(C, JA, Inputs); 1501 } 1502 } 1503 1504 return *T; 1505} 1506 1507/// DragonFly - DragonFly tool chain which can call as(1) and ld(1) directly. 1508 1509DragonFly::DragonFly(const HostInfo &Host, const llvm::Triple& Triple) 1510 : Generic_ELF(Host, Triple) { 1511 1512 // Path mangling to find libexec 1513 getProgramPaths().push_back(getDriver().getInstalledDir()); 1514 if (getDriver().getInstalledDir() != getDriver().Dir) 1515 getProgramPaths().push_back(getDriver().Dir); 1516 1517 getFilePaths().push_back(getDriver().Dir + "/../lib"); 1518 getFilePaths().push_back("/usr/lib"); 1519 getFilePaths().push_back("/usr/lib/gcc41"); 1520} 1521 1522Tool &DragonFly::SelectTool(const Compilation &C, const JobAction &JA, 1523 const ActionList &Inputs) const { 1524 Action::ActionClass Key; 1525 if (getDriver().ShouldUseClangCompiler(C, JA, getTriple())) 1526 Key = Action::AnalyzeJobClass; 1527 else 1528 Key = JA.getKind(); 1529 1530 Tool *&T = Tools[Key]; 1531 if (!T) { 1532 switch (Key) { 1533 case Action::AssembleJobClass: 1534 T = new tools::dragonfly::Assemble(*this); break; 1535 case Action::LinkJobClass: 1536 T = new tools::dragonfly::Link(*this); break; 1537 default: 1538 T = &Generic_GCC::SelectTool(C, JA, Inputs); 1539 } 1540 } 1541 1542 return *T; 1543} 1544 1545Windows::Windows(const HostInfo &Host, const llvm::Triple& Triple) 1546 : ToolChain(Host, Triple) { 1547} 1548 1549Tool &Windows::SelectTool(const Compilation &C, const JobAction &JA, 1550 const ActionList &Inputs) const { 1551 Action::ActionClass Key; 1552 if (getDriver().ShouldUseClangCompiler(C, JA, getTriple())) 1553 Key = Action::AnalyzeJobClass; 1554 else 1555 Key = JA.getKind(); 1556 1557 Tool *&T = Tools[Key]; 1558 if (!T) { 1559 switch (Key) { 1560 case Action::InputClass: 1561 case Action::BindArchClass: 1562 case Action::LipoJobClass: 1563 case Action::DsymutilJobClass: 1564 assert(0 && "Invalid tool kind."); 1565 case Action::PreprocessJobClass: 1566 case Action::PrecompileJobClass: 1567 case Action::AnalyzeJobClass: 1568 case Action::CompileJobClass: 1569 T = new tools::Clang(*this); break; 1570 case Action::AssembleJobClass: 1571 T = new tools::ClangAs(*this); break; 1572 case Action::LinkJobClass: 1573 T = new tools::visualstudio::Link(*this); break; 1574 } 1575 } 1576 1577 return *T; 1578} 1579 1580bool Windows::IsIntegratedAssemblerDefault() const { 1581 return true; 1582} 1583 1584bool Windows::IsUnwindTablesDefault() const { 1585 // FIXME: Gross; we should probably have some separate target 1586 // definition, possibly even reusing the one in clang. 1587 return getArchName() == "x86_64"; 1588} 1589 1590const char *Windows::GetDefaultRelocationModel() const { 1591 return "static"; 1592} 1593 1594const char *Windows::GetForcedPicModel() const { 1595 if (getArchName() == "x86_64") 1596 return "pic"; 1597 return 0; 1598} 1599