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