ToolChains.cpp revision 212904
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/raw_ostream.h" 27#include "llvm/System/Path.h" 28 29#include <cstdlib> // ::getenv 30 31#ifndef CLANG_PREFIX 32#define CLANG_PREFIX 33#endif 34 35using namespace clang::driver; 36using namespace clang::driver::toolchains; 37 38/// Darwin - Darwin tool chain for i386 and x86_64. 39 40Darwin::Darwin(const HostInfo &Host, const llvm::Triple& Triple) 41 : ToolChain(Host, Triple), TargetInitialized(false) 42{ 43 // Compute the initial Darwin version based on the host. 44 bool HadExtra; 45 std::string OSName = Triple.getOSName(); 46 if (!Driver::GetReleaseVersion(&OSName[6], 47 DarwinVersion[0], DarwinVersion[1], 48 DarwinVersion[2], HadExtra)) 49 getDriver().Diag(clang::diag::err_drv_invalid_darwin_version) << OSName; 50 51 llvm::raw_string_ostream(MacosxVersionMin) 52 << "10." << std::max(0, (int)DarwinVersion[0] - 4) << '.' 53 << DarwinVersion[1]; 54} 55 56types::ID Darwin::LookupTypeForExtension(const char *Ext) const { 57 types::ID Ty = types::lookupTypeForExtension(Ext); 58 59 // Darwin always preprocesses assembly files (unless -x is used explicitly). 60 if (Ty == types::TY_PP_Asm) 61 return types::TY_Asm; 62 63 return Ty; 64} 65 66// FIXME: Can we tablegen this? 67static const char *GetArmArchForMArch(llvm::StringRef Value) { 68 if (Value == "armv6k") 69 return "armv6"; 70 71 if (Value == "armv5tej") 72 return "armv5"; 73 74 if (Value == "xscale") 75 return "xscale"; 76 77 if (Value == "armv4t") 78 return "armv4t"; 79 80 if (Value == "armv7" || Value == "armv7-a" || Value == "armv7-r" || 81 Value == "armv7-m" || Value == "armv7a" || Value == "armv7r" || 82 Value == "armv7m") 83 return "armv7"; 84 85 return 0; 86} 87 88// FIXME: Can we tablegen this? 89static const char *GetArmArchForMCpu(llvm::StringRef Value) { 90 if (Value == "arm10tdmi" || Value == "arm1020t" || Value == "arm9e" || 91 Value == "arm946e-s" || Value == "arm966e-s" || 92 Value == "arm968e-s" || Value == "arm10e" || 93 Value == "arm1020e" || Value == "arm1022e" || Value == "arm926ej-s" || 94 Value == "arm1026ej-s") 95 return "armv5"; 96 97 if (Value == "xscale") 98 return "xscale"; 99 100 if (Value == "arm1136j-s" || Value == "arm1136jf-s" || 101 Value == "arm1176jz-s" || Value == "arm1176jzf-s") 102 return "armv6"; 103 104 if (Value == "cortex-a8" || Value == "cortex-r4" || Value == "cortex-m3") 105 return "armv7"; 106 107 return 0; 108} 109 110llvm::StringRef Darwin::getDarwinArchName(const ArgList &Args) const { 111 switch (getTriple().getArch()) { 112 default: 113 return getArchName(); 114 115 case llvm::Triple::arm: { 116 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) 117 if (const char *Arch = GetArmArchForMArch(A->getValue(Args))) 118 return Arch; 119 120 if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) 121 if (const char *Arch = GetArmArchForMCpu(A->getValue(Args))) 122 return Arch; 123 124 return "arm"; 125 } 126 } 127} 128 129DarwinGCC::DarwinGCC(const HostInfo &Host, const llvm::Triple& Triple) 130 : Darwin(Host, Triple) 131{ 132 // We can only work with 4.2.1 currently. 133 GCCVersion[0] = 4; 134 GCCVersion[1] = 2; 135 GCCVersion[2] = 1; 136 137 // Set up the tool chain paths to match gcc. 138 ToolChainDir = "i686-apple-darwin"; 139 ToolChainDir += llvm::utostr(DarwinVersion[0]); 140 ToolChainDir += "/"; 141 ToolChainDir += llvm::utostr(GCCVersion[0]); 142 ToolChainDir += '.'; 143 ToolChainDir += llvm::utostr(GCCVersion[1]); 144 ToolChainDir += '.'; 145 ToolChainDir += llvm::utostr(GCCVersion[2]); 146 147 // Try the next major version if that tool chain dir is invalid. 148 std::string Tmp = "/usr/lib/gcc/" + ToolChainDir; 149 if (!llvm::sys::Path(Tmp).exists()) { 150 std::string Next = "i686-apple-darwin"; 151 Next += llvm::utostr(DarwinVersion[0] + 1); 152 Next += "/"; 153 Next += llvm::utostr(GCCVersion[0]); 154 Next += '.'; 155 Next += llvm::utostr(GCCVersion[1]); 156 Next += '.'; 157 Next += llvm::utostr(GCCVersion[2]); 158 159 // Use that if it exists, otherwise hope the user isn't linking. 160 // 161 // FIXME: Drop dependency on gcc's tool chain. 162 Tmp = "/usr/lib/gcc/" + Next; 163 if (llvm::sys::Path(Tmp).exists()) 164 ToolChainDir = Next; 165 } 166 167 std::string Path; 168 if (getArchName() == "x86_64") { 169 Path = getDriver().Dir; 170 Path += "/../lib/gcc/"; 171 Path += ToolChainDir; 172 Path += "/x86_64"; 173 getFilePaths().push_back(Path); 174 175 Path = "/usr/lib/gcc/"; 176 Path += ToolChainDir; 177 Path += "/x86_64"; 178 getFilePaths().push_back(Path); 179 } 180 181 Path = getDriver().Dir; 182 Path += "/../lib/gcc/"; 183 Path += ToolChainDir; 184 getFilePaths().push_back(Path); 185 186 Path = "/usr/lib/gcc/"; 187 Path += ToolChainDir; 188 getFilePaths().push_back(Path); 189 190 Path = getDriver().Dir; 191 Path += "/../libexec/gcc/"; 192 Path += ToolChainDir; 193 getProgramPaths().push_back(Path); 194 195 Path = "/usr/libexec/gcc/"; 196 Path += ToolChainDir; 197 getProgramPaths().push_back(Path); 198 199 getProgramPaths().push_back(getDriver().getInstalledDir()); 200 if (getDriver().getInstalledDir() != getDriver().Dir) 201 getProgramPaths().push_back(getDriver().Dir); 202} 203 204Darwin::~Darwin() { 205 // Free tool implementations. 206 for (llvm::DenseMap<unsigned, Tool*>::iterator 207 it = Tools.begin(), ie = Tools.end(); it != ie; ++it) 208 delete it->second; 209} 210 211std::string Darwin::ComputeEffectiveClangTriple(const ArgList &Args) const { 212 llvm::Triple Triple(ComputeLLVMTriple(Args)); 213 214 // If the target isn't initialized (e.g., an unknown Darwin platform, return 215 // the default triple). 216 if (!isTargetInitialized()) 217 return Triple.getTriple(); 218 219 unsigned Version[3]; 220 getTargetVersion(Version); 221 222 // Mangle the target version into the OS triple component. For historical 223 // reasons that make little sense, the version passed here is the "darwin" 224 // version, which drops the 10 and offsets by 4. See inverse code when 225 // setting the OS version preprocessor define. 226 if (!isTargetIPhoneOS()) { 227 Version[0] = Version[1] + 4; 228 Version[1] = Version[2]; 229 Version[2] = 0; 230 } else { 231 // Use the environment to communicate that we are targetting iPhoneOS. 232 Triple.setEnvironmentName("iphoneos"); 233 } 234 235 llvm::SmallString<16> Str; 236 llvm::raw_svector_ostream(Str) << "darwin" << Version[0] 237 << "." << Version[1] << "." << Version[2]; 238 Triple.setOSName(Str.str()); 239 240 return Triple.getTriple(); 241} 242 243Tool &Darwin::SelectTool(const Compilation &C, const JobAction &JA) const { 244 Action::ActionClass Key; 245 if (getDriver().ShouldUseClangCompiler(C, JA, getTriple())) 246 Key = Action::AnalyzeJobClass; 247 else 248 Key = JA.getKind(); 249 250 // FIXME: This doesn't belong here, but ideally we will support static soon 251 // anyway. 252 bool HasStatic = (C.getArgs().hasArg(options::OPT_mkernel) || 253 C.getArgs().hasArg(options::OPT_static) || 254 C.getArgs().hasArg(options::OPT_fapple_kext)); 255 bool IsIADefault = IsIntegratedAssemblerDefault() && !HasStatic; 256 bool UseIntegratedAs = C.getArgs().hasFlag(options::OPT_integrated_as, 257 options::OPT_no_integrated_as, 258 IsIADefault); 259 260 Tool *&T = Tools[Key]; 261 if (!T) { 262 switch (Key) { 263 case Action::InputClass: 264 case Action::BindArchClass: 265 assert(0 && "Invalid tool kind."); 266 case Action::PreprocessJobClass: 267 T = new tools::darwin::Preprocess(*this); break; 268 case Action::AnalyzeJobClass: 269 T = new tools::Clang(*this); break; 270 case Action::PrecompileJobClass: 271 case Action::CompileJobClass: 272 T = new tools::darwin::Compile(*this); break; 273 case Action::AssembleJobClass: { 274 if (UseIntegratedAs) 275 T = new tools::ClangAs(*this); 276 else 277 T = new tools::darwin::Assemble(*this); 278 break; 279 } 280 case Action::LinkJobClass: 281 T = new tools::darwin::Link(*this); break; 282 case Action::LipoJobClass: 283 T = new tools::darwin::Lipo(*this); break; 284 case Action::DsymutilJobClass: 285 T = new tools::darwin::Dsymutil(*this); break; 286 } 287 } 288 289 return *T; 290} 291 292void DarwinGCC::AddLinkSearchPathArgs(const ArgList &Args, 293 ArgStringList &CmdArgs) const { 294 std::string Tmp; 295 296 // FIXME: Derive these correctly. 297 if (getArchName() == "x86_64") { 298 CmdArgs.push_back(Args.MakeArgString("-L/usr/lib/gcc/" + ToolChainDir + 299 "/x86_64")); 300 // Intentionally duplicated for (temporary) gcc bug compatibility. 301 CmdArgs.push_back(Args.MakeArgString("-L/usr/lib/gcc/" + ToolChainDir + 302 "/x86_64")); 303 } 304 305 CmdArgs.push_back(Args.MakeArgString("-L/usr/lib/" + ToolChainDir)); 306 307 Tmp = getDriver().Dir + "/../lib/gcc/" + ToolChainDir; 308 if (llvm::sys::Path(Tmp).exists()) 309 CmdArgs.push_back(Args.MakeArgString("-L" + Tmp)); 310 Tmp = getDriver().Dir + "/../lib/gcc"; 311 if (llvm::sys::Path(Tmp).exists()) 312 CmdArgs.push_back(Args.MakeArgString("-L" + Tmp)); 313 CmdArgs.push_back(Args.MakeArgString("-L/usr/lib/gcc/" + ToolChainDir)); 314 // Intentionally duplicated for (temporary) gcc bug compatibility. 315 CmdArgs.push_back(Args.MakeArgString("-L/usr/lib/gcc/" + ToolChainDir)); 316 Tmp = getDriver().Dir + "/../lib/" + ToolChainDir; 317 if (llvm::sys::Path(Tmp).exists()) 318 CmdArgs.push_back(Args.MakeArgString("-L" + Tmp)); 319 Tmp = getDriver().Dir + "/../lib"; 320 if (llvm::sys::Path(Tmp).exists()) 321 CmdArgs.push_back(Args.MakeArgString("-L" + Tmp)); 322 CmdArgs.push_back(Args.MakeArgString("-L/usr/lib/gcc/" + ToolChainDir + 323 "/../../../" + ToolChainDir)); 324 CmdArgs.push_back(Args.MakeArgString("-L/usr/lib/gcc/" + ToolChainDir + 325 "/../../..")); 326} 327 328void DarwinGCC::AddLinkRuntimeLibArgs(const ArgList &Args, 329 ArgStringList &CmdArgs) const { 330 // Note that this routine is only used for targetting OS X. 331 332 // Derived from libgcc and lib specs but refactored. 333 if (Args.hasArg(options::OPT_static)) { 334 CmdArgs.push_back("-lgcc_static"); 335 } else { 336 if (Args.hasArg(options::OPT_static_libgcc)) { 337 CmdArgs.push_back("-lgcc_eh"); 338 } else if (Args.hasArg(options::OPT_miphoneos_version_min_EQ)) { 339 // Derived from darwin_iphoneos_libgcc spec. 340 if (isTargetIPhoneOS()) { 341 CmdArgs.push_back("-lgcc_s.1"); 342 } else { 343 CmdArgs.push_back("-lgcc_s.10.5"); 344 } 345 } else if (Args.hasArg(options::OPT_shared_libgcc) || 346 Args.hasFlag(options::OPT_fexceptions, 347 options::OPT_fno_exceptions) || 348 Args.hasArg(options::OPT_fgnu_runtime)) { 349 // FIXME: This is probably broken on 10.3? 350 if (isMacosxVersionLT(10, 5)) 351 CmdArgs.push_back("-lgcc_s.10.4"); 352 else if (isMacosxVersionLT(10, 6)) 353 CmdArgs.push_back("-lgcc_s.10.5"); 354 } else { 355 if (isMacosxVersionLT(10, 3, 9)) 356 ; // Do nothing. 357 else if (isMacosxVersionLT(10, 5)) 358 CmdArgs.push_back("-lgcc_s.10.4"); 359 else if (isMacosxVersionLT(10, 6)) 360 CmdArgs.push_back("-lgcc_s.10.5"); 361 } 362 363 if (isTargetIPhoneOS() || isMacosxVersionLT(10, 6)) { 364 CmdArgs.push_back("-lgcc"); 365 CmdArgs.push_back("-lSystem"); 366 } else { 367 CmdArgs.push_back("-lSystem"); 368 CmdArgs.push_back("-lgcc"); 369 } 370 } 371} 372 373DarwinClang::DarwinClang(const HostInfo &Host, const llvm::Triple& Triple) 374 : Darwin(Host, Triple) 375{ 376 // We expect 'as', 'ld', etc. to be adjacent to our install dir. 377 getProgramPaths().push_back(getDriver().getInstalledDir()); 378 if (getDriver().getInstalledDir() != getDriver().Dir) 379 getProgramPaths().push_back(getDriver().Dir); 380} 381 382void DarwinClang::AddLinkSearchPathArgs(const ArgList &Args, 383 ArgStringList &CmdArgs) const { 384 // The Clang toolchain uses explicit paths for internal libraries. 385 386 // Unfortunately, we still might depend on a few of the libraries that are 387 // only available in the gcc library directory (in particular 388 // libstdc++.dylib). For now, hardcode the path to the known install location. 389 llvm::sys::Path P(getDriver().Dir); 390 P.eraseComponent(); // .../usr/bin -> ../usr 391 P.appendComponent("lib"); 392 P.appendComponent("gcc"); 393 switch (getTriple().getArch()) { 394 default: 395 assert(0 && "Invalid Darwin arch!"); 396 case llvm::Triple::x86: 397 case llvm::Triple::x86_64: 398 P.appendComponent("i686-apple-darwin10"); 399 break; 400 case llvm::Triple::arm: 401 case llvm::Triple::thumb: 402 P.appendComponent("arm-apple-darwin10"); 403 break; 404 case llvm::Triple::ppc: 405 case llvm::Triple::ppc64: 406 P.appendComponent("powerpc-apple-darwin10"); 407 break; 408 } 409 P.appendComponent("4.2.1"); 410 411 // Determine the arch specific GCC subdirectory. 412 const char *ArchSpecificDir = 0; 413 switch (getTriple().getArch()) { 414 default: 415 break; 416 case llvm::Triple::arm: 417 case llvm::Triple::thumb: { 418 std::string Triple = ComputeLLVMTriple(Args); 419 llvm::StringRef TripleStr = Triple; 420 if (TripleStr.startswith("armv5") || TripleStr.startswith("thumbv5")) 421 ArchSpecificDir = "v5"; 422 else if (TripleStr.startswith("armv6") || TripleStr.startswith("thumbv6")) 423 ArchSpecificDir = "v6"; 424 else if (TripleStr.startswith("armv7") || TripleStr.startswith("thumbv7")) 425 ArchSpecificDir = "v7"; 426 break; 427 } 428 case llvm::Triple::ppc64: 429 ArchSpecificDir = "ppc64"; 430 break; 431 case llvm::Triple::x86_64: 432 ArchSpecificDir = "x86_64"; 433 break; 434 } 435 436 if (ArchSpecificDir) { 437 P.appendComponent(ArchSpecificDir); 438 if (P.exists()) 439 CmdArgs.push_back(Args.MakeArgString("-L" + P.str())); 440 P.eraseComponent(); 441 } 442 443 if (P.exists()) 444 CmdArgs.push_back(Args.MakeArgString("-L" + P.str())); 445} 446 447void DarwinClang::AddLinkRuntimeLibArgs(const ArgList &Args, 448 ArgStringList &CmdArgs) const { 449 // Darwin doesn't support real static executables, don't link any runtime 450 // libraries with -static. 451 if (Args.hasArg(options::OPT_static)) 452 return; 453 454 // Reject -static-libgcc for now, we can deal with this when and if someone 455 // cares. This is useful in situations where someone wants to statically link 456 // something like libstdc++, and needs its runtime support routines. 457 if (const Arg *A = Args.getLastArg(options::OPT_static_libgcc)) { 458 getDriver().Diag(clang::diag::err_drv_unsupported_opt) 459 << A->getAsString(Args); 460 return; 461 } 462 463 // Otherwise link libSystem, then the dynamic runtime library, and finally any 464 // target specific static runtime library. 465 CmdArgs.push_back("-lSystem"); 466 467 // Select the dynamic runtime library and the target specific static library. 468 const char *DarwinStaticLib = 0; 469 if (isTargetIPhoneOS()) { 470 CmdArgs.push_back("-lgcc_s.1"); 471 472 // We may need some static functions for armv6/thumb which are required to 473 // be in the same linkage unit as their caller. 474 if (getDarwinArchName(Args) == "armv6") 475 DarwinStaticLib = "libclang_rt.armv6.a"; 476 } else { 477 // The dynamic runtime library was merged with libSystem for 10.6 and 478 // beyond; only 10.4 and 10.5 need an additional runtime library. 479 if (isMacosxVersionLT(10, 5)) 480 CmdArgs.push_back("-lgcc_s.10.4"); 481 else if (isMacosxVersionLT(10, 6)) 482 CmdArgs.push_back("-lgcc_s.10.5"); 483 484 // For OS X, we only need a static runtime library when targetting 10.4, to 485 // provide versions of the static functions which were omitted from 486 // 10.4.dylib. 487 if (isMacosxVersionLT(10, 5)) 488 DarwinStaticLib = "libclang_rt.10.4.a"; 489 } 490 491 /// Add the target specific static library, if needed. 492 if (DarwinStaticLib) { 493 llvm::sys::Path P(getDriver().ResourceDir); 494 P.appendComponent("lib"); 495 P.appendComponent("darwin"); 496 P.appendComponent(DarwinStaticLib); 497 498 // For now, allow missing resource libraries to support developers who may 499 // not have compiler-rt checked out or integrated into their build. 500 if (!P.exists()) 501 getDriver().Diag(clang::diag::warn_drv_missing_resource_library) 502 << P.str(); 503 else 504 CmdArgs.push_back(Args.MakeArgString(P.str())); 505 } 506} 507 508void Darwin::AddDeploymentTarget(DerivedArgList &Args) const { 509 const OptTable &Opts = getDriver().getOpts(); 510 511 Arg *OSXVersion = Args.getLastArg(options::OPT_mmacosx_version_min_EQ); 512 Arg *iPhoneVersion = Args.getLastArg(options::OPT_miphoneos_version_min_EQ); 513 if (OSXVersion && iPhoneVersion) { 514 getDriver().Diag(clang::diag::err_drv_argument_not_allowed_with) 515 << OSXVersion->getAsString(Args) 516 << iPhoneVersion->getAsString(Args); 517 iPhoneVersion = 0; 518 } else if (!OSXVersion && !iPhoneVersion) { 519 // If neither OS X nor iPhoneOS targets were specified, check for 520 // environment defines. 521 const char *OSXTarget = ::getenv("MACOSX_DEPLOYMENT_TARGET"); 522 const char *iPhoneOSTarget = ::getenv("IPHONEOS_DEPLOYMENT_TARGET"); 523 524 // Ignore empty strings. 525 if (OSXTarget && OSXTarget[0] == '\0') 526 OSXTarget = 0; 527 if (iPhoneOSTarget && iPhoneOSTarget[0] == '\0') 528 iPhoneOSTarget = 0; 529 530 // Diagnose conflicting deployment targets, and choose default platform 531 // based on the tool chain. 532 // 533 // FIXME: Don't hardcode default here. 534 if (OSXTarget && iPhoneOSTarget) { 535 // FIXME: We should see if we can get away with warning or erroring on 536 // this. Perhaps put under -pedantic? 537 if (getTriple().getArch() == llvm::Triple::arm || 538 getTriple().getArch() == llvm::Triple::thumb) 539 OSXTarget = 0; 540 else 541 iPhoneOSTarget = 0; 542 } 543 544 if (OSXTarget) { 545 const Option *O = Opts.getOption(options::OPT_mmacosx_version_min_EQ); 546 OSXVersion = Args.MakeJoinedArg(0, O, OSXTarget); 547 Args.append(OSXVersion); 548 } else if (iPhoneOSTarget) { 549 const Option *O = Opts.getOption(options::OPT_miphoneos_version_min_EQ); 550 iPhoneVersion = Args.MakeJoinedArg(0, O, iPhoneOSTarget); 551 Args.append(iPhoneVersion); 552 } else { 553 // Otherwise, assume we are targeting OS X. 554 const Option *O = Opts.getOption(options::OPT_mmacosx_version_min_EQ); 555 OSXVersion = Args.MakeJoinedArg(0, O, MacosxVersionMin); 556 Args.append(OSXVersion); 557 } 558 } 559 560 // Set the tool chain target information. 561 unsigned Major, Minor, Micro; 562 bool HadExtra; 563 if (OSXVersion) { 564 assert(!iPhoneVersion && "Unknown target platform!"); 565 if (!Driver::GetReleaseVersion(OSXVersion->getValue(Args), Major, Minor, 566 Micro, HadExtra) || HadExtra || 567 Major != 10 || Minor >= 10 || Micro >= 10) 568 getDriver().Diag(clang::diag::err_drv_invalid_version_number) 569 << OSXVersion->getAsString(Args); 570 } else { 571 assert(iPhoneVersion && "Unknown target platform!"); 572 if (!Driver::GetReleaseVersion(iPhoneVersion->getValue(Args), Major, Minor, 573 Micro, HadExtra) || HadExtra || 574 Major >= 10 || Minor >= 100 || Micro >= 100) 575 getDriver().Diag(clang::diag::err_drv_invalid_version_number) 576 << iPhoneVersion->getAsString(Args); 577 } 578 setTarget(iPhoneVersion, Major, Minor, Micro); 579} 580 581DerivedArgList *Darwin::TranslateArgs(const DerivedArgList &Args, 582 const char *BoundArch) const { 583 DerivedArgList *DAL = new DerivedArgList(Args.getBaseArgs()); 584 const OptTable &Opts = getDriver().getOpts(); 585 586 // FIXME: We really want to get out of the tool chain level argument 587 // translation business, as it makes the driver functionality much 588 // more opaque. For now, we follow gcc closely solely for the 589 // purpose of easily achieving feature parity & testability. Once we 590 // have something that works, we should reevaluate each translation 591 // and try to push it down into tool specific logic. 592 593 for (ArgList::const_iterator it = Args.begin(), 594 ie = Args.end(); it != ie; ++it) { 595 Arg *A = *it; 596 597 if (A->getOption().matches(options::OPT_Xarch__)) { 598 // FIXME: Canonicalize name. 599 if (getArchName() != A->getValue(Args, 0)) 600 continue; 601 602 unsigned Index = Args.getBaseArgs().MakeIndex(A->getValue(Args, 1)); 603 unsigned Prev = Index; 604 Arg *XarchArg = Opts.ParseOneArg(Args, Index); 605 606 // If the argument parsing failed or more than one argument was 607 // consumed, the -Xarch_ argument's parameter tried to consume 608 // extra arguments. Emit an error and ignore. 609 // 610 // We also want to disallow any options which would alter the 611 // driver behavior; that isn't going to work in our model. We 612 // use isDriverOption() as an approximation, although things 613 // like -O4 are going to slip through. 614 if (!XarchArg || Index > Prev + 1 || 615 XarchArg->getOption().isDriverOption()) { 616 getDriver().Diag(clang::diag::err_drv_invalid_Xarch_argument) 617 << A->getAsString(Args); 618 continue; 619 } 620 621 XarchArg->setBaseArg(A); 622 A = XarchArg; 623 624 DAL->AddSynthesizedArg(A); 625 } 626 627 // Sob. These is strictly gcc compatible for the time being. Apple 628 // gcc translates options twice, which means that self-expanding 629 // options add duplicates. 630 switch ((options::ID) A->getOption().getID()) { 631 default: 632 DAL->append(A); 633 break; 634 635 case options::OPT_mkernel: 636 case options::OPT_fapple_kext: 637 DAL->append(A); 638 DAL->AddFlagArg(A, Opts.getOption(options::OPT_static)); 639 DAL->AddFlagArg(A, Opts.getOption(options::OPT_static)); 640 break; 641 642 case options::OPT_dependency_file: 643 DAL->AddSeparateArg(A, Opts.getOption(options::OPT_MF), 644 A->getValue(Args)); 645 break; 646 647 case options::OPT_gfull: 648 DAL->AddFlagArg(A, Opts.getOption(options::OPT_g_Flag)); 649 DAL->AddFlagArg(A, 650 Opts.getOption(options::OPT_fno_eliminate_unused_debug_symbols)); 651 break; 652 653 case options::OPT_gused: 654 DAL->AddFlagArg(A, Opts.getOption(options::OPT_g_Flag)); 655 DAL->AddFlagArg(A, 656 Opts.getOption(options::OPT_feliminate_unused_debug_symbols)); 657 break; 658 659 case options::OPT_fterminated_vtables: 660 case options::OPT_findirect_virtual_calls: 661 DAL->AddFlagArg(A, Opts.getOption(options::OPT_fapple_kext)); 662 DAL->AddFlagArg(A, Opts.getOption(options::OPT_static)); 663 break; 664 665 case options::OPT_shared: 666 DAL->AddFlagArg(A, Opts.getOption(options::OPT_dynamiclib)); 667 break; 668 669 case options::OPT_fconstant_cfstrings: 670 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mconstant_cfstrings)); 671 break; 672 673 case options::OPT_fno_constant_cfstrings: 674 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mno_constant_cfstrings)); 675 break; 676 677 case options::OPT_Wnonportable_cfstrings: 678 DAL->AddFlagArg(A, 679 Opts.getOption(options::OPT_mwarn_nonportable_cfstrings)); 680 break; 681 682 case options::OPT_Wno_nonportable_cfstrings: 683 DAL->AddFlagArg(A, 684 Opts.getOption(options::OPT_mno_warn_nonportable_cfstrings)); 685 break; 686 687 case options::OPT_fpascal_strings: 688 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mpascal_strings)); 689 break; 690 691 case options::OPT_fno_pascal_strings: 692 DAL->AddFlagArg(A, Opts.getOption(options::OPT_mno_pascal_strings)); 693 break; 694 } 695 } 696 697 if (getTriple().getArch() == llvm::Triple::x86 || 698 getTriple().getArch() == llvm::Triple::x86_64) 699 if (!Args.hasArgNoClaim(options::OPT_mtune_EQ)) 700 DAL->AddJoinedArg(0, Opts.getOption(options::OPT_mtune_EQ), "core2"); 701 702 // Add the arch options based on the particular spelling of -arch, to match 703 // how the driver driver works. 704 if (BoundArch) { 705 llvm::StringRef Name = BoundArch; 706 const Option *MCpu = Opts.getOption(options::OPT_mcpu_EQ); 707 const Option *MArch = Opts.getOption(options::OPT_march_EQ); 708 709 // This code must be kept in sync with LLVM's getArchTypeForDarwinArch, 710 // which defines the list of which architectures we accept. 711 if (Name == "ppc") 712 ; 713 else if (Name == "ppc601") 714 DAL->AddJoinedArg(0, MCpu, "601"); 715 else if (Name == "ppc603") 716 DAL->AddJoinedArg(0, MCpu, "603"); 717 else if (Name == "ppc604") 718 DAL->AddJoinedArg(0, MCpu, "604"); 719 else if (Name == "ppc604e") 720 DAL->AddJoinedArg(0, MCpu, "604e"); 721 else if (Name == "ppc750") 722 DAL->AddJoinedArg(0, MCpu, "750"); 723 else if (Name == "ppc7400") 724 DAL->AddJoinedArg(0, MCpu, "7400"); 725 else if (Name == "ppc7450") 726 DAL->AddJoinedArg(0, MCpu, "7450"); 727 else if (Name == "ppc970") 728 DAL->AddJoinedArg(0, MCpu, "970"); 729 730 else if (Name == "ppc64") 731 DAL->AddFlagArg(0, Opts.getOption(options::OPT_m64)); 732 733 else if (Name == "i386") 734 ; 735 else if (Name == "i486") 736 DAL->AddJoinedArg(0, MArch, "i486"); 737 else if (Name == "i586") 738 DAL->AddJoinedArg(0, MArch, "i586"); 739 else if (Name == "i686") 740 DAL->AddJoinedArg(0, MArch, "i686"); 741 else if (Name == "pentium") 742 DAL->AddJoinedArg(0, MArch, "pentium"); 743 else if (Name == "pentium2") 744 DAL->AddJoinedArg(0, MArch, "pentium2"); 745 else if (Name == "pentpro") 746 DAL->AddJoinedArg(0, MArch, "pentiumpro"); 747 else if (Name == "pentIIm3") 748 DAL->AddJoinedArg(0, MArch, "pentium2"); 749 750 else if (Name == "x86_64") 751 DAL->AddFlagArg(0, Opts.getOption(options::OPT_m64)); 752 753 else if (Name == "arm") 754 DAL->AddJoinedArg(0, MArch, "armv4t"); 755 else if (Name == "armv4t") 756 DAL->AddJoinedArg(0, MArch, "armv4t"); 757 else if (Name == "armv5") 758 DAL->AddJoinedArg(0, MArch, "armv5tej"); 759 else if (Name == "xscale") 760 DAL->AddJoinedArg(0, MArch, "xscale"); 761 else if (Name == "armv6") 762 DAL->AddJoinedArg(0, MArch, "armv6k"); 763 else if (Name == "armv7") 764 DAL->AddJoinedArg(0, MArch, "armv7a"); 765 766 else 767 llvm_unreachable("invalid Darwin arch"); 768 } 769 770 // Add an explicit version min argument for the deployment target. We do this 771 // after argument translation because -Xarch_ arguments may add a version min 772 // argument. 773 AddDeploymentTarget(*DAL); 774 775 return DAL; 776} 777 778bool Darwin::IsUnwindTablesDefault() const { 779 // FIXME: Gross; we should probably have some separate target 780 // definition, possibly even reusing the one in clang. 781 return getArchName() == "x86_64"; 782} 783 784bool Darwin::UseDwarfDebugFlags() const { 785 if (const char *S = ::getenv("RC_DEBUG_OPTIONS")) 786 return S[0] != '\0'; 787 return false; 788} 789 790bool Darwin::UseSjLjExceptions() const { 791 // Darwin uses SjLj exceptions on ARM. 792 return (getTriple().getArch() == llvm::Triple::arm || 793 getTriple().getArch() == llvm::Triple::thumb); 794} 795 796const char *Darwin::GetDefaultRelocationModel() const { 797 return "pic"; 798} 799 800const char *Darwin::GetForcedPicModel() const { 801 if (getArchName() == "x86_64") 802 return "pic"; 803 return 0; 804} 805 806bool Darwin::SupportsObjCGC() const { 807 // Garbage collection is supported everywhere except on iPhone OS. 808 return !isTargetIPhoneOS(); 809} 810 811std::string 812Darwin_Generic_GCC::ComputeEffectiveClangTriple(const ArgList &Args) const { 813 return ComputeLLVMTriple(Args); 814} 815 816/// Generic_GCC - A tool chain using the 'gcc' command to perform 817/// all subcommands; this relies on gcc translating the majority of 818/// command line options. 819 820Generic_GCC::Generic_GCC(const HostInfo &Host, const llvm::Triple& Triple) 821 : ToolChain(Host, Triple) { 822 getProgramPaths().push_back(getDriver().getInstalledDir()); 823 if (getDriver().getInstalledDir() != getDriver().Dir.c_str()) 824 getProgramPaths().push_back(getDriver().Dir); 825} 826 827Generic_GCC::~Generic_GCC() { 828 // Free tool implementations. 829 for (llvm::DenseMap<unsigned, Tool*>::iterator 830 it = Tools.begin(), ie = Tools.end(); it != ie; ++it) 831 delete it->second; 832} 833 834Tool &Generic_GCC::SelectTool(const Compilation &C, 835 const JobAction &JA) const { 836 Action::ActionClass Key; 837 if (getDriver().ShouldUseClangCompiler(C, JA, getTriple())) 838 Key = Action::AnalyzeJobClass; 839 else 840 Key = JA.getKind(); 841 842 Tool *&T = Tools[Key]; 843 if (!T) { 844 switch (Key) { 845 case Action::InputClass: 846 case Action::BindArchClass: 847 assert(0 && "Invalid tool kind."); 848 case Action::PreprocessJobClass: 849 T = new tools::gcc::Preprocess(*this); break; 850 case Action::PrecompileJobClass: 851 T = new tools::gcc::Precompile(*this); break; 852 case Action::AnalyzeJobClass: 853 T = new tools::Clang(*this); break; 854 case Action::CompileJobClass: 855 T = new tools::gcc::Compile(*this); break; 856 case Action::AssembleJobClass: 857 T = new tools::gcc::Assemble(*this); break; 858 case Action::LinkJobClass: 859 T = new tools::gcc::Link(*this); break; 860 861 // This is a bit ungeneric, but the only platform using a driver 862 // driver is Darwin. 863 case Action::LipoJobClass: 864 T = new tools::darwin::Lipo(*this); break; 865 case Action::DsymutilJobClass: 866 T = new tools::darwin::Dsymutil(*this); break; 867 } 868 } 869 870 return *T; 871} 872 873bool Generic_GCC::IsUnwindTablesDefault() const { 874 // FIXME: Gross; we should probably have some separate target 875 // definition, possibly even reusing the one in clang. 876 return getArchName() == "x86_64"; 877} 878 879const char *Generic_GCC::GetDefaultRelocationModel() const { 880 return "static"; 881} 882 883const char *Generic_GCC::GetForcedPicModel() const { 884 return 0; 885} 886 887/// TCEToolChain - A tool chain using the llvm bitcode tools to perform 888/// all subcommands. See http://tce.cs.tut.fi for our peculiar target. 889/// Currently does not support anything else but compilation. 890 891TCEToolChain::TCEToolChain(const HostInfo &Host, const llvm::Triple& Triple) 892 : ToolChain(Host, Triple) { 893 // Path mangling to find libexec 894 std::string Path(getDriver().Dir); 895 896 Path += "/../libexec"; 897 getProgramPaths().push_back(Path); 898} 899 900TCEToolChain::~TCEToolChain() { 901 for (llvm::DenseMap<unsigned, Tool*>::iterator 902 it = Tools.begin(), ie = Tools.end(); it != ie; ++it) 903 delete it->second; 904} 905 906bool TCEToolChain::IsMathErrnoDefault() const { 907 return true; 908} 909 910bool TCEToolChain::IsUnwindTablesDefault() const { 911 return false; 912} 913 914const char *TCEToolChain::GetDefaultRelocationModel() const { 915 return "static"; 916} 917 918const char *TCEToolChain::GetForcedPicModel() const { 919 return 0; 920} 921 922Tool &TCEToolChain::SelectTool(const Compilation &C, 923 const JobAction &JA) const { 924 Action::ActionClass Key; 925 Key = Action::AnalyzeJobClass; 926 927 Tool *&T = Tools[Key]; 928 if (!T) { 929 switch (Key) { 930 case Action::PreprocessJobClass: 931 T = new tools::gcc::Preprocess(*this); break; 932 case Action::AnalyzeJobClass: 933 T = new tools::Clang(*this); break; 934 default: 935 assert(false && "Unsupported action for TCE target."); 936 } 937 } 938 return *T; 939} 940 941/// OpenBSD - OpenBSD tool chain which can call as(1) and ld(1) directly. 942 943OpenBSD::OpenBSD(const HostInfo &Host, const llvm::Triple& Triple) 944 : Generic_GCC(Host, Triple) { 945 getFilePaths().push_back(getDriver().Dir + "/../lib"); 946 getFilePaths().push_back("/usr/lib"); 947} 948 949Tool &OpenBSD::SelectTool(const Compilation &C, const JobAction &JA) const { 950 Action::ActionClass Key; 951 if (getDriver().ShouldUseClangCompiler(C, JA, getTriple())) 952 Key = Action::AnalyzeJobClass; 953 else 954 Key = JA.getKind(); 955 956 Tool *&T = Tools[Key]; 957 if (!T) { 958 switch (Key) { 959 case Action::AssembleJobClass: 960 T = new tools::openbsd::Assemble(*this); break; 961 case Action::LinkJobClass: 962 T = new tools::openbsd::Link(*this); break; 963 default: 964 T = &Generic_GCC::SelectTool(C, JA); 965 } 966 } 967 968 return *T; 969} 970 971/// FreeBSD - FreeBSD tool chain which can call as(1) and ld(1) directly. 972 973FreeBSD::FreeBSD(const HostInfo &Host, const llvm::Triple& Triple) 974 : Generic_GCC(Host, Triple) { 975 976 // Determine if we are compiling 32-bit code on an x86_64 platform. 977 bool Lib32 = false; 978 if (Triple.getArch() == llvm::Triple::x86 && 979 llvm::Triple(getDriver().DefaultHostTriple).getArch() == 980 llvm::Triple::x86_64) 981 Lib32 = true; 982 983 getProgramPaths().push_back(getDriver().Dir + "/../libexec"); 984 getProgramPaths().push_back("/usr/libexec"); 985 if (Lib32) { 986 getFilePaths().push_back(CLANG_PREFIX "/usr/lib32"); 987 } else { 988 getFilePaths().push_back(CLANG_PREFIX "/usr/lib"); 989 } 990} 991 992Tool &FreeBSD::SelectTool(const Compilation &C, const JobAction &JA) const { 993 Action::ActionClass Key; 994 if (getDriver().ShouldUseClangCompiler(C, JA, getTriple())) 995 Key = Action::AnalyzeJobClass; 996 else 997 Key = JA.getKind(); 998 999 Tool *&T = Tools[Key]; 1000 if (!T) { 1001 switch (Key) { 1002 case Action::AssembleJobClass: 1003 T = new tools::freebsd::Assemble(*this); break; 1004 case Action::LinkJobClass: 1005 T = new tools::freebsd::Link(*this); break; 1006 default: 1007 T = &Generic_GCC::SelectTool(C, JA); 1008 } 1009 } 1010 1011 return *T; 1012} 1013 1014/// Minix - Minix tool chain which can call as(1) and ld(1) directly. 1015 1016Minix::Minix(const HostInfo &Host, const llvm::Triple& Triple) 1017 : Generic_GCC(Host, Triple) { 1018 getFilePaths().push_back(getDriver().Dir + "/../lib"); 1019 getFilePaths().push_back("/usr/lib"); 1020 getFilePaths().push_back("/usr/gnu/lib"); 1021 getFilePaths().push_back("/usr/gnu/lib/gcc/i686-pc-minix/4.4.3"); 1022} 1023 1024Tool &Minix::SelectTool(const Compilation &C, const JobAction &JA) const { 1025 Action::ActionClass Key; 1026 if (getDriver().ShouldUseClangCompiler(C, JA, getTriple())) 1027 Key = Action::AnalyzeJobClass; 1028 else 1029 Key = JA.getKind(); 1030 1031 Tool *&T = Tools[Key]; 1032 if (!T) { 1033 switch (Key) { 1034 case Action::AssembleJobClass: 1035 T = new tools::minix::Assemble(*this); break; 1036 case Action::LinkJobClass: 1037 T = new tools::minix::Link(*this); break; 1038 default: 1039 T = &Generic_GCC::SelectTool(C, JA); 1040 } 1041 } 1042 1043 return *T; 1044} 1045 1046/// AuroraUX - AuroraUX tool chain which can call as(1) and ld(1) directly. 1047 1048AuroraUX::AuroraUX(const HostInfo &Host, const llvm::Triple& Triple) 1049 : Generic_GCC(Host, Triple) { 1050 1051 getProgramPaths().push_back(getDriver().getInstalledDir()); 1052 if (getDriver().getInstalledDir() != getDriver().Dir.c_str()) 1053 getProgramPaths().push_back(getDriver().Dir); 1054 1055 getFilePaths().push_back(getDriver().Dir + "/../lib"); 1056 getFilePaths().push_back("/usr/lib"); 1057 getFilePaths().push_back("/usr/sfw/lib"); 1058 getFilePaths().push_back("/opt/gcc4/lib"); 1059 getFilePaths().push_back("/opt/gcc4/lib/gcc/i386-pc-solaris2.11/4.2.4"); 1060 1061} 1062 1063Tool &AuroraUX::SelectTool(const Compilation &C, const JobAction &JA) const { 1064 Action::ActionClass Key; 1065 if (getDriver().ShouldUseClangCompiler(C, JA, getTriple())) 1066 Key = Action::AnalyzeJobClass; 1067 else 1068 Key = JA.getKind(); 1069 1070 Tool *&T = Tools[Key]; 1071 if (!T) { 1072 switch (Key) { 1073 case Action::AssembleJobClass: 1074 T = new tools::auroraux::Assemble(*this); break; 1075 case Action::LinkJobClass: 1076 T = new tools::auroraux::Link(*this); break; 1077 default: 1078 T = &Generic_GCC::SelectTool(C, JA); 1079 } 1080 } 1081 1082 return *T; 1083} 1084 1085 1086/// Linux toolchain (very bare-bones at the moment). 1087 1088Linux::Linux(const HostInfo &Host, const llvm::Triple& Triple) 1089 : Generic_GCC(Host, Triple) { 1090 getFilePaths().push_back(getDriver().Dir + 1091 "/../lib/clang/" CLANG_VERSION_STRING "/"); 1092 getFilePaths().push_back("/lib/"); 1093 getFilePaths().push_back("/usr/lib/"); 1094 1095 // Depending on the Linux distribution, any combination of lib{,32,64} is 1096 // possible. E.g. Debian uses lib and lib32 for mixed i386/x86-64 systems, 1097 // openSUSE uses lib and lib64 for the same purpose. 1098 getFilePaths().push_back("/lib32/"); 1099 getFilePaths().push_back("/usr/lib32/"); 1100 getFilePaths().push_back("/lib64/"); 1101 getFilePaths().push_back("/usr/lib64/"); 1102 1103 // FIXME: Figure out some way to get gcc's libdir 1104 // (e.g. /usr/lib/gcc/i486-linux-gnu/4.3/ for Ubuntu 32-bit); we need 1105 // crtbegin.o/crtend.o/etc., and want static versions of various 1106 // libraries. If we had our own crtbegin.o/crtend.o/etc, we could probably 1107 // get away with using shared versions in /usr/lib, though. 1108 // We could fall back to the approach we used for includes (a massive 1109 // list), but that's messy at best. 1110} 1111 1112Tool &Linux::SelectTool(const Compilation &C, const JobAction &JA) const { 1113 Action::ActionClass Key; 1114 if (getDriver().ShouldUseClangCompiler(C, JA, getTriple())) 1115 Key = Action::AnalyzeJobClass; 1116 else 1117 Key = JA.getKind(); 1118 1119 Tool *&T = Tools[Key]; 1120 if (!T) { 1121 switch (Key) { 1122 case Action::AssembleJobClass: 1123 T = new tools::linuxtools::Assemble(*this); break; 1124 default: 1125 T = &Generic_GCC::SelectTool(C, JA); 1126 } 1127 } 1128 1129 return *T; 1130} 1131 1132/// DragonFly - DragonFly tool chain which can call as(1) and ld(1) directly. 1133 1134DragonFly::DragonFly(const HostInfo &Host, const llvm::Triple& Triple) 1135 : Generic_GCC(Host, Triple) { 1136 1137 // Path mangling to find libexec 1138 getProgramPaths().push_back(getDriver().getInstalledDir()); 1139 if (getDriver().getInstalledDir() != getDriver().Dir.c_str()) 1140 getProgramPaths().push_back(getDriver().Dir); 1141 1142 getFilePaths().push_back(getDriver().Dir + "/../lib"); 1143 getFilePaths().push_back("/usr/lib"); 1144 getFilePaths().push_back("/usr/lib/gcc41"); 1145} 1146 1147Tool &DragonFly::SelectTool(const Compilation &C, const JobAction &JA) const { 1148 Action::ActionClass Key; 1149 if (getDriver().ShouldUseClangCompiler(C, JA, getTriple())) 1150 Key = Action::AnalyzeJobClass; 1151 else 1152 Key = JA.getKind(); 1153 1154 Tool *&T = Tools[Key]; 1155 if (!T) { 1156 switch (Key) { 1157 case Action::AssembleJobClass: 1158 T = new tools::dragonfly::Assemble(*this); break; 1159 case Action::LinkJobClass: 1160 T = new tools::dragonfly::Link(*this); break; 1161 default: 1162 T = &Generic_GCC::SelectTool(C, JA); 1163 } 1164 } 1165 1166 return *T; 1167} 1168 1169Windows::Windows(const HostInfo &Host, const llvm::Triple& Triple) 1170 : ToolChain(Host, Triple) { 1171} 1172 1173Tool &Windows::SelectTool(const Compilation &C, const JobAction &JA) const { 1174 Action::ActionClass Key; 1175 if (getDriver().ShouldUseClangCompiler(C, JA, getTriple())) 1176 Key = Action::AnalyzeJobClass; 1177 else 1178 Key = JA.getKind(); 1179 1180 Tool *&T = Tools[Key]; 1181 if (!T) { 1182 switch (Key) { 1183 case Action::InputClass: 1184 case Action::BindArchClass: 1185 case Action::LipoJobClass: 1186 case Action::DsymutilJobClass: 1187 assert(0 && "Invalid tool kind."); 1188 case Action::PreprocessJobClass: 1189 case Action::PrecompileJobClass: 1190 case Action::AnalyzeJobClass: 1191 case Action::CompileJobClass: 1192 T = new tools::Clang(*this); break; 1193 case Action::AssembleJobClass: 1194 T = new tools::ClangAs(*this); break; 1195 case Action::LinkJobClass: 1196 T = new tools::visualstudio::Link(*this); break; 1197 } 1198 } 1199 1200 return *T; 1201} 1202 1203bool Windows::IsIntegratedAssemblerDefault() const { 1204 return true; 1205} 1206 1207bool Windows::IsUnwindTablesDefault() const { 1208 // FIXME: Gross; we should probably have some separate target 1209 // definition, possibly even reusing the one in clang. 1210 return getArchName() == "x86_64"; 1211} 1212 1213const char *Windows::GetDefaultRelocationModel() const { 1214 return "static"; 1215} 1216 1217const char *Windows::GetForcedPicModel() const { 1218 if (getArchName() == "x86_64") 1219 return "pic"; 1220 return 0; 1221} 1222