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