Tools.cpp revision 1045f50412d6d8a64b811d5552694061c5df4c50
1//===--- Tools.cpp - Tools 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 "Tools.h" 11 12#include "clang/Driver/Action.h" 13#include "clang/Driver/Arg.h" 14#include "clang/Driver/ArgList.h" 15#include "clang/Driver/Driver.h" 16#include "clang/Driver/DriverDiagnostic.h" 17#include "clang/Driver/Compilation.h" 18#include "clang/Driver/Job.h" 19#include "clang/Driver/HostInfo.h" 20#include "clang/Driver/Option.h" 21#include "clang/Driver/Options.h" 22#include "clang/Driver/ToolChain.h" 23#include "clang/Driver/Util.h" 24 25#include "llvm/ADT/SmallString.h" 26#include "llvm/ADT/StringSwitch.h" 27#include "llvm/ADT/Twine.h" 28#include "llvm/Support/Format.h" 29#include "llvm/Support/raw_ostream.h" 30#include "llvm/System/Host.h" 31#include "llvm/System/Process.h" 32 33#include "InputInfo.h" 34#include "ToolChains.h" 35 36using namespace clang::driver; 37using namespace clang::driver::tools; 38 39/// CheckPreprocessingOptions - Perform some validation of preprocessing 40/// arguments that is shared with gcc. 41static void CheckPreprocessingOptions(const Driver &D, const ArgList &Args) { 42 if (Arg *A = Args.getLastArg(options::OPT_C, options::OPT_CC)) 43 if (!Args.hasArg(options::OPT_E)) 44 D.Diag(clang::diag::err_drv_argument_only_allowed_with) 45 << A->getAsString(Args) << "-E"; 46} 47 48/// CheckCodeGenerationOptions - Perform some validation of code generation 49/// arguments that is shared with gcc. 50static void CheckCodeGenerationOptions(const Driver &D, const ArgList &Args) { 51 // In gcc, only ARM checks this, but it seems reasonable to check universally. 52 if (Args.hasArg(options::OPT_static)) 53 if (const Arg *A = Args.getLastArg(options::OPT_dynamic, 54 options::OPT_mdynamic_no_pic)) 55 D.Diag(clang::diag::err_drv_argument_not_allowed_with) 56 << A->getAsString(Args) << "-static"; 57} 58 59void Clang::AddPreprocessingOptions(const Driver &D, 60 const ArgList &Args, 61 ArgStringList &CmdArgs, 62 const InputInfo &Output, 63 const InputInfoList &Inputs) const { 64 Arg *A; 65 66 CheckPreprocessingOptions(D, Args); 67 68 Args.AddLastArg(CmdArgs, options::OPT_C); 69 Args.AddLastArg(CmdArgs, options::OPT_CC); 70 71 // Handle dependency file generation. 72 if ((A = Args.getLastArg(options::OPT_M)) || 73 (A = Args.getLastArg(options::OPT_MM)) || 74 (A = Args.getLastArg(options::OPT_MD)) || 75 (A = Args.getLastArg(options::OPT_MMD))) { 76 // Determine the output location. 77 const char *DepFile; 78 if (Output.getType() == types::TY_Dependencies) { 79 if (Output.isPipe()) 80 DepFile = "-"; 81 else 82 DepFile = Output.getFilename(); 83 } else if (Arg *MF = Args.getLastArg(options::OPT_MF)) { 84 DepFile = MF->getValue(Args); 85 } else if (A->getOption().matches(options::OPT_M) || 86 A->getOption().matches(options::OPT_MM)) { 87 DepFile = "-"; 88 } else { 89 DepFile = darwin::CC1::getDependencyFileName(Args, Inputs); 90 } 91 CmdArgs.push_back("-dependency-file"); 92 CmdArgs.push_back(DepFile); 93 94 // Add an -MT option if the user didn't specify their own. 95 // 96 // FIXME: This should use -MQ, when we support it. 97 if (!Args.hasArg(options::OPT_MT) && !Args.hasArg(options::OPT_MQ)) { 98 const char *DepTarget; 99 100 // If user provided -o, that is the dependency target, except 101 // when we are only generating a dependency file. 102 Arg *OutputOpt = Args.getLastArg(options::OPT_o); 103 if (OutputOpt && Output.getType() != types::TY_Dependencies) { 104 DepTarget = OutputOpt->getValue(Args); 105 } else { 106 // Otherwise derive from the base input. 107 // 108 // FIXME: This should use the computed output file location. 109 llvm::sys::Path P(Inputs[0].getBaseInput()); 110 111 P.eraseSuffix(); 112 P.appendSuffix("o"); 113 DepTarget = Args.MakeArgString(P.getLast()); 114 } 115 116 CmdArgs.push_back("-MT"); 117 CmdArgs.push_back(DepTarget); 118 } 119 120 if (A->getOption().matches(options::OPT_M) || 121 A->getOption().matches(options::OPT_MD)) 122 CmdArgs.push_back("-sys-header-deps"); 123 } 124 125 Args.AddLastArg(CmdArgs, options::OPT_MP); 126 Args.AddAllArgs(CmdArgs, options::OPT_MT); 127 128 // Add -i* options, and automatically translate to 129 // -include-pch/-include-pth for transparent PCH support. It's 130 // wonky, but we include looking for .gch so we can support seamless 131 // replacement into a build system already set up to be generating 132 // .gch files. 133 for (arg_iterator it = Args.filtered_begin(options::OPT_clang_i_Group), 134 ie = Args.filtered_end(); it != ie; ++it) { 135 const Arg *A = it; 136 137 if (A->getOption().matches(options::OPT_include)) { 138 // Use PCH if the user requested it, except for C++ (for now). 139 bool UsePCH = D.CCCUsePCH; 140 if (types::isCXX(Inputs[0].getType())) 141 UsePCH = false; 142 143 bool FoundPTH = false; 144 bool FoundPCH = false; 145 llvm::sys::Path P(A->getValue(Args)); 146 if (UsePCH) { 147 P.appendSuffix("pch"); 148 if (P.exists()) 149 FoundPCH = true; 150 else 151 P.eraseSuffix(); 152 } 153 154 if (!FoundPCH) { 155 P.appendSuffix("pth"); 156 if (P.exists()) 157 FoundPTH = true; 158 else 159 P.eraseSuffix(); 160 } 161 162 if (!FoundPCH && !FoundPTH) { 163 P.appendSuffix("gch"); 164 if (P.exists()) { 165 FoundPCH = UsePCH; 166 FoundPTH = !UsePCH; 167 } 168 else 169 P.eraseSuffix(); 170 } 171 172 if (FoundPCH || FoundPTH) { 173 A->claim(); 174 if (UsePCH) 175 CmdArgs.push_back("-include-pch"); 176 else 177 CmdArgs.push_back("-include-pth"); 178 CmdArgs.push_back(Args.MakeArgString(P.str())); 179 continue; 180 } 181 } 182 183 // Not translated, render as usual. 184 A->claim(); 185 A->render(Args, CmdArgs); 186 } 187 188 Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U); 189 Args.AddAllArgs(CmdArgs, options::OPT_I_Group, options::OPT_F); 190 191 // Add -Wp, and -Xassembler if using the preprocessor. 192 193 // FIXME: There is a very unfortunate problem here, some troubled 194 // souls abuse -Wp, to pass preprocessor options in gcc syntax. To 195 // really support that we would have to parse and then translate 196 // those options. :( 197 Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA, 198 options::OPT_Xpreprocessor); 199 200 // -I- is a deprecated GCC feature, reject it. 201 if (Arg *A = Args.getLastArg(options::OPT_I_)) 202 D.Diag(clang::diag::err_drv_I_dash_not_supported) << A->getAsString(Args); 203} 204 205/// getARMTargetCPU - Get the (LLVM) name of the ARM cpu we are targetting. 206// 207// FIXME: tblgen this. 208static const char *getARMTargetCPU(const ArgList &Args) { 209 // FIXME: Warn on inconsistent use of -mcpu and -march. 210 211 // If we have -mcpu=, use that. 212 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) 213 return A->getValue(Args); 214 215 // Otherwise, if we have -march= choose the base CPU for that arch. 216 if (Arg *A = Args.getLastArg(options::OPT_march_EQ)) { 217 llvm::StringRef MArch = A->getValue(Args); 218 219 if (MArch == "armv2" || MArch == "armv2a") 220 return "arm2"; 221 if (MArch == "armv3") 222 return "arm6"; 223 if (MArch == "armv3m") 224 return "arm7m"; 225 if (MArch == "armv4" || MArch == "armv4t") 226 return "arm7tdmi"; 227 if (MArch == "armv5" || MArch == "armv5t") 228 return "arm10tdmi"; 229 if (MArch == "armv5e" || MArch == "armv5te") 230 return "arm1026ejs"; 231 if (MArch == "armv5tej") 232 return "arm926ej-s"; 233 if (MArch == "armv6" || MArch == "armv6k") 234 return "arm1136jf-s"; 235 if (MArch == "armv6j") 236 return "arm1136j-s"; 237 if (MArch == "armv6z" || MArch == "armv6zk") 238 return "arm1176jzf-s"; 239 if (MArch == "armv6t2") 240 return "arm1156t2-s"; 241 if (MArch == "armv7" || MArch == "armv7a" || MArch == "armv7-a") 242 return "cortex-a8"; 243 if (MArch == "armv7r" || MArch == "armv7-r") 244 return "cortex-r4"; 245 if (MArch == "armv7m" || MArch == "armv7-m") 246 return "cortex-m3"; 247 if (MArch == "ep9312") 248 return "ep9312"; 249 if (MArch == "iwmmxt") 250 return "iwmmxt"; 251 if (MArch == "xscale") 252 return "xscale"; 253 } 254 255 // Otherwise return the most base CPU LLVM supports. 256 return "arm7tdmi"; 257} 258 259/// getLLVMArchSuffixForARM - Get the LLVM arch name to use for a particular 260/// CPU. 261// 262// FIXME: This is redundant with -mcpu, why does LLVM use this. 263// FIXME: tblgen this, or kill it! 264static const char *getLLVMArchSuffixForARM(llvm::StringRef CPU) { 265 if (CPU == "arm7tdmi" || CPU == "arm7tdmi-s" || CPU == "arm710t" || 266 CPU == "arm720t" || CPU == "arm9" || CPU == "arm9tdmi" || 267 CPU == "arm920" || CPU == "arm920t" || CPU == "arm922t" || 268 CPU == "arm940t" || CPU == "ep9312") 269 return "v4t"; 270 271 if (CPU == "arm10tdmi" || CPU == "arm1020t") 272 return "v5"; 273 274 if (CPU == "arm9e" || CPU == "arm926ej-s" || CPU == "arm946e-s" || 275 CPU == "arm966e-s" || CPU == "arm968e-s" || CPU == "arm10e" || 276 CPU == "arm1020e" || CPU == "arm1022e" || CPU == "xscale" || 277 CPU == "iwmmxt") 278 return "v5e"; 279 280 if (CPU == "arm1136j-s" || CPU == "arm1136jf-s" || CPU == "arm1176jz-s" || 281 CPU == "arm1176jzf-s" || CPU == "mpcorenovfp" || CPU == "mpcore") 282 return "v6"; 283 284 if (CPU == "arm1156t2-s" || CPU == "arm1156t2f-s") 285 return "v6t2"; 286 287 if (CPU == "cortex-a8" || CPU == "cortex-a9") 288 return "v7"; 289 290 return ""; 291} 292 293/// getLLVMTriple - Get the LLVM triple to use for a particular toolchain, which 294/// may depend on command line arguments. 295static std::string getLLVMTriple(const ToolChain &TC, const ArgList &Args) { 296 switch (TC.getTriple().getArch()) { 297 default: 298 return TC.getTripleString(); 299 300 case llvm::Triple::arm: 301 case llvm::Triple::thumb: { 302 // FIXME: Factor into subclasses. 303 llvm::Triple Triple = TC.getTriple(); 304 305 // Thumb2 is the default for V7 on Darwin. 306 // 307 // FIXME: Thumb should just be another -target-feaure, not in the triple. 308 llvm::StringRef Suffix = getLLVMArchSuffixForARM(getARMTargetCPU(Args)); 309 bool ThumbDefault = 310 (Suffix == "v7" && TC.getTriple().getOS() == llvm::Triple::Darwin); 311 std::string ArchName = "arm"; 312 if (Args.hasFlag(options::OPT_mthumb, options::OPT_mno_thumb, ThumbDefault)) 313 ArchName = "thumb"; 314 Triple.setArchName(ArchName + Suffix.str()); 315 316 return Triple.getTriple(); 317 } 318 } 319} 320 321// FIXME: Move to target hook. 322static bool isSignedCharDefault(const llvm::Triple &Triple) { 323 switch (Triple.getArch()) { 324 default: 325 return true; 326 327 case llvm::Triple::ppc: 328 case llvm::Triple::ppc64: 329 if (Triple.getOS() == llvm::Triple::Darwin) 330 return true; 331 return false; 332 333 case llvm::Triple::systemz: 334 return false; 335 } 336} 337 338void Clang::AddARMTargetArgs(const ArgList &Args, 339 ArgStringList &CmdArgs) const { 340 const Driver &D = getToolChain().getDriver(); 341 342 // Select the ABI to use. 343 // 344 // FIXME: Support -meabi. 345 const char *ABIName = 0; 346 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) { 347 ABIName = A->getValue(Args); 348 } else { 349 // Select the default based on the platform. 350 switch (getToolChain().getTriple().getOS()) { 351 // FIXME: Is this right for non-Darwin and non-Linux? 352 default: 353 ABIName = "aapcs"; 354 break; 355 356 case llvm::Triple::Darwin: 357 ABIName = "apcs-gnu"; 358 break; 359 360 case llvm::Triple::Linux: 361 ABIName = "aapcs-linux"; 362 break; 363 } 364 } 365 CmdArgs.push_back("-target-abi"); 366 CmdArgs.push_back(ABIName); 367 368 // Set the CPU based on -march= and -mcpu=. 369 CmdArgs.push_back("-target-cpu"); 370 CmdArgs.push_back(getARMTargetCPU(Args)); 371 372 // Select the float ABI as determined by -msoft-float, -mhard-float, and 373 // -mfloat-abi=. 374 llvm::StringRef FloatABI; 375 if (Arg *A = Args.getLastArg(options::OPT_msoft_float, 376 options::OPT_mhard_float, 377 options::OPT_mfloat_abi_EQ)) { 378 if (A->getOption().matches(options::OPT_msoft_float)) 379 FloatABI = "soft"; 380 else if (A->getOption().matches(options::OPT_mhard_float)) 381 FloatABI = "hard"; 382 else { 383 FloatABI = A->getValue(Args); 384 if (FloatABI != "soft" && FloatABI != "softfp" && FloatABI != "hard") { 385 D.Diag(clang::diag::err_drv_invalid_mfloat_abi) 386 << A->getAsString(Args); 387 FloatABI = "soft"; 388 } 389 } 390 } 391 392 // If unspecified, choose the default based on the platform. 393 if (FloatABI.empty()) { 394 // FIXME: This is wrong for non-Darwin, we don't have a mechanism yet for 395 // distinguishing things like linux-eabi vs linux-elf. 396 switch (getToolChain().getTriple().getOS()) { 397 case llvm::Triple::Darwin: { 398 // Darwin defaults to "softfp" for v6 and v7. 399 // 400 // FIXME: Factor out an ARM class so we can cache the arch somewhere. 401 llvm::StringRef ArchName = getLLVMArchSuffixForARM(getARMTargetCPU(Args)); 402 if (ArchName.startswith("v6") || ArchName.startswith("v7")) 403 FloatABI = "softfp"; 404 else 405 FloatABI = "soft"; 406 break; 407 } 408 409 default: 410 // Assume "soft", but warn the user we are guessing. 411 FloatABI = "soft"; 412 D.Diag(clang::diag::warn_drv_assuming_mfloat_abi_is) << "soft"; 413 break; 414 } 415 } 416 417 if (FloatABI == "soft") { 418 // Floating point operations and argument passing are soft. 419 // 420 // FIXME: This changes CPP defines, we need -target-soft-float. 421 CmdArgs.push_back("-msoft-float"); 422 CmdArgs.push_back("-mfloat-abi"); 423 CmdArgs.push_back("soft"); 424 } else if (FloatABI == "softfp") { 425 // Floating point operations are hard, but argument passing is soft. 426 CmdArgs.push_back("-mfloat-abi"); 427 CmdArgs.push_back("soft"); 428 } else { 429 // Floating point operations and argument passing are hard. 430 assert(FloatABI == "hard" && "Invalid float abi!"); 431 CmdArgs.push_back("-mfloat-abi"); 432 CmdArgs.push_back("hard"); 433 } 434 435 // Set appropriate target features for floating point mode. 436 // 437 // FIXME: Note, this is a hack, the LLVM backend doesn't actually use these 438 // yet (it uses the -mfloat-abi and -msoft-float options above), and it is 439 // stripped out by the ARM target. 440 441 // Use software floating point operations? 442 if (FloatABI == "soft") { 443 CmdArgs.push_back("-target-feature"); 444 CmdArgs.push_back("+soft-float"); 445 } 446 447 // Use software floating point argument passing? 448 if (FloatABI != "hard") { 449 CmdArgs.push_back("-target-feature"); 450 CmdArgs.push_back("+soft-float-abi"); 451 } 452 453 // Honor -mfpu=. 454 // 455 // FIXME: Centralize feature selection, defaulting shouldn't be also in the 456 // frontend target. 457 if (const Arg *A = Args.getLastArg(options::OPT_mfpu_EQ)) { 458 llvm::StringRef FPU = A->getValue(Args); 459 460 // Set the target features based on the FPU. 461 if (FPU == "fpa" || FPU == "fpe2" || FPU == "fpe3" || FPU == "maverick") { 462 // Disable any default FPU support. 463 CmdArgs.push_back("-target-feature"); 464 CmdArgs.push_back("-vfp2"); 465 CmdArgs.push_back("-target-feature"); 466 CmdArgs.push_back("-vfp3"); 467 CmdArgs.push_back("-target-feature"); 468 CmdArgs.push_back("-neon"); 469 } else if (FPU == "vfp") { 470 CmdArgs.push_back("-target-feature"); 471 CmdArgs.push_back("+vfp2"); 472 } else if (FPU == "vfp3") { 473 CmdArgs.push_back("-target-feature"); 474 CmdArgs.push_back("+vfp3"); 475 } else if (FPU == "neon") { 476 CmdArgs.push_back("-target-feature"); 477 CmdArgs.push_back("+neon"); 478 } else 479 D.Diag(clang::diag::err_drv_clang_unsupported) << A->getAsString(Args); 480 } 481} 482 483void Clang::AddX86TargetArgs(const ArgList &Args, 484 ArgStringList &CmdArgs) const { 485 if (!Args.hasFlag(options::OPT_mred_zone, 486 options::OPT_mno_red_zone, 487 true) || 488 Args.hasArg(options::OPT_mkernel) || 489 Args.hasArg(options::OPT_fapple_kext)) 490 CmdArgs.push_back("-disable-red-zone"); 491 492 if (Args.hasFlag(options::OPT_msoft_float, 493 options::OPT_mno_soft_float, 494 false)) 495 CmdArgs.push_back("-no-implicit-float"); 496 497 const char *CPUName = 0; 498 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) { 499 if (llvm::StringRef(A->getValue(Args)) == "native") { 500 // FIXME: Reject attempts to use -march=native unless the target matches 501 // the host. 502 // 503 // FIXME: We should also incorporate the detected target features for use 504 // with -native. 505 std::string CPU = llvm::sys::getHostCPUName(); 506 if (!CPU.empty()) 507 CPUName = Args.MakeArgString(CPU); 508 } else 509 CPUName = A->getValue(Args); 510 } 511 512 // Select the default CPU if none was given (or detection failed). 513 if (!CPUName) { 514 // FIXME: Need target hooks. 515 if (getToolChain().getOS().startswith("darwin")) { 516 if (getToolChain().getArchName() == "x86_64") 517 CPUName = "core2"; 518 else if (getToolChain().getArchName() == "i386") 519 CPUName = "yonah"; 520 } else { 521 if (getToolChain().getArchName() == "x86_64") 522 CPUName = "x86-64"; 523 else if (getToolChain().getArchName() == "i386") 524 CPUName = "pentium4"; 525 } 526 } 527 528 if (CPUName) { 529 CmdArgs.push_back("-target-cpu"); 530 CmdArgs.push_back(CPUName); 531 } 532 533 for (arg_iterator it = Args.filtered_begin(options::OPT_m_x86_Features_Group), 534 ie = Args.filtered_end(); it != ie; ++it) { 535 llvm::StringRef Name = it->getOption().getName(); 536 it->claim(); 537 538 // Skip over "-m". 539 assert(Name.startswith("-m") && "Invalid feature name."); 540 Name = Name.substr(2); 541 542 bool IsNegative = Name.startswith("no-"); 543 if (IsNegative) 544 Name = Name.substr(3); 545 546 CmdArgs.push_back("-target-feature"); 547 CmdArgs.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name)); 548 } 549} 550 551static bool needsExceptions(const ArgList &Args, types::ID InputType, 552 const llvm::Triple &Triple) { 553 if (Arg *A = Args.getLastArg(options::OPT_fexceptions, 554 options::OPT_fno_exceptions)) { 555 if (A->getOption().matches(options::OPT_fexceptions)) 556 return true; 557 else 558 return false; 559 } 560 switch (InputType) { 561 case types::TY_CXX: case types::TY_CXXHeader: 562 case types::TY_PP_CXX: case types::TY_PP_CXXHeader: 563 case types::TY_ObjCXX: case types::TY_ObjCXXHeader: 564 case types::TY_PP_ObjCXX: case types::TY_PP_ObjCXXHeader: 565 return true; 566 567 case types::TY_ObjC: case types::TY_ObjCHeader: 568 case types::TY_PP_ObjC: case types::TY_PP_ObjCHeader: 569 if (Args.hasArg(options::OPT_fobjc_nonfragile_abi)) 570 return true; 571 if (Triple.getOS() != llvm::Triple::Darwin) 572 return false; 573 return (Triple.getDarwinMajorNumber() >= 9 && 574 Triple.getArch() == llvm::Triple::x86_64); 575 576 default: 577 return false; 578 } 579} 580 581/// getEffectiveClangTriple - Get the "effective" target triple, which is the 582/// triple for the target but with the OS version potentially modified for 583/// Darwin's -mmacosx-version-min. 584static std::string getEffectiveClangTriple(const Driver &D, 585 const ToolChain &TC, 586 const ArgList &Args) { 587 llvm::Triple Triple(getLLVMTriple(TC, Args)); 588 589 // Handle -mmacosx-version-min and -miphoneos-version-min. 590 if (Triple.getOS() != llvm::Triple::Darwin) { 591 // Diagnose use of -mmacosx-version-min and -miphoneos-version-min on 592 // non-Darwin. 593 if (Arg *A = Args.getLastArg(options::OPT_mmacosx_version_min_EQ, 594 options::OPT_miphoneos_version_min_EQ)) 595 D.Diag(clang::diag::err_drv_clang_unsupported) << A->getAsString(Args); 596 } else { 597 const toolchains::Darwin &DarwinTC( 598 reinterpret_cast<const toolchains::Darwin&>(TC)); 599 unsigned Version[3]; 600 DarwinTC.getTargetVersion(Version); 601 602 // Mangle the target version into the OS triple component. For historical 603 // reasons that make little sense, the version passed here is the "darwin" 604 // version, which drops the 10 and offsets by 4. See inverse code when 605 // setting the OS version preprocessor define. 606 if (!DarwinTC.isTargetIPhoneOS()) { 607 Version[0] = Version[1] + 4; 608 Version[1] = Version[2]; 609 Version[2] = 0; 610 } else { 611 // Use the environment to communicate that we are targetting iPhoneOS. 612 Triple.setEnvironmentName("iphoneos"); 613 } 614 615 llvm::SmallString<16> Str; 616 llvm::raw_svector_ostream(Str) << "darwin" << Version[0] 617 << "." << Version[1] << "." << Version[2]; 618 Triple.setOSName(Str.str()); 619 } 620 621 return Triple.getTriple(); 622} 623 624void Clang::ConstructJob(Compilation &C, const JobAction &JA, 625 Job &Dest, 626 const InputInfo &Output, 627 const InputInfoList &Inputs, 628 const ArgList &Args, 629 const char *LinkingOutput) const { 630 const Driver &D = getToolChain().getDriver(); 631 ArgStringList CmdArgs; 632 633 assert(Inputs.size() == 1 && "Unable to handle multiple inputs."); 634 635 // Invoke ourselves in -cc1 mode. 636 // 637 // FIXME: Implement custom jobs for internal actions. 638 CmdArgs.push_back("-cc1"); 639 640 // Add the "effective" target triple. 641 CmdArgs.push_back("-triple"); 642 std::string TripleStr = getEffectiveClangTriple(D, getToolChain(), Args); 643 CmdArgs.push_back(Args.MakeArgString(TripleStr)); 644 645 // Select the appropriate action. 646 if (isa<AnalyzeJobAction>(JA)) { 647 assert(JA.getType() == types::TY_Plist && "Invalid output type."); 648 CmdArgs.push_back("-analyze"); 649 } else if (isa<PreprocessJobAction>(JA)) { 650 if (Output.getType() == types::TY_Dependencies) 651 CmdArgs.push_back("-Eonly"); 652 else 653 CmdArgs.push_back("-E"); 654 } else if (isa<PrecompileJobAction>(JA)) { 655 // Use PCH if the user requested it, except for C++ (for now). 656 bool UsePCH = D.CCCUsePCH; 657 if (types::isCXX(Inputs[0].getType())) 658 UsePCH = false; 659 660 if (UsePCH) 661 CmdArgs.push_back("-emit-pch"); 662 else 663 CmdArgs.push_back("-emit-pth"); 664 } else { 665 assert(isa<CompileJobAction>(JA) && "Invalid action for clang tool."); 666 667 if (JA.getType() == types::TY_Nothing) { 668 CmdArgs.push_back("-fsyntax-only"); 669 } else if (JA.getType() == types::TY_LLVMAsm) { 670 CmdArgs.push_back("-emit-llvm"); 671 } else if (JA.getType() == types::TY_LLVMBC) { 672 CmdArgs.push_back("-emit-llvm-bc"); 673 } else if (JA.getType() == types::TY_PP_Asm) { 674 CmdArgs.push_back("-S"); 675 } else if (JA.getType() == types::TY_AST) { 676 CmdArgs.push_back("-emit-pch"); 677 } 678 } 679 680 // The make clang go fast button. 681 CmdArgs.push_back("-disable-free"); 682 683 // Set the main file name, so that debug info works even with 684 // -save-temps. 685 CmdArgs.push_back("-main-file-name"); 686 CmdArgs.push_back(darwin::CC1::getBaseInputName(Args, Inputs)); 687 688 // Some flags which affect the language (via preprocessor 689 // defines). See darwin::CC1::AddCPPArgs. 690 if (Args.hasArg(options::OPT_static)) 691 CmdArgs.push_back("-static-define"); 692 693 if (isa<AnalyzeJobAction>(JA)) { 694 // Enable region store model by default. 695 CmdArgs.push_back("-analyzer-store=region"); 696 697 // Treat blocks as analysis entry points. 698 CmdArgs.push_back("-analyzer-opt-analyze-nested-blocks"); 699 700 // Add default argument set. 701 if (!Args.hasArg(options::OPT__analyzer_no_default_checks)) { 702 CmdArgs.push_back("-warn-dead-stores"); 703 CmdArgs.push_back("-warn-security-syntactic"); 704 CmdArgs.push_back("-checker-cfref"); 705 CmdArgs.push_back("-analyzer-eagerly-assume"); 706 CmdArgs.push_back("-warn-objc-methodsigs"); 707 // Do not enable the missing -dealloc check. 708 // '-warn-objc-missing-dealloc', 709 CmdArgs.push_back("-warn-objc-unused-ivars"); 710 } 711 712 // Set the output format. The default is plist, for (lame) historical 713 // reasons. 714 CmdArgs.push_back("-analyzer-output"); 715 if (Arg *A = Args.getLastArg(options::OPT__analyzer_output)) 716 CmdArgs.push_back(A->getValue(Args)); 717 else 718 CmdArgs.push_back("plist"); 719 720 // Add -Xanalyzer arguments when running as analyzer. 721 Args.AddAllArgValues(CmdArgs, options::OPT_Xanalyzer); 722 } 723 724 CheckCodeGenerationOptions(D, Args); 725 726 // Perform argument translation for LLVM backend. This 727 // takes some care in reconciling with llvm-gcc. The 728 // issue is that llvm-gcc translates these options based on 729 // the values in cc1, whereas we are processing based on 730 // the driver arguments. 731 732 // This comes from the default translation the driver + cc1 733 // would do to enable flag_pic. 734 // 735 // FIXME: Centralize this code. 736 bool PICEnabled = (Args.hasArg(options::OPT_fPIC) || 737 Args.hasArg(options::OPT_fpic) || 738 Args.hasArg(options::OPT_fPIE) || 739 Args.hasArg(options::OPT_fpie)); 740 bool PICDisabled = (Args.hasArg(options::OPT_mkernel) || 741 Args.hasArg(options::OPT_static)); 742 const char *Model = getToolChain().GetForcedPicModel(); 743 if (!Model) { 744 if (Args.hasArg(options::OPT_mdynamic_no_pic)) 745 Model = "dynamic-no-pic"; 746 else if (PICDisabled) 747 Model = "static"; 748 else if (PICEnabled) 749 Model = "pic"; 750 else 751 Model = getToolChain().GetDefaultRelocationModel(); 752 } 753 if (llvm::StringRef(Model) != "pic") { 754 CmdArgs.push_back("-mrelocation-model"); 755 CmdArgs.push_back(Model); 756 } 757 758 // Infer the __PIC__ value. 759 // 760 // FIXME: This isn't quite right on Darwin, which always sets 761 // __PIC__=2. 762 if (strcmp(Model, "pic") == 0 || strcmp(Model, "dynamic-no-pic") == 0) { 763 CmdArgs.push_back("-pic-level"); 764 CmdArgs.push_back(Args.hasArg(options::OPT_fPIC) ? "2" : "1"); 765 } 766 if (!Args.hasFlag(options::OPT_fmerge_all_constants, 767 options::OPT_fno_merge_all_constants)) 768 CmdArgs.push_back("-no-merge-all-constants"); 769 770 // LLVM Code Generator Options. 771 772 // FIXME: Set --enable-unsafe-fp-math. 773 if (Args.hasFlag(options::OPT_fno_omit_frame_pointer, 774 options::OPT_fomit_frame_pointer)) 775 CmdArgs.push_back("-mdisable-fp-elim"); 776 if (!Args.hasFlag(options::OPT_fzero_initialized_in_bss, 777 options::OPT_fno_zero_initialized_in_bss)) 778 CmdArgs.push_back("-mno-zero-initialized-in-bss"); 779 if (Args.hasArg(options::OPT_dA) || Args.hasArg(options::OPT_fverbose_asm)) 780 CmdArgs.push_back("-masm-verbose"); 781 if (Args.hasArg(options::OPT_fdebug_pass_structure)) { 782 CmdArgs.push_back("-mdebug-pass"); 783 CmdArgs.push_back("Structure"); 784 } 785 if (Args.hasArg(options::OPT_fdebug_pass_arguments)) { 786 CmdArgs.push_back("-mdebug-pass"); 787 CmdArgs.push_back("Arguments"); 788 } 789 790 // This is a coarse approximation of what llvm-gcc actually does, both 791 // -fasynchronous-unwind-tables and -fnon-call-exceptions interact in more 792 // complicated ways. 793 bool AsynchronousUnwindTables = 794 Args.hasFlag(options::OPT_fasynchronous_unwind_tables, 795 options::OPT_fno_asynchronous_unwind_tables, 796 getToolChain().IsUnwindTablesDefault() && 797 !Args.hasArg(options::OPT_mkernel)); 798 if (Args.hasFlag(options::OPT_funwind_tables, options::OPT_fno_unwind_tables, 799 AsynchronousUnwindTables)) 800 CmdArgs.push_back("-munwind-tables"); 801 802 if (Arg *A = Args.getLastArg(options::OPT_flimited_precision_EQ)) { 803 CmdArgs.push_back("-mlimit-float-precision"); 804 CmdArgs.push_back(A->getValue(Args)); 805 } 806 807 // FIXME: Handle -mtune=. 808 (void) Args.hasArg(options::OPT_mtune_EQ); 809 810 if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) { 811 CmdArgs.push_back("-mcode-model"); 812 CmdArgs.push_back(A->getValue(Args)); 813 } 814 815 // Add target specific cpu and features flags. 816 switch(getToolChain().getTriple().getArch()) { 817 default: 818 break; 819 820 case llvm::Triple::arm: 821 case llvm::Triple::thumb: 822 AddARMTargetArgs(Args, CmdArgs); 823 break; 824 825 case llvm::Triple::x86: 826 case llvm::Triple::x86_64: 827 AddX86TargetArgs(Args, CmdArgs); 828 break; 829 } 830 831 // -fno-math-errno is default. 832 if (Args.hasFlag(options::OPT_fmath_errno, 833 options::OPT_fno_math_errno, 834 false)) 835 CmdArgs.push_back("-fmath-errno"); 836 837 Arg *Unsupported; 838 if ((Unsupported = Args.getLastArg(options::OPT_MG)) || 839 (Unsupported = Args.getLastArg(options::OPT_MQ)) || 840 (Unsupported = Args.getLastArg(options::OPT_iframework)) || 841 (Unsupported = Args.getLastArg(options::OPT_fshort_enums))) 842 D.Diag(clang::diag::err_drv_clang_unsupported) 843 << Unsupported->getOption().getName(); 844 845 Args.AddAllArgs(CmdArgs, options::OPT_v); 846 Args.AddLastArg(CmdArgs, options::OPT_P); 847 Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout); 848 849 // Special case debug options to only pass -g to clang. This is 850 // wrong. 851 if (Args.hasArg(options::OPT_g_Group)) 852 CmdArgs.push_back("-g"); 853 854 Args.AddLastArg(CmdArgs, options::OPT_nostdinc); 855 Args.AddLastArg(CmdArgs, options::OPT_nobuiltininc); 856 857 // Pass the path to compiler resource files. 858 CmdArgs.push_back("-resource-dir"); 859 CmdArgs.push_back(D.ResourceDir.c_str()); 860 861 // Add preprocessing options like -I, -D, etc. if we are using the 862 // preprocessor. 863 // 864 // FIXME: Support -fpreprocessed 865 types::ID InputType = Inputs[0].getType(); 866 if (types::getPreprocessedType(InputType) != types::TY_INVALID) 867 AddPreprocessingOptions(D, Args, CmdArgs, Output, Inputs); 868 869 // Manually translate -O to -O2 and -O4 to -O3; let clang reject 870 // others. 871 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) { 872 if (A->getOption().matches(options::OPT_O4)) 873 CmdArgs.push_back("-O3"); 874 else if (A->getValue(Args)[0] == '\0') 875 CmdArgs.push_back("-O2"); 876 else 877 A->render(Args, CmdArgs); 878 } 879 880 Args.AddAllArgs(CmdArgs, options::OPT_W_Group); 881 Args.AddLastArg(CmdArgs, options::OPT_pedantic); 882 Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors); 883 Args.AddLastArg(CmdArgs, options::OPT_w); 884 885 // Handle -{std, ansi, trigraphs} -- take the last of -{std, ansi} 886 // (-ansi is equivalent to -std=c89). 887 // 888 // If a std is supplied, only add -trigraphs if it follows the 889 // option. 890 if (Arg *Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) { 891 if (Std->getOption().matches(options::OPT_ansi)) 892 if (types::isCXX(InputType)) 893 CmdArgs.push_back("-std=c++98"); 894 else 895 CmdArgs.push_back("-std=c89"); 896 else 897 Std->render(Args, CmdArgs); 898 899 if (Arg *A = Args.getLastArg(options::OPT_trigraphs)) 900 if (A->getIndex() > Std->getIndex()) 901 A->render(Args, CmdArgs); 902 } else { 903 // Honor -std-default. 904 // 905 // FIXME: Clang doesn't correctly handle -std= when the input language 906 // doesn't match. For the time being just ignore this for C++ inputs; 907 // eventually we want to do all the standard defaulting here instead of 908 // splitting it between the driver and clang -cc1. 909 if (!types::isCXX(InputType)) 910 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ, 911 "-std=", /*Joined=*/true); 912 Args.AddLastArg(CmdArgs, options::OPT_trigraphs); 913 } 914 915 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_depth_)) { 916 CmdArgs.push_back("-ftemplate-depth"); 917 CmdArgs.push_back(A->getValue(Args)); 918 } 919 920 if (Args.hasArg(options::OPT__relocatable_pch)) 921 CmdArgs.push_back("-relocatable-pch"); 922 923 if (Arg *A = Args.getLastArg(options::OPT_fconstant_string_class_EQ)) { 924 CmdArgs.push_back("-fconstant-string-class"); 925 CmdArgs.push_back(A->getValue(Args)); 926 } 927 928 if (Arg *A = Args.getLastArg(options::OPT_ftabstop_EQ)) { 929 CmdArgs.push_back("-ftabstop"); 930 CmdArgs.push_back(A->getValue(Args)); 931 } 932 933 // Pass -fmessage-length=. 934 CmdArgs.push_back("-fmessage-length"); 935 if (Arg *A = Args.getLastArg(options::OPT_fmessage_length_EQ)) { 936 CmdArgs.push_back(A->getValue(Args)); 937 } else { 938 // If -fmessage-length=N was not specified, determine whether this is a 939 // terminal and, if so, implicitly define -fmessage-length appropriately. 940 unsigned N = llvm::sys::Process::StandardErrColumns(); 941 CmdArgs.push_back(Args.MakeArgString(llvm::Twine(N))); 942 } 943 944 if (const Arg *A = Args.getLastArg(options::OPT_fvisibility_EQ)) { 945 CmdArgs.push_back("-fvisibility"); 946 CmdArgs.push_back(A->getValue(Args)); 947 } 948 949 // Forward -f (flag) options which we can pass directly. 950 Args.AddLastArg(CmdArgs, options::OPT_fcatch_undefined_behavior); 951 Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls); 952 Args.AddLastArg(CmdArgs, options::OPT_ffreestanding); 953 Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions); 954 Args.AddLastArg(CmdArgs, options::OPT_flax_vector_conversions); 955 Args.AddLastArg(CmdArgs, options::OPT_fno_caret_diagnostics); 956 Args.AddLastArg(CmdArgs, options::OPT_fno_show_column); 957 Args.AddLastArg(CmdArgs, options::OPT_fobjc_gc_only); 958 Args.AddLastArg(CmdArgs, options::OPT_fobjc_gc); 959 Args.AddLastArg(CmdArgs, options::OPT_fobjc_sender_dependent_dispatch); 960 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_print_source_range_info); 961 Args.AddLastArg(CmdArgs, options::OPT_ftime_report); 962 Args.AddLastArg(CmdArgs, options::OPT_ftrapv); 963 Args.AddLastArg(CmdArgs, options::OPT_fwritable_strings); 964 965 Args.AddLastArg(CmdArgs, options::OPT_pthread); 966 967 // -stack-protector=0 is default. 968 unsigned StackProtectorLevel = 0; 969 if (Arg *A = Args.getLastArg(options::OPT_fno_stack_protector, 970 options::OPT_fstack_protector_all, 971 options::OPT_fstack_protector)) { 972 if (A->getOption().matches(options::OPT_fstack_protector)) 973 StackProtectorLevel = 1; 974 else if (A->getOption().matches(options::OPT_fstack_protector_all)) 975 StackProtectorLevel = 2; 976 } else 977 StackProtectorLevel = getToolChain().GetDefaultStackProtectorLevel(); 978 if (StackProtectorLevel) { 979 CmdArgs.push_back("-stack-protector"); 980 CmdArgs.push_back(Args.MakeArgString(llvm::Twine(StackProtectorLevel))); 981 } 982 983 // Forward -f options with positive and negative forms; we translate 984 // these by hand. 985 986 // -fbuiltin is default. 987 if (!Args.hasFlag(options::OPT_fbuiltin, options::OPT_fno_builtin)) 988 CmdArgs.push_back("-fno-builtin"); 989 990 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new, 991 options::OPT_fno_assume_sane_operator_new)) 992 CmdArgs.push_back("-fno-assume-sane-operator-new"); 993 994 // -fblocks=0 is default. 995 if (Args.hasFlag(options::OPT_fblocks, options::OPT_fno_blocks, 996 getToolChain().IsBlocksDefault())) { 997 Args.AddLastArg(CmdArgs, options::OPT_fblock_introspection); 998 CmdArgs.push_back("-fblocks"); 999 } 1000 1001 // -fexceptions=0 is default. 1002 if (needsExceptions(Args, InputType, getToolChain().getTriple())) 1003 CmdArgs.push_back("-fexceptions"); 1004 1005 // -frtti is default. 1006 if (!Args.hasFlag(options::OPT_frtti, options::OPT_fno_rtti)) 1007 CmdArgs.push_back("-fno-rtti"); 1008 1009 // -fsigned-char is default. 1010 if (!Args.hasFlag(options::OPT_fsigned_char, options::OPT_funsigned_char, 1011 isSignedCharDefault(getToolChain().getTriple()))) 1012 CmdArgs.push_back("-fno-signed-char"); 1013 1014 // -fms-extensions=0 is default. 1015 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions, 1016 getToolChain().getTriple().getOS() == llvm::Triple::Win32)) 1017 CmdArgs.push_back("-fms-extensions"); 1018 1019 // -fnext-runtime is default. 1020 if (!Args.hasFlag(options::OPT_fnext_runtime, options::OPT_fgnu_runtime, 1021 getToolChain().getTriple().getOS() == llvm::Triple::Darwin)) 1022 CmdArgs.push_back("-fgnu-runtime"); 1023 1024 // -fobjc-nonfragile-abi=0 is default. 1025 if (types::isObjC(InputType)) { 1026 if (Args.hasArg(options::OPT_fobjc_nonfragile_abi) || 1027 getToolChain().IsObjCNonFragileABIDefault()) 1028 CmdArgs.push_back("-fobjc-nonfragile-abi"); 1029 } 1030 1031 // -fshort-wchar default varies depending on platform; only 1032 // pass if specified. 1033 if (Arg *A = Args.getLastArg(options::OPT_fshort_wchar)) { 1034 if (A->getOption().matches(options::OPT_fshort_wchar)) 1035 CmdArgs.push_back("-fshort-wchar"); 1036 } 1037 1038 // -fno-pascal-strings is default, only pass non-default. If the tool chain 1039 // happened to translate to -mpascal-strings, we want to back translate here. 1040 // 1041 // FIXME: This is gross; that translation should be pulled from the 1042 // tool chain. 1043 if (Args.hasFlag(options::OPT_fpascal_strings, 1044 options::OPT_fno_pascal_strings, 1045 false) || 1046 Args.hasFlag(options::OPT_mpascal_strings, 1047 options::OPT_mno_pascal_strings, 1048 false)) 1049 CmdArgs.push_back("-fpascal-strings"); 1050 1051 // -fcommon is default, only pass non-default. 1052 if (!Args.hasFlag(options::OPT_fcommon, options::OPT_fno_common)) 1053 CmdArgs.push_back("-fno-common"); 1054 1055 // -fsigned-bitfields is default, and clang doesn't yet support 1056 // --funsigned-bitfields. 1057 if (!Args.hasFlag(options::OPT_fsigned_bitfields, 1058 options::OPT_funsigned_bitfields)) 1059 D.Diag(clang::diag::warn_drv_clang_unsupported) 1060 << Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args); 1061 1062 // -fdiagnostics-fixit-info is default, only pass non-default. 1063 if (!Args.hasFlag(options::OPT_fdiagnostics_fixit_info, 1064 options::OPT_fno_diagnostics_fixit_info)) 1065 CmdArgs.push_back("-fno-diagnostics-fixit-info"); 1066 1067 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_binary); 1068 1069 // Enable -fdiagnostics-show-option by default. 1070 if (Args.hasFlag(options::OPT_fdiagnostics_show_option, 1071 options::OPT_fno_diagnostics_show_option)) 1072 CmdArgs.push_back("-fdiagnostics-show-option"); 1073 1074 // Color diagnostics are the default, unless the terminal doesn't support 1075 // them. 1076 if (Args.hasFlag(options::OPT_fcolor_diagnostics, 1077 options::OPT_fno_color_diagnostics) && 1078 llvm::sys::Process::StandardErrHasColors()) 1079 CmdArgs.push_back("-fcolor-diagnostics"); 1080 1081 if (!Args.hasFlag(options::OPT_fshow_source_location, 1082 options::OPT_fno_show_source_location)) 1083 CmdArgs.push_back("-fno-show-source-location"); 1084 1085 // -fdollars-in-identifiers default varies depending on platform and 1086 // language; only pass if specified. 1087 if (Arg *A = Args.getLastArg(options::OPT_fdollars_in_identifiers, 1088 options::OPT_fno_dollars_in_identifiers)) { 1089 if (A->getOption().matches(options::OPT_fdollars_in_identifiers)) 1090 CmdArgs.push_back("-fdollars-in-identifiers"); 1091 else 1092 CmdArgs.push_back("-fno-dollars-in-identifiers"); 1093 } 1094 1095 // -funit-at-a-time is default, and we don't support -fno-unit-at-a-time for 1096 // practical purposes. 1097 if (Arg *A = Args.getLastArg(options::OPT_funit_at_a_time, 1098 options::OPT_fno_unit_at_a_time)) { 1099 if (A->getOption().matches(options::OPT_fno_unit_at_a_time)) 1100 D.Diag(clang::diag::warn_drv_clang_unsupported) << A->getAsString(Args); 1101 } 1102 1103 // Default to -fno-builtin-str{cat,cpy} on Darwin for ARM. 1104 // 1105 // FIXME: This is disabled until clang -cc1 supports -fno-builtin-foo. PR4941. 1106#if 0 1107 if (getToolChain().getTriple().getOS() == llvm::Triple::Darwin && 1108 (getToolChain().getTriple().getArch() == llvm::Triple::arm || 1109 getToolChain().getTriple().getArch() == llvm::Triple::thumb)) { 1110 if (!Args.hasArg(options::OPT_fbuiltin_strcat)) 1111 CmdArgs.push_back("-fno-builtin-strcat"); 1112 if (!Args.hasArg(options::OPT_fbuiltin_strcpy)) 1113 CmdArgs.push_back("-fno-builtin-strcpy"); 1114 } 1115#endif 1116 1117 if (Arg *A = Args.getLastArg(options::OPT_traditional, 1118 options::OPT_traditional_cpp)) 1119 D.Diag(clang::diag::err_drv_clang_unsupported) << A->getAsString(Args); 1120 1121 Args.AddLastArg(CmdArgs, options::OPT_dM); 1122 Args.AddLastArg(CmdArgs, options::OPT_dD); 1123 1124 Args.AddAllArgValues(CmdArgs, options::OPT_Xclang); 1125 Args.AddAllArgValues(CmdArgs, options::OPT_mllvm); 1126 1127 if (Output.getType() == types::TY_Dependencies) { 1128 // Handled with other dependency code. 1129 } else if (Output.isPipe()) { 1130 CmdArgs.push_back("-o"); 1131 CmdArgs.push_back("-"); 1132 } else if (Output.isFilename()) { 1133 CmdArgs.push_back("-o"); 1134 CmdArgs.push_back(Output.getFilename()); 1135 } else { 1136 assert(Output.isNothing() && "Invalid output."); 1137 } 1138 1139 for (InputInfoList::const_iterator 1140 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 1141 const InputInfo &II = *it; 1142 CmdArgs.push_back("-x"); 1143 CmdArgs.push_back(types::getTypeName(II.getType())); 1144 if (II.isPipe()) 1145 CmdArgs.push_back("-"); 1146 else if (II.isFilename()) 1147 CmdArgs.push_back(II.getFilename()); 1148 else 1149 II.getInputArg().renderAsInput(Args, CmdArgs); 1150 } 1151 1152 Args.AddAllArgs(CmdArgs, options::OPT_undef); 1153 1154 const char *Exec = 1155 Args.MakeArgString(getToolChain().GetProgramPath(C, "clang")); 1156 1157 // Optionally embed the -cc1 level arguments into the debug info, for build 1158 // analysis. 1159 if (getToolChain().UseDwarfDebugFlags()) { 1160 llvm::SmallString<256> Flags; 1161 Flags += Exec; 1162 for (unsigned i = 0, e = CmdArgs.size(); i != e; ++i) { 1163 Flags += " "; 1164 Flags += CmdArgs[i]; 1165 } 1166 CmdArgs.push_back("-dwarf-debug-flags"); 1167 CmdArgs.push_back(Args.MakeArgString(Flags.str())); 1168 } 1169 1170 Dest.addCommand(new Command(JA, *this, Exec, CmdArgs)); 1171 1172 // Explicitly warn that these options are unsupported, even though 1173 // we are allowing compilation to continue. 1174 for (arg_iterator it = Args.filtered_begin(options::OPT_pg), 1175 ie = Args.filtered_end(); it != ie; ++it) { 1176 it->claim(); 1177 D.Diag(clang::diag::warn_drv_clang_unsupported) << it->getAsString(Args); 1178 } 1179 1180 // Claim some arguments which clang supports automatically. 1181 1182 // -fpch-preprocess is used with gcc to add a special marker in the 1183 // -output to include the PCH file. Clang's PTH solution is 1184 // -completely transparent, so we do not need to deal with it at 1185 // -all. 1186 Args.ClaimAllArgs(options::OPT_fpch_preprocess); 1187 1188 // Claim some arguments which clang doesn't support, but we don't 1189 // care to warn the user about. 1190 Args.ClaimAllArgs(options::OPT_clang_ignored_f_Group); 1191 Args.ClaimAllArgs(options::OPT_clang_ignored_m_Group); 1192} 1193 1194void gcc::Common::ConstructJob(Compilation &C, const JobAction &JA, 1195 Job &Dest, 1196 const InputInfo &Output, 1197 const InputInfoList &Inputs, 1198 const ArgList &Args, 1199 const char *LinkingOutput) const { 1200 const Driver &D = getToolChain().getDriver(); 1201 ArgStringList CmdArgs; 1202 1203 for (ArgList::const_iterator 1204 it = Args.begin(), ie = Args.end(); it != ie; ++it) { 1205 Arg *A = *it; 1206 if (A->getOption().hasForwardToGCC()) { 1207 // It is unfortunate that we have to claim here, as this means 1208 // we will basically never report anything interesting for 1209 // platforms using a generic gcc, even if we are just using gcc 1210 // to get to the assembler. 1211 A->claim(); 1212 A->render(Args, CmdArgs); 1213 } 1214 } 1215 1216 RenderExtraToolArgs(JA, CmdArgs); 1217 1218 // If using a driver driver, force the arch. 1219 const std::string &Arch = getToolChain().getArchName(); 1220 if (getToolChain().getTriple().getOS() == llvm::Triple::Darwin) { 1221 CmdArgs.push_back("-arch"); 1222 1223 // FIXME: Remove these special cases. 1224 if (Arch == "powerpc") 1225 CmdArgs.push_back("ppc"); 1226 else if (Arch == "powerpc64") 1227 CmdArgs.push_back("ppc64"); 1228 else 1229 CmdArgs.push_back(Args.MakeArgString(Arch)); 1230 } 1231 1232 // Try to force gcc to match the tool chain we want, if we recognize 1233 // the arch. 1234 // 1235 // FIXME: The triple class should directly provide the information we want 1236 // here. 1237 if (Arch == "i386" || Arch == "powerpc") 1238 CmdArgs.push_back("-m32"); 1239 else if (Arch == "x86_64" || Arch == "powerpc64") 1240 CmdArgs.push_back("-m64"); 1241 1242 if (Output.isPipe()) { 1243 CmdArgs.push_back("-o"); 1244 CmdArgs.push_back("-"); 1245 } else if (Output.isFilename()) { 1246 CmdArgs.push_back("-o"); 1247 CmdArgs.push_back(Output.getFilename()); 1248 } else { 1249 assert(Output.isNothing() && "Unexpected output"); 1250 CmdArgs.push_back("-fsyntax-only"); 1251 } 1252 1253 1254 // Only pass -x if gcc will understand it; otherwise hope gcc 1255 // understands the suffix correctly. The main use case this would go 1256 // wrong in is for linker inputs if they happened to have an odd 1257 // suffix; really the only way to get this to happen is a command 1258 // like '-x foobar a.c' which will treat a.c like a linker input. 1259 // 1260 // FIXME: For the linker case specifically, can we safely convert 1261 // inputs into '-Wl,' options? 1262 for (InputInfoList::const_iterator 1263 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 1264 const InputInfo &II = *it; 1265 1266 // Don't try to pass LLVM or AST inputs to a generic gcc. 1267 if (II.getType() == types::TY_LLVMBC) 1268 D.Diag(clang::diag::err_drv_no_linker_llvm_support) 1269 << getToolChain().getTripleString(); 1270 else if (II.getType() == types::TY_AST) 1271 D.Diag(clang::diag::err_drv_no_ast_support) 1272 << getToolChain().getTripleString(); 1273 1274 if (types::canTypeBeUserSpecified(II.getType())) { 1275 CmdArgs.push_back("-x"); 1276 CmdArgs.push_back(types::getTypeName(II.getType())); 1277 } 1278 1279 if (II.isPipe()) 1280 CmdArgs.push_back("-"); 1281 else if (II.isFilename()) 1282 CmdArgs.push_back(II.getFilename()); 1283 else 1284 // Don't render as input, we need gcc to do the translations. 1285 II.getInputArg().render(Args, CmdArgs); 1286 } 1287 1288 const char *GCCName = getToolChain().getDriver().CCCGenericGCCName.c_str(); 1289 const char *Exec = 1290 Args.MakeArgString(getToolChain().GetProgramPath(C, GCCName)); 1291 Dest.addCommand(new Command(JA, *this, Exec, CmdArgs)); 1292} 1293 1294void gcc::Preprocess::RenderExtraToolArgs(const JobAction &JA, 1295 ArgStringList &CmdArgs) const { 1296 CmdArgs.push_back("-E"); 1297} 1298 1299void gcc::Precompile::RenderExtraToolArgs(const JobAction &JA, 1300 ArgStringList &CmdArgs) const { 1301 // The type is good enough. 1302} 1303 1304void gcc::Compile::RenderExtraToolArgs(const JobAction &JA, 1305 ArgStringList &CmdArgs) const { 1306 // If -flto, etc. are present then make sure not to force assembly output. 1307 if (JA.getType() == types::TY_LLVMBC) 1308 CmdArgs.push_back("-c"); 1309 else 1310 CmdArgs.push_back("-S"); 1311} 1312 1313void gcc::Assemble::RenderExtraToolArgs(const JobAction &JA, 1314 ArgStringList &CmdArgs) const { 1315 CmdArgs.push_back("-c"); 1316} 1317 1318void gcc::Link::RenderExtraToolArgs(const JobAction &JA, 1319 ArgStringList &CmdArgs) const { 1320 // The types are (hopefully) good enough. 1321} 1322 1323const char *darwin::CC1::getCC1Name(types::ID Type) const { 1324 switch (Type) { 1325 default: 1326 assert(0 && "Unexpected type for Darwin CC1 tool."); 1327 case types::TY_Asm: 1328 case types::TY_C: case types::TY_CHeader: 1329 case types::TY_PP_C: case types::TY_PP_CHeader: 1330 return "cc1"; 1331 case types::TY_ObjC: case types::TY_ObjCHeader: 1332 case types::TY_PP_ObjC: case types::TY_PP_ObjCHeader: 1333 return "cc1obj"; 1334 case types::TY_CXX: case types::TY_CXXHeader: 1335 case types::TY_PP_CXX: case types::TY_PP_CXXHeader: 1336 return "cc1plus"; 1337 case types::TY_ObjCXX: case types::TY_ObjCXXHeader: 1338 case types::TY_PP_ObjCXX: case types::TY_PP_ObjCXXHeader: 1339 return "cc1objplus"; 1340 } 1341} 1342 1343const char *darwin::CC1::getBaseInputName(const ArgList &Args, 1344 const InputInfoList &Inputs) { 1345 llvm::sys::Path P(Inputs[0].getBaseInput()); 1346 return Args.MakeArgString(P.getLast()); 1347} 1348 1349const char *darwin::CC1::getBaseInputStem(const ArgList &Args, 1350 const InputInfoList &Inputs) { 1351 const char *Str = getBaseInputName(Args, Inputs); 1352 1353 if (const char *End = strchr(Str, '.')) 1354 return Args.MakeArgString(std::string(Str, End)); 1355 1356 return Str; 1357} 1358 1359const char * 1360darwin::CC1::getDependencyFileName(const ArgList &Args, 1361 const InputInfoList &Inputs) { 1362 // FIXME: Think about this more. 1363 std::string Res; 1364 1365 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) { 1366 std::string Str(OutputOpt->getValue(Args)); 1367 1368 Res = Str.substr(0, Str.rfind('.')); 1369 } else 1370 Res = darwin::CC1::getBaseInputStem(Args, Inputs); 1371 1372 return Args.MakeArgString(Res + ".d"); 1373} 1374 1375void darwin::CC1::AddCC1Args(const ArgList &Args, 1376 ArgStringList &CmdArgs) const { 1377 const Driver &D = getToolChain().getDriver(); 1378 1379 CheckCodeGenerationOptions(D, Args); 1380 1381 // Derived from cc1 spec. 1382 if (!Args.hasArg(options::OPT_mkernel) && !Args.hasArg(options::OPT_static) && 1383 !Args.hasArg(options::OPT_mdynamic_no_pic)) 1384 CmdArgs.push_back("-fPIC"); 1385 1386 if (getToolChain().getTriple().getArch() == llvm::Triple::arm || 1387 getToolChain().getTriple().getArch() == llvm::Triple::thumb) { 1388 if (!Args.hasArg(options::OPT_fbuiltin_strcat)) 1389 CmdArgs.push_back("-fno-builtin-strcat"); 1390 if (!Args.hasArg(options::OPT_fbuiltin_strcpy)) 1391 CmdArgs.push_back("-fno-builtin-strcpy"); 1392 } 1393 1394 // gcc has some code here to deal with when no -mmacosx-version-min 1395 // and no -miphoneos-version-min is present, but this never happens 1396 // due to tool chain specific argument translation. 1397 1398 if (Args.hasArg(options::OPT_g_Flag) && 1399 !Args.hasArg(options::OPT_fno_eliminate_unused_debug_symbols)) 1400 CmdArgs.push_back("-feliminate-unused-debug-symbols"); 1401} 1402 1403void darwin::CC1::AddCC1OptionsArgs(const ArgList &Args, ArgStringList &CmdArgs, 1404 const InputInfoList &Inputs, 1405 const ArgStringList &OutputArgs) const { 1406 const Driver &D = getToolChain().getDriver(); 1407 1408 // Derived from cc1_options spec. 1409 if (Args.hasArg(options::OPT_fast) || 1410 Args.hasArg(options::OPT_fastf) || 1411 Args.hasArg(options::OPT_fastcp)) 1412 CmdArgs.push_back("-O3"); 1413 1414 if (Arg *A = Args.getLastArg(options::OPT_pg)) 1415 if (Args.hasArg(options::OPT_fomit_frame_pointer)) 1416 D.Diag(clang::diag::err_drv_argument_not_allowed_with) 1417 << A->getAsString(Args) << "-fomit-frame-pointer"; 1418 1419 AddCC1Args(Args, CmdArgs); 1420 1421 if (!Args.hasArg(options::OPT_Q)) 1422 CmdArgs.push_back("-quiet"); 1423 1424 CmdArgs.push_back("-dumpbase"); 1425 CmdArgs.push_back(darwin::CC1::getBaseInputName(Args, Inputs)); 1426 1427 Args.AddAllArgs(CmdArgs, options::OPT_d_Group); 1428 1429 Args.AddAllArgs(CmdArgs, options::OPT_m_Group); 1430 Args.AddAllArgs(CmdArgs, options::OPT_a_Group); 1431 1432 // FIXME: The goal is to use the user provided -o if that is our 1433 // final output, otherwise to drive from the original input 1434 // name. Find a clean way to go about this. 1435 if ((Args.hasArg(options::OPT_c) || Args.hasArg(options::OPT_S)) && 1436 Args.hasArg(options::OPT_o)) { 1437 Arg *OutputOpt = Args.getLastArg(options::OPT_o); 1438 CmdArgs.push_back("-auxbase-strip"); 1439 CmdArgs.push_back(OutputOpt->getValue(Args)); 1440 } else { 1441 CmdArgs.push_back("-auxbase"); 1442 CmdArgs.push_back(darwin::CC1::getBaseInputStem(Args, Inputs)); 1443 } 1444 1445 Args.AddAllArgs(CmdArgs, options::OPT_g_Group); 1446 1447 Args.AddAllArgs(CmdArgs, options::OPT_O); 1448 // FIXME: -Wall is getting some special treatment. Investigate. 1449 Args.AddAllArgs(CmdArgs, options::OPT_W_Group, options::OPT_pedantic_Group); 1450 Args.AddLastArg(CmdArgs, options::OPT_w); 1451 Args.AddAllArgs(CmdArgs, options::OPT_std_EQ, options::OPT_ansi, 1452 options::OPT_trigraphs); 1453 if (!Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) { 1454 // Honor -std-default. 1455 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ, 1456 "-std=", /*Joined=*/true); 1457 } 1458 1459 if (Args.hasArg(options::OPT_v)) 1460 CmdArgs.push_back("-version"); 1461 if (Args.hasArg(options::OPT_pg)) 1462 CmdArgs.push_back("-p"); 1463 Args.AddLastArg(CmdArgs, options::OPT_p); 1464 1465 // The driver treats -fsyntax-only specially. 1466 if (getToolChain().getTriple().getArch() == llvm::Triple::arm || 1467 getToolChain().getTriple().getArch() == llvm::Triple::thumb) { 1468 // Removes -fbuiltin-str{cat,cpy}; these aren't recognized by cc1 but are 1469 // used to inhibit the default -fno-builtin-str{cat,cpy}. 1470 // 1471 // FIXME: Should we grow a better way to deal with "removing" args? 1472 for (arg_iterator it = Args.filtered_begin(options::OPT_f_Group, 1473 options::OPT_fsyntax_only), 1474 ie = Args.filtered_end(); it != ie; ++it) { 1475 if (!it->getOption().matches(options::OPT_fbuiltin_strcat) && 1476 !it->getOption().matches(options::OPT_fbuiltin_strcpy)) { 1477 it->claim(); 1478 it->render(Args, CmdArgs); 1479 } 1480 } 1481 } else 1482 Args.AddAllArgs(CmdArgs, options::OPT_f_Group, options::OPT_fsyntax_only); 1483 1484 Args.AddAllArgs(CmdArgs, options::OPT_undef); 1485 if (Args.hasArg(options::OPT_Qn)) 1486 CmdArgs.push_back("-fno-ident"); 1487 1488 // FIXME: This isn't correct. 1489 //Args.AddLastArg(CmdArgs, options::OPT__help) 1490 //Args.AddLastArg(CmdArgs, options::OPT__targetHelp) 1491 1492 CmdArgs.append(OutputArgs.begin(), OutputArgs.end()); 1493 1494 // FIXME: Still don't get what is happening here. Investigate. 1495 Args.AddAllArgs(CmdArgs, options::OPT__param); 1496 1497 if (Args.hasArg(options::OPT_fmudflap) || 1498 Args.hasArg(options::OPT_fmudflapth)) { 1499 CmdArgs.push_back("-fno-builtin"); 1500 CmdArgs.push_back("-fno-merge-constants"); 1501 } 1502 1503 if (Args.hasArg(options::OPT_coverage)) { 1504 CmdArgs.push_back("-fprofile-arcs"); 1505 CmdArgs.push_back("-ftest-coverage"); 1506 } 1507 1508 if (types::isCXX(Inputs[0].getType())) 1509 CmdArgs.push_back("-D__private_extern__=extern"); 1510} 1511 1512void darwin::CC1::AddCPPOptionsArgs(const ArgList &Args, ArgStringList &CmdArgs, 1513 const InputInfoList &Inputs, 1514 const ArgStringList &OutputArgs) const { 1515 // Derived from cpp_options 1516 AddCPPUniqueOptionsArgs(Args, CmdArgs, Inputs); 1517 1518 CmdArgs.append(OutputArgs.begin(), OutputArgs.end()); 1519 1520 AddCC1Args(Args, CmdArgs); 1521 1522 // NOTE: The code below has some commonality with cpp_options, but 1523 // in classic gcc style ends up sending things in different 1524 // orders. This may be a good merge candidate once we drop pedantic 1525 // compatibility. 1526 1527 Args.AddAllArgs(CmdArgs, options::OPT_m_Group); 1528 Args.AddAllArgs(CmdArgs, options::OPT_std_EQ, options::OPT_ansi, 1529 options::OPT_trigraphs); 1530 if (!Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) { 1531 // Honor -std-default. 1532 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ, 1533 "-std=", /*Joined=*/true); 1534 } 1535 Args.AddAllArgs(CmdArgs, options::OPT_W_Group, options::OPT_pedantic_Group); 1536 Args.AddLastArg(CmdArgs, options::OPT_w); 1537 1538 // The driver treats -fsyntax-only specially. 1539 Args.AddAllArgs(CmdArgs, options::OPT_f_Group, options::OPT_fsyntax_only); 1540 1541 if (Args.hasArg(options::OPT_g_Group) && !Args.hasArg(options::OPT_g0) && 1542 !Args.hasArg(options::OPT_fno_working_directory)) 1543 CmdArgs.push_back("-fworking-directory"); 1544 1545 Args.AddAllArgs(CmdArgs, options::OPT_O); 1546 Args.AddAllArgs(CmdArgs, options::OPT_undef); 1547 if (Args.hasArg(options::OPT_save_temps)) 1548 CmdArgs.push_back("-fpch-preprocess"); 1549} 1550 1551void darwin::CC1::AddCPPUniqueOptionsArgs(const ArgList &Args, 1552 ArgStringList &CmdArgs, 1553 const InputInfoList &Inputs) const { 1554 const Driver &D = getToolChain().getDriver(); 1555 1556 CheckPreprocessingOptions(D, Args); 1557 1558 // Derived from cpp_unique_options. 1559 // -{C,CC} only with -E is checked in CheckPreprocessingOptions(). 1560 Args.AddLastArg(CmdArgs, options::OPT_C); 1561 Args.AddLastArg(CmdArgs, options::OPT_CC); 1562 if (!Args.hasArg(options::OPT_Q)) 1563 CmdArgs.push_back("-quiet"); 1564 Args.AddAllArgs(CmdArgs, options::OPT_nostdinc); 1565 Args.AddLastArg(CmdArgs, options::OPT_v); 1566 Args.AddAllArgs(CmdArgs, options::OPT_I_Group, options::OPT_F); 1567 Args.AddLastArg(CmdArgs, options::OPT_P); 1568 1569 // FIXME: Handle %I properly. 1570 if (getToolChain().getArchName() == "x86_64") { 1571 CmdArgs.push_back("-imultilib"); 1572 CmdArgs.push_back("x86_64"); 1573 } 1574 1575 if (Args.hasArg(options::OPT_MD)) { 1576 CmdArgs.push_back("-MD"); 1577 CmdArgs.push_back(darwin::CC1::getDependencyFileName(Args, Inputs)); 1578 } 1579 1580 if (Args.hasArg(options::OPT_MMD)) { 1581 CmdArgs.push_back("-MMD"); 1582 CmdArgs.push_back(darwin::CC1::getDependencyFileName(Args, Inputs)); 1583 } 1584 1585 Args.AddLastArg(CmdArgs, options::OPT_M); 1586 Args.AddLastArg(CmdArgs, options::OPT_MM); 1587 Args.AddAllArgs(CmdArgs, options::OPT_MF); 1588 Args.AddLastArg(CmdArgs, options::OPT_MG); 1589 Args.AddLastArg(CmdArgs, options::OPT_MP); 1590 Args.AddAllArgs(CmdArgs, options::OPT_MQ); 1591 Args.AddAllArgs(CmdArgs, options::OPT_MT); 1592 if (!Args.hasArg(options::OPT_M) && !Args.hasArg(options::OPT_MM) && 1593 (Args.hasArg(options::OPT_MD) || Args.hasArg(options::OPT_MMD))) { 1594 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) { 1595 CmdArgs.push_back("-MQ"); 1596 CmdArgs.push_back(OutputOpt->getValue(Args)); 1597 } 1598 } 1599 1600 Args.AddLastArg(CmdArgs, options::OPT_remap); 1601 if (Args.hasArg(options::OPT_g3)) 1602 CmdArgs.push_back("-dD"); 1603 Args.AddLastArg(CmdArgs, options::OPT_H); 1604 1605 AddCPPArgs(Args, CmdArgs); 1606 1607 Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U, options::OPT_A); 1608 Args.AddAllArgs(CmdArgs, options::OPT_i_Group); 1609 1610 for (InputInfoList::const_iterator 1611 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 1612 const InputInfo &II = *it; 1613 1614 if (II.isPipe()) 1615 CmdArgs.push_back("-"); 1616 else 1617 CmdArgs.push_back(II.getFilename()); 1618 } 1619 1620 Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA, 1621 options::OPT_Xpreprocessor); 1622 1623 if (Args.hasArg(options::OPT_fmudflap)) { 1624 CmdArgs.push_back("-D_MUDFLAP"); 1625 CmdArgs.push_back("-include"); 1626 CmdArgs.push_back("mf-runtime.h"); 1627 } 1628 1629 if (Args.hasArg(options::OPT_fmudflapth)) { 1630 CmdArgs.push_back("-D_MUDFLAP"); 1631 CmdArgs.push_back("-D_MUDFLAPTH"); 1632 CmdArgs.push_back("-include"); 1633 CmdArgs.push_back("mf-runtime.h"); 1634 } 1635} 1636 1637void darwin::CC1::AddCPPArgs(const ArgList &Args, 1638 ArgStringList &CmdArgs) const { 1639 // Derived from cpp spec. 1640 1641 if (Args.hasArg(options::OPT_static)) { 1642 // The gcc spec is broken here, it refers to dynamic but 1643 // that has been translated. Start by being bug compatible. 1644 1645 // if (!Args.hasArg(arglist.parser.dynamicOption)) 1646 CmdArgs.push_back("-D__STATIC__"); 1647 } else 1648 CmdArgs.push_back("-D__DYNAMIC__"); 1649 1650 if (Args.hasArg(options::OPT_pthread)) 1651 CmdArgs.push_back("-D_REENTRANT"); 1652} 1653 1654void darwin::Preprocess::ConstructJob(Compilation &C, const JobAction &JA, 1655 Job &Dest, const InputInfo &Output, 1656 const InputInfoList &Inputs, 1657 const ArgList &Args, 1658 const char *LinkingOutput) const { 1659 ArgStringList CmdArgs; 1660 1661 assert(Inputs.size() == 1 && "Unexpected number of inputs!"); 1662 1663 CmdArgs.push_back("-E"); 1664 1665 if (Args.hasArg(options::OPT_traditional) || 1666 Args.hasArg(options::OPT_traditional_cpp)) 1667 CmdArgs.push_back("-traditional-cpp"); 1668 1669 ArgStringList OutputArgs; 1670 if (Output.isFilename()) { 1671 OutputArgs.push_back("-o"); 1672 OutputArgs.push_back(Output.getFilename()); 1673 } else { 1674 assert(Output.isPipe() && "Unexpected CC1 output."); 1675 } 1676 1677 if (Args.hasArg(options::OPT_E)) { 1678 AddCPPOptionsArgs(Args, CmdArgs, Inputs, OutputArgs); 1679 } else { 1680 AddCPPOptionsArgs(Args, CmdArgs, Inputs, ArgStringList()); 1681 CmdArgs.append(OutputArgs.begin(), OutputArgs.end()); 1682 } 1683 1684 Args.AddAllArgs(CmdArgs, options::OPT_d_Group); 1685 1686 const char *CC1Name = getCC1Name(Inputs[0].getType()); 1687 const char *Exec = 1688 Args.MakeArgString(getToolChain().GetProgramPath(C, CC1Name)); 1689 Dest.addCommand(new Command(JA, *this, Exec, CmdArgs)); 1690} 1691 1692void darwin::Compile::ConstructJob(Compilation &C, const JobAction &JA, 1693 Job &Dest, const InputInfo &Output, 1694 const InputInfoList &Inputs, 1695 const ArgList &Args, 1696 const char *LinkingOutput) const { 1697 const Driver &D = getToolChain().getDriver(); 1698 ArgStringList CmdArgs; 1699 1700 assert(Inputs.size() == 1 && "Unexpected number of inputs!"); 1701 1702 types::ID InputType = Inputs[0].getType(); 1703 const Arg *A; 1704 if ((A = Args.getLastArg(options::OPT_traditional))) 1705 D.Diag(clang::diag::err_drv_argument_only_allowed_with) 1706 << A->getAsString(Args) << "-E"; 1707 1708 if (Output.getType() == types::TY_LLVMAsm) 1709 CmdArgs.push_back("-emit-llvm"); 1710 else if (Output.getType() == types::TY_LLVMBC) 1711 CmdArgs.push_back("-emit-llvm-bc"); 1712 else if (Output.getType() == types::TY_AST) 1713 D.Diag(clang::diag::err_drv_no_ast_support) 1714 << getToolChain().getTripleString(); 1715 1716 ArgStringList OutputArgs; 1717 if (Output.getType() != types::TY_PCH) { 1718 OutputArgs.push_back("-o"); 1719 if (Output.isPipe()) 1720 OutputArgs.push_back("-"); 1721 else if (Output.isNothing()) 1722 OutputArgs.push_back("/dev/null"); 1723 else 1724 OutputArgs.push_back(Output.getFilename()); 1725 } 1726 1727 // There is no need for this level of compatibility, but it makes 1728 // diffing easier. 1729 bool OutputArgsEarly = (Args.hasArg(options::OPT_fsyntax_only) || 1730 Args.hasArg(options::OPT_S)); 1731 1732 if (types::getPreprocessedType(InputType) != types::TY_INVALID) { 1733 AddCPPUniqueOptionsArgs(Args, CmdArgs, Inputs); 1734 if (OutputArgsEarly) { 1735 AddCC1OptionsArgs(Args, CmdArgs, Inputs, OutputArgs); 1736 } else { 1737 AddCC1OptionsArgs(Args, CmdArgs, Inputs, ArgStringList()); 1738 CmdArgs.append(OutputArgs.begin(), OutputArgs.end()); 1739 } 1740 } else { 1741 CmdArgs.push_back("-fpreprocessed"); 1742 1743 for (InputInfoList::const_iterator 1744 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 1745 const InputInfo &II = *it; 1746 1747 // Reject AST inputs. 1748 if (II.getType() == types::TY_AST) { 1749 D.Diag(clang::diag::err_drv_no_ast_support) 1750 << getToolChain().getTripleString(); 1751 return; 1752 } 1753 1754 if (II.isPipe()) 1755 CmdArgs.push_back("-"); 1756 else 1757 CmdArgs.push_back(II.getFilename()); 1758 } 1759 1760 if (OutputArgsEarly) { 1761 AddCC1OptionsArgs(Args, CmdArgs, Inputs, OutputArgs); 1762 } else { 1763 AddCC1OptionsArgs(Args, CmdArgs, Inputs, ArgStringList()); 1764 CmdArgs.append(OutputArgs.begin(), OutputArgs.end()); 1765 } 1766 } 1767 1768 if (Output.getType() == types::TY_PCH) { 1769 assert(Output.isFilename() && "Invalid PCH output."); 1770 1771 CmdArgs.push_back("-o"); 1772 // NOTE: gcc uses a temp .s file for this, but there doesn't seem 1773 // to be a good reason. 1774 CmdArgs.push_back("/dev/null"); 1775 1776 CmdArgs.push_back("--output-pch="); 1777 CmdArgs.push_back(Output.getFilename()); 1778 } 1779 1780 const char *CC1Name = getCC1Name(Inputs[0].getType()); 1781 const char *Exec = 1782 Args.MakeArgString(getToolChain().GetProgramPath(C, CC1Name)); 1783 Dest.addCommand(new Command(JA, *this, Exec, CmdArgs)); 1784} 1785 1786void darwin::Assemble::ConstructJob(Compilation &C, const JobAction &JA, 1787 Job &Dest, const InputInfo &Output, 1788 const InputInfoList &Inputs, 1789 const ArgList &Args, 1790 const char *LinkingOutput) const { 1791 ArgStringList CmdArgs; 1792 1793 assert(Inputs.size() == 1 && "Unexpected number of inputs."); 1794 const InputInfo &Input = Inputs[0]; 1795 1796 // Bit of a hack, this is only used for original inputs. 1797 // 1798 // FIXME: This is broken for preprocessed .s inputs. 1799 if (Input.isFilename() && 1800 strcmp(Input.getFilename(), Input.getBaseInput()) == 0) { 1801 if (Args.hasArg(options::OPT_gstabs)) 1802 CmdArgs.push_back("--gstabs"); 1803 else if (Args.hasArg(options::OPT_g_Group)) 1804 CmdArgs.push_back("--gdwarf2"); 1805 } 1806 1807 // Derived from asm spec. 1808 AddDarwinArch(Args, CmdArgs); 1809 1810 if (!getDarwinToolChain().isTargetIPhoneOS() || 1811 Args.hasArg(options::OPT_force__cpusubtype__ALL)) 1812 CmdArgs.push_back("-force_cpusubtype_ALL"); 1813 1814 if (getToolChain().getTriple().getArch() != llvm::Triple::x86_64 && 1815 (Args.hasArg(options::OPT_mkernel) || 1816 Args.hasArg(options::OPT_static) || 1817 Args.hasArg(options::OPT_fapple_kext))) 1818 CmdArgs.push_back("-static"); 1819 1820 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, 1821 options::OPT_Xassembler); 1822 1823 assert(Output.isFilename() && "Unexpected lipo output."); 1824 CmdArgs.push_back("-o"); 1825 CmdArgs.push_back(Output.getFilename()); 1826 1827 if (Input.isPipe()) { 1828 CmdArgs.push_back("-"); 1829 } else { 1830 assert(Input.isFilename() && "Invalid input."); 1831 CmdArgs.push_back(Input.getFilename()); 1832 } 1833 1834 // asm_final spec is empty. 1835 1836 const char *Exec = 1837 Args.MakeArgString(getToolChain().GetProgramPath(C, "as")); 1838 Dest.addCommand(new Command(JA, *this, Exec, CmdArgs)); 1839} 1840 1841/// Helper routine for seeing if we should use dsymutil; this is a 1842/// gcc compatible hack, we should remove it and use the input 1843/// type information. 1844static bool isSourceSuffix(const char *Str) { 1845 // match: 'C', 'CPP', 'c', 'cc', 'cp', 'c++', 'cpp', 'cxx', 'm', 1846 // 'mm'. 1847 return llvm::StringSwitch<bool>(Str) 1848 .Case("C", true) 1849 .Case("c", true) 1850 .Case("m", true) 1851 .Case("cc", true) 1852 .Case("cp", true) 1853 .Case("mm", true) 1854 .Case("CPP", true) 1855 .Case("c++", true) 1856 .Case("cpp", true) 1857 .Case("cxx", true) 1858 .Default(false); 1859} 1860 1861void darwin::DarwinTool::AddDarwinArch(const ArgList &Args, 1862 ArgStringList &CmdArgs) const { 1863 llvm::StringRef ArchName = getDarwinToolChain().getDarwinArchName(Args); 1864 1865 // Derived from darwin_arch spec. 1866 CmdArgs.push_back("-arch"); 1867 CmdArgs.push_back(Args.MakeArgString(ArchName)); 1868 1869 // FIXME: Is this needed anymore? 1870 if (ArchName == "arm") 1871 CmdArgs.push_back("-force_cpusubtype_ALL"); 1872} 1873 1874void darwin::Link::AddLinkArgs(const ArgList &Args, 1875 ArgStringList &CmdArgs) const { 1876 const Driver &D = getToolChain().getDriver(); 1877 1878 // Derived from the "link" spec. 1879 Args.AddAllArgs(CmdArgs, options::OPT_static); 1880 if (!Args.hasArg(options::OPT_static)) 1881 CmdArgs.push_back("-dynamic"); 1882 if (Args.hasArg(options::OPT_fgnu_runtime)) { 1883 // FIXME: gcc replaces -lobjc in forward args with -lobjc-gnu 1884 // here. How do we wish to handle such things? 1885 } 1886 1887 if (!Args.hasArg(options::OPT_dynamiclib)) { 1888 AddDarwinArch(Args, CmdArgs); 1889 // FIXME: Why do this only on this path? 1890 Args.AddLastArg(CmdArgs, options::OPT_force__cpusubtype__ALL); 1891 1892 Args.AddLastArg(CmdArgs, options::OPT_bundle); 1893 Args.AddAllArgs(CmdArgs, options::OPT_bundle__loader); 1894 Args.AddAllArgs(CmdArgs, options::OPT_client__name); 1895 1896 Arg *A; 1897 if ((A = Args.getLastArg(options::OPT_compatibility__version)) || 1898 (A = Args.getLastArg(options::OPT_current__version)) || 1899 (A = Args.getLastArg(options::OPT_install__name))) 1900 D.Diag(clang::diag::err_drv_argument_only_allowed_with) 1901 << A->getAsString(Args) << "-dynamiclib"; 1902 1903 Args.AddLastArg(CmdArgs, options::OPT_force__flat__namespace); 1904 Args.AddLastArg(CmdArgs, options::OPT_keep__private__externs); 1905 Args.AddLastArg(CmdArgs, options::OPT_private__bundle); 1906 } else { 1907 CmdArgs.push_back("-dylib"); 1908 1909 Arg *A; 1910 if ((A = Args.getLastArg(options::OPT_bundle)) || 1911 (A = Args.getLastArg(options::OPT_bundle__loader)) || 1912 (A = Args.getLastArg(options::OPT_client__name)) || 1913 (A = Args.getLastArg(options::OPT_force__flat__namespace)) || 1914 (A = Args.getLastArg(options::OPT_keep__private__externs)) || 1915 (A = Args.getLastArg(options::OPT_private__bundle))) 1916 D.Diag(clang::diag::err_drv_argument_not_allowed_with) 1917 << A->getAsString(Args) << "-dynamiclib"; 1918 1919 Args.AddAllArgsTranslated(CmdArgs, options::OPT_compatibility__version, 1920 "-dylib_compatibility_version"); 1921 Args.AddAllArgsTranslated(CmdArgs, options::OPT_current__version, 1922 "-dylib_current_version"); 1923 1924 AddDarwinArch(Args, CmdArgs); 1925 1926 Args.AddAllArgsTranslated(CmdArgs, options::OPT_install__name, 1927 "-dylib_install_name"); 1928 } 1929 1930 Args.AddLastArg(CmdArgs, options::OPT_all__load); 1931 Args.AddAllArgs(CmdArgs, options::OPT_allowable__client); 1932 Args.AddLastArg(CmdArgs, options::OPT_bind__at__load); 1933 if (getDarwinToolChain().isTargetIPhoneOS()) 1934 Args.AddLastArg(CmdArgs, options::OPT_arch__errors__fatal); 1935 Args.AddLastArg(CmdArgs, options::OPT_dead__strip); 1936 Args.AddLastArg(CmdArgs, options::OPT_no__dead__strip__inits__and__terms); 1937 Args.AddAllArgs(CmdArgs, options::OPT_dylib__file); 1938 Args.AddLastArg(CmdArgs, options::OPT_dynamic); 1939 Args.AddAllArgs(CmdArgs, options::OPT_exported__symbols__list); 1940 Args.AddLastArg(CmdArgs, options::OPT_flat__namespace); 1941 Args.AddAllArgs(CmdArgs, options::OPT_headerpad__max__install__names); 1942 Args.AddAllArgs(CmdArgs, options::OPT_image__base); 1943 Args.AddAllArgs(CmdArgs, options::OPT_init); 1944 1945 // Adding all arguments doesn't make sense here but this is what gcc does. One 1946 // of this should always be present thanks to argument translation. 1947 assert((Args.hasArg(options::OPT_mmacosx_version_min_EQ) || 1948 Args.hasArg(options::OPT_miphoneos_version_min_EQ)) && 1949 "Missing version argument (lost in translation)?"); 1950 Args.AddAllArgsTranslated(CmdArgs, options::OPT_mmacosx_version_min_EQ, 1951 "-macosx_version_min"); 1952 Args.AddAllArgsTranslated(CmdArgs, options::OPT_miphoneos_version_min_EQ, 1953 "-iphoneos_version_min"); 1954 Args.AddLastArg(CmdArgs, options::OPT_nomultidefs); 1955 Args.AddLastArg(CmdArgs, options::OPT_multi__module); 1956 Args.AddLastArg(CmdArgs, options::OPT_single__module); 1957 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined); 1958 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined__unused); 1959 1960 if (Args.hasArg(options::OPT_fpie)) 1961 CmdArgs.push_back("-pie"); 1962 1963 Args.AddLastArg(CmdArgs, options::OPT_prebind); 1964 Args.AddLastArg(CmdArgs, options::OPT_noprebind); 1965 Args.AddLastArg(CmdArgs, options::OPT_nofixprebinding); 1966 Args.AddLastArg(CmdArgs, options::OPT_prebind__all__twolevel__modules); 1967 Args.AddLastArg(CmdArgs, options::OPT_read__only__relocs); 1968 Args.AddAllArgs(CmdArgs, options::OPT_sectcreate); 1969 Args.AddAllArgs(CmdArgs, options::OPT_sectorder); 1970 Args.AddAllArgs(CmdArgs, options::OPT_seg1addr); 1971 Args.AddAllArgs(CmdArgs, options::OPT_segprot); 1972 Args.AddAllArgs(CmdArgs, options::OPT_segaddr); 1973 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__only__addr); 1974 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__write__addr); 1975 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table); 1976 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table__filename); 1977 Args.AddAllArgs(CmdArgs, options::OPT_sub__library); 1978 Args.AddAllArgs(CmdArgs, options::OPT_sub__umbrella); 1979 1980 Args.AddAllArgsTranslated(CmdArgs, options::OPT_isysroot, "-syslibroot"); 1981 if (getDarwinToolChain().isTargetIPhoneOS()) { 1982 if (!Args.hasArg(options::OPT_isysroot)) { 1983 CmdArgs.push_back("-syslibroot"); 1984 CmdArgs.push_back("/Developer/SDKs/Extra"); 1985 } 1986 } 1987 1988 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace); 1989 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace__hints); 1990 Args.AddAllArgs(CmdArgs, options::OPT_umbrella); 1991 Args.AddAllArgs(CmdArgs, options::OPT_undefined); 1992 Args.AddAllArgs(CmdArgs, options::OPT_unexported__symbols__list); 1993 Args.AddAllArgs(CmdArgs, options::OPT_weak__reference__mismatches); 1994 Args.AddLastArg(CmdArgs, options::OPT_X_Flag); 1995 Args.AddAllArgs(CmdArgs, options::OPT_y); 1996 Args.AddLastArg(CmdArgs, options::OPT_w); 1997 Args.AddAllArgs(CmdArgs, options::OPT_pagezero__size); 1998 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__); 1999 Args.AddLastArg(CmdArgs, options::OPT_seglinkedit); 2000 Args.AddLastArg(CmdArgs, options::OPT_noseglinkedit); 2001 Args.AddAllArgs(CmdArgs, options::OPT_sectalign); 2002 Args.AddAllArgs(CmdArgs, options::OPT_sectobjectsymbols); 2003 Args.AddAllArgs(CmdArgs, options::OPT_segcreate); 2004 Args.AddLastArg(CmdArgs, options::OPT_whyload); 2005 Args.AddLastArg(CmdArgs, options::OPT_whatsloaded); 2006 Args.AddAllArgs(CmdArgs, options::OPT_dylinker__install__name); 2007 Args.AddLastArg(CmdArgs, options::OPT_dylinker); 2008 Args.AddLastArg(CmdArgs, options::OPT_Mach); 2009} 2010 2011void darwin::Link::ConstructJob(Compilation &C, const JobAction &JA, 2012 Job &Dest, const InputInfo &Output, 2013 const InputInfoList &Inputs, 2014 const ArgList &Args, 2015 const char *LinkingOutput) const { 2016 assert(Output.getType() == types::TY_Image && "Invalid linker output type."); 2017 2018 // The logic here is derived from gcc's behavior; most of which 2019 // comes from specs (starting with link_command). Consult gcc for 2020 // more information. 2021 ArgStringList CmdArgs; 2022 2023 // I'm not sure why this particular decomposition exists in gcc, but 2024 // we follow suite for ease of comparison. 2025 AddLinkArgs(Args, CmdArgs); 2026 2027 Args.AddAllArgs(CmdArgs, options::OPT_d_Flag); 2028 Args.AddAllArgs(CmdArgs, options::OPT_s); 2029 Args.AddAllArgs(CmdArgs, options::OPT_t); 2030 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag); 2031 Args.AddAllArgs(CmdArgs, options::OPT_u_Group); 2032 Args.AddAllArgs(CmdArgs, options::OPT_A); 2033 Args.AddLastArg(CmdArgs, options::OPT_e); 2034 Args.AddAllArgs(CmdArgs, options::OPT_m_Separate); 2035 Args.AddAllArgs(CmdArgs, options::OPT_r); 2036 2037 CmdArgs.push_back("-o"); 2038 CmdArgs.push_back(Output.getFilename()); 2039 2040 if (!Args.hasArg(options::OPT_A) && 2041 !Args.hasArg(options::OPT_nostdlib) && 2042 !Args.hasArg(options::OPT_nostartfiles)) { 2043 // Derived from startfile spec. 2044 if (Args.hasArg(options::OPT_dynamiclib)) { 2045 // Derived from darwin_dylib1 spec. 2046 if (getDarwinToolChain().isTargetIPhoneOS()) { 2047 if (getDarwinToolChain().isIPhoneOSVersionLT(3, 1)) 2048 CmdArgs.push_back("-ldylib1.o"); 2049 } else { 2050 if (getDarwinToolChain().isMacosxVersionLT(10, 5)) 2051 CmdArgs.push_back("-ldylib1.o"); 2052 else if (getDarwinToolChain().isMacosxVersionLT(10, 6)) 2053 CmdArgs.push_back("-ldylib1.10.5.o"); 2054 } 2055 } else { 2056 if (Args.hasArg(options::OPT_bundle)) { 2057 if (!Args.hasArg(options::OPT_static)) { 2058 // Derived from darwin_bundle1 spec. 2059 if (getDarwinToolChain().isTargetIPhoneOS()) { 2060 if (getDarwinToolChain().isIPhoneOSVersionLT(3, 1)) 2061 CmdArgs.push_back("-lbundle1.o"); 2062 } else { 2063 if (getDarwinToolChain().isMacosxVersionLT(10, 6)) 2064 CmdArgs.push_back("-lbundle1.o"); 2065 } 2066 } 2067 } else { 2068 if (Args.hasArg(options::OPT_pg)) { 2069 if (Args.hasArg(options::OPT_static) || 2070 Args.hasArg(options::OPT_object) || 2071 Args.hasArg(options::OPT_preload)) { 2072 CmdArgs.push_back("-lgcrt0.o"); 2073 } else { 2074 CmdArgs.push_back("-lgcrt1.o"); 2075 2076 // darwin_crt2 spec is empty. 2077 } 2078 } else { 2079 if (Args.hasArg(options::OPT_static) || 2080 Args.hasArg(options::OPT_object) || 2081 Args.hasArg(options::OPT_preload)) { 2082 CmdArgs.push_back("-lcrt0.o"); 2083 } else { 2084 // Derived from darwin_crt1 spec. 2085 if (getDarwinToolChain().isTargetIPhoneOS()) { 2086 if (getDarwinToolChain().isIPhoneOSVersionLT(3, 1)) 2087 CmdArgs.push_back("-lcrt1.o"); 2088 else 2089 CmdArgs.push_back("-lcrt1.3.1.o"); 2090 } else { 2091 if (getDarwinToolChain().isMacosxVersionLT(10, 5)) 2092 CmdArgs.push_back("-lcrt1.o"); 2093 else if (getDarwinToolChain().isMacosxVersionLT(10, 6)) 2094 CmdArgs.push_back("-lcrt1.10.5.o"); 2095 else 2096 CmdArgs.push_back("-lcrt1.10.6.o"); 2097 2098 // darwin_crt2 spec is empty. 2099 } 2100 } 2101 } 2102 } 2103 } 2104 2105 if (!getDarwinToolChain().isTargetIPhoneOS() && 2106 Args.hasArg(options::OPT_shared_libgcc) && 2107 getDarwinToolChain().isMacosxVersionLT(10, 5)) { 2108 const char *Str = 2109 Args.MakeArgString(getToolChain().GetFilePath(C, "crt3.o")); 2110 CmdArgs.push_back(Str); 2111 } 2112 } 2113 2114 Args.AddAllArgs(CmdArgs, options::OPT_L); 2115 2116 if (Args.hasArg(options::OPT_fopenmp)) 2117 // This is more complicated in gcc... 2118 CmdArgs.push_back("-lgomp"); 2119 2120 getDarwinToolChain().AddLinkSearchPathArgs(Args, CmdArgs); 2121 2122 for (InputInfoList::const_iterator 2123 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 2124 const InputInfo &II = *it; 2125 if (II.isFilename()) 2126 CmdArgs.push_back(II.getFilename()); 2127 else 2128 II.getInputArg().renderAsInput(Args, CmdArgs); 2129 } 2130 2131 if (LinkingOutput) { 2132 CmdArgs.push_back("-arch_multiple"); 2133 CmdArgs.push_back("-final_output"); 2134 CmdArgs.push_back(LinkingOutput); 2135 } 2136 2137 if (Args.hasArg(options::OPT_fprofile_arcs) || 2138 Args.hasArg(options::OPT_fprofile_generate) || 2139 Args.hasArg(options::OPT_fcreate_profile) || 2140 Args.hasArg(options::OPT_coverage)) 2141 CmdArgs.push_back("-lgcov"); 2142 2143 if (Args.hasArg(options::OPT_fnested_functions)) 2144 CmdArgs.push_back("-allow_stack_execute"); 2145 2146 if (!Args.hasArg(options::OPT_nostdlib) && 2147 !Args.hasArg(options::OPT_nodefaultlibs)) { 2148 // FIXME: g++ is more complicated here, it tries to put -lstdc++ 2149 // before -lm, for example. 2150 if (getToolChain().getDriver().CCCIsCXX) 2151 CmdArgs.push_back("-lstdc++"); 2152 2153 // link_ssp spec is empty. 2154 2155 // Let the tool chain choose which runtime library to link. 2156 getDarwinToolChain().AddLinkRuntimeLibArgs(Args, CmdArgs); 2157 } 2158 2159 if (!Args.hasArg(options::OPT_A) && 2160 !Args.hasArg(options::OPT_nostdlib) && 2161 !Args.hasArg(options::OPT_nostartfiles)) { 2162 // endfile_spec is empty. 2163 } 2164 2165 Args.AddAllArgs(CmdArgs, options::OPT_T_Group); 2166 Args.AddAllArgs(CmdArgs, options::OPT_F); 2167 2168 const char *Exec = 2169 Args.MakeArgString(getToolChain().GetProgramPath(C, "ld")); 2170 Dest.addCommand(new Command(JA, *this, Exec, CmdArgs)); 2171 2172 // Find the first non-empty base input (we want to ignore linker 2173 // inputs). 2174 const char *BaseInput = ""; 2175 for (unsigned i = 0, e = Inputs.size(); i != e; ++i) { 2176 if (Inputs[i].getBaseInput()[0] != '\0') { 2177 BaseInput = Inputs[i].getBaseInput(); 2178 break; 2179 } 2180 } 2181 2182 // Run dsymutil if we are making an executable in a single step. 2183 // 2184 // FIXME: Currently we don't want to do this when we are part of a 2185 // universal build step, as this would end up creating stray temp 2186 // files. 2187 if (!LinkingOutput && 2188 Args.getLastArg(options::OPT_g_Group) && 2189 !Args.getLastArg(options::OPT_gstabs) && 2190 !Args.getLastArg(options::OPT_g0)) { 2191 // FIXME: This is gross, but matches gcc. The test only considers 2192 // the suffix (not the -x type), and then only of the first 2193 // source input. Awesome. 2194 const char *Suffix = strrchr(BaseInput, '.'); 2195 if (Suffix && isSourceSuffix(Suffix + 1)) { 2196 const char *Exec = 2197 Args.MakeArgString(getToolChain().GetProgramPath(C, "dsymutil")); 2198 ArgStringList CmdArgs; 2199 CmdArgs.push_back(Output.getFilename()); 2200 C.getJobs().addCommand(new Command(JA, *this, Exec, CmdArgs)); 2201 } 2202 } 2203} 2204 2205void darwin::Lipo::ConstructJob(Compilation &C, const JobAction &JA, 2206 Job &Dest, const InputInfo &Output, 2207 const InputInfoList &Inputs, 2208 const ArgList &Args, 2209 const char *LinkingOutput) const { 2210 ArgStringList CmdArgs; 2211 2212 CmdArgs.push_back("-create"); 2213 assert(Output.isFilename() && "Unexpected lipo output."); 2214 2215 CmdArgs.push_back("-output"); 2216 CmdArgs.push_back(Output.getFilename()); 2217 2218 for (InputInfoList::const_iterator 2219 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 2220 const InputInfo &II = *it; 2221 assert(II.isFilename() && "Unexpected lipo input."); 2222 CmdArgs.push_back(II.getFilename()); 2223 } 2224 const char *Exec = 2225 Args.MakeArgString(getToolChain().GetProgramPath(C, "lipo")); 2226 Dest.addCommand(new Command(JA, *this, Exec, CmdArgs)); 2227} 2228 2229void auroraux::Assemble::ConstructJob(Compilation &C, const JobAction &JA, 2230 Job &Dest, const InputInfo &Output, 2231 const InputInfoList &Inputs, 2232 const ArgList &Args, 2233 const char *LinkingOutput) const { 2234 ArgStringList CmdArgs; 2235 2236 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, 2237 options::OPT_Xassembler); 2238 2239 CmdArgs.push_back("-o"); 2240 if (Output.isPipe()) 2241 CmdArgs.push_back("-"); 2242 else 2243 CmdArgs.push_back(Output.getFilename()); 2244 2245 for (InputInfoList::const_iterator 2246 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 2247 const InputInfo &II = *it; 2248 if (II.isPipe()) 2249 CmdArgs.push_back("-"); 2250 else 2251 CmdArgs.push_back(II.getFilename()); 2252 } 2253 2254 const char *Exec = 2255 Args.MakeArgString(getToolChain().GetProgramPath(C, "gas")); 2256 Dest.addCommand(new Command(JA, *this, Exec, CmdArgs)); 2257} 2258 2259void auroraux::Link::ConstructJob(Compilation &C, const JobAction &JA, 2260 Job &Dest, const InputInfo &Output, 2261 const InputInfoList &Inputs, 2262 const ArgList &Args, 2263 const char *LinkingOutput) const { 2264 const Driver &D = getToolChain().getDriver(); 2265 ArgStringList CmdArgs; 2266 2267 if ((!Args.hasArg(options::OPT_nostdlib)) && 2268 (!Args.hasArg(options::OPT_shared))) { 2269 CmdArgs.push_back("-e"); 2270 CmdArgs.push_back("_start"); 2271 } 2272 2273 if (Args.hasArg(options::OPT_static)) { 2274 CmdArgs.push_back("-Bstatic"); 2275 CmdArgs.push_back("-dn"); 2276 } else { 2277// CmdArgs.push_back("--eh-frame-hdr"); 2278 CmdArgs.push_back("-Bdynamic"); 2279 if (Args.hasArg(options::OPT_shared)) { 2280 CmdArgs.push_back("-shared"); 2281 } else { 2282 CmdArgs.push_back("--dynamic-linker"); 2283 CmdArgs.push_back("/lib/ld.so.1"); // 64Bit Path /lib/amd64/ld.so.1 2284 } 2285 } 2286 2287 if (Output.isPipe()) { 2288 CmdArgs.push_back("-o"); 2289 CmdArgs.push_back("-"); 2290 } else if (Output.isFilename()) { 2291 CmdArgs.push_back("-o"); 2292 CmdArgs.push_back(Output.getFilename()); 2293 } else { 2294 assert(Output.isNothing() && "Invalid output."); 2295 } 2296 2297 if (!Args.hasArg(options::OPT_nostdlib) && 2298 !Args.hasArg(options::OPT_nostartfiles)) { 2299 if (!Args.hasArg(options::OPT_shared)) { 2300 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crt1.o"))); 2301 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crti.o"))); 2302 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crtbegin.o"))); 2303 } else { 2304 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crti.o"))); 2305 } 2306 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crtn.o"))); 2307 } 2308 2309 CmdArgs.push_back(Args.MakeArgString("-L/opt/gcc4/lib/gcc/" 2310 + getToolChain().getTripleString() 2311 + "/4.2.4")); 2312 2313 Args.AddAllArgs(CmdArgs, options::OPT_L); 2314 Args.AddAllArgs(CmdArgs, options::OPT_T_Group); 2315 Args.AddAllArgs(CmdArgs, options::OPT_e); 2316 2317 for (InputInfoList::const_iterator 2318 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 2319 const InputInfo &II = *it; 2320 2321 // Don't try to pass LLVM inputs to a generic gcc. 2322 if (II.getType() == types::TY_LLVMBC) 2323 D.Diag(clang::diag::err_drv_no_linker_llvm_support) 2324 << getToolChain().getTripleString(); 2325 2326 if (II.isPipe()) 2327 CmdArgs.push_back("-"); 2328 else if (II.isFilename()) 2329 CmdArgs.push_back(II.getFilename()); 2330 else 2331 II.getInputArg().renderAsInput(Args, CmdArgs); 2332 } 2333 2334 if (!Args.hasArg(options::OPT_nostdlib) && 2335 !Args.hasArg(options::OPT_nodefaultlibs)) { 2336 // FIXME: For some reason GCC passes -lgcc before adding 2337 // the default system libraries. Just mimic this for now. 2338 CmdArgs.push_back("-lgcc"); 2339 2340 if (Args.hasArg(options::OPT_pthread)) 2341 CmdArgs.push_back("-pthread"); 2342 if (!Args.hasArg(options::OPT_shared)) 2343 CmdArgs.push_back("-lc"); 2344 CmdArgs.push_back("-lgcc"); 2345 } 2346 2347 if (!Args.hasArg(options::OPT_nostdlib) && 2348 !Args.hasArg(options::OPT_nostartfiles)) { 2349 if (!Args.hasArg(options::OPT_shared)) 2350 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crtend.o"))); 2351// else 2352// CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crtendS.o"))); 2353 } 2354 2355 const char *Exec = 2356 Args.MakeArgString(getToolChain().GetProgramPath(C, "ld")); 2357 Dest.addCommand(new Command(JA, *this, Exec, CmdArgs)); 2358} 2359 2360void openbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA, 2361 Job &Dest, const InputInfo &Output, 2362 const InputInfoList &Inputs, 2363 const ArgList &Args, 2364 const char *LinkingOutput) const { 2365 ArgStringList CmdArgs; 2366 2367 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, 2368 options::OPT_Xassembler); 2369 2370 CmdArgs.push_back("-o"); 2371 if (Output.isPipe()) 2372 CmdArgs.push_back("-"); 2373 else 2374 CmdArgs.push_back(Output.getFilename()); 2375 2376 for (InputInfoList::const_iterator 2377 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 2378 const InputInfo &II = *it; 2379 if (II.isPipe()) 2380 CmdArgs.push_back("-"); 2381 else 2382 CmdArgs.push_back(II.getFilename()); 2383 } 2384 2385 const char *Exec = 2386 Args.MakeArgString(getToolChain().GetProgramPath(C, "as")); 2387 Dest.addCommand(new Command(JA, *this, Exec, CmdArgs)); 2388} 2389 2390void openbsd::Link::ConstructJob(Compilation &C, const JobAction &JA, 2391 Job &Dest, const InputInfo &Output, 2392 const InputInfoList &Inputs, 2393 const ArgList &Args, 2394 const char *LinkingOutput) const { 2395 const Driver &D = getToolChain().getDriver(); 2396 ArgStringList CmdArgs; 2397 2398 if ((!Args.hasArg(options::OPT_nostdlib)) && 2399 (!Args.hasArg(options::OPT_shared))) { 2400 CmdArgs.push_back("-e"); 2401 CmdArgs.push_back("__start"); 2402 } 2403 2404 if (Args.hasArg(options::OPT_static)) { 2405 CmdArgs.push_back("-Bstatic"); 2406 } else { 2407 CmdArgs.push_back("--eh-frame-hdr"); 2408 CmdArgs.push_back("-Bdynamic"); 2409 if (Args.hasArg(options::OPT_shared)) { 2410 CmdArgs.push_back("-shared"); 2411 } else { 2412 CmdArgs.push_back("-dynamic-linker"); 2413 CmdArgs.push_back("/usr/libexec/ld.so"); 2414 } 2415 } 2416 2417 if (Output.isPipe()) { 2418 CmdArgs.push_back("-o"); 2419 CmdArgs.push_back("-"); 2420 } else if (Output.isFilename()) { 2421 CmdArgs.push_back("-o"); 2422 CmdArgs.push_back(Output.getFilename()); 2423 } else { 2424 assert(Output.isNothing() && "Invalid output."); 2425 } 2426 2427 if (!Args.hasArg(options::OPT_nostdlib) && 2428 !Args.hasArg(options::OPT_nostartfiles)) { 2429 if (!Args.hasArg(options::OPT_shared)) { 2430 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crt0.o"))); 2431 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crtbegin.o"))); 2432 } else { 2433 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crtbeginS.o"))); 2434 } 2435 } 2436 2437 std::string Triple = getToolChain().getTripleString(); 2438 if (Triple.substr(0, 6) == "x86_64") 2439 Triple.replace(0, 6, "amd64"); 2440 CmdArgs.push_back(Args.MakeArgString("-L/usr/lib/gcc-lib/" + Triple + 2441 "/3.3.5")); 2442 2443 Args.AddAllArgs(CmdArgs, options::OPT_L); 2444 Args.AddAllArgs(CmdArgs, options::OPT_T_Group); 2445 Args.AddAllArgs(CmdArgs, options::OPT_e); 2446 2447 for (InputInfoList::const_iterator 2448 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 2449 const InputInfo &II = *it; 2450 2451 // Don't try to pass LLVM inputs to a generic gcc. 2452 if (II.getType() == types::TY_LLVMBC) 2453 D.Diag(clang::diag::err_drv_no_linker_llvm_support) 2454 << getToolChain().getTripleString(); 2455 2456 if (II.isPipe()) 2457 CmdArgs.push_back("-"); 2458 else if (II.isFilename()) 2459 CmdArgs.push_back(II.getFilename()); 2460 else 2461 II.getInputArg().renderAsInput(Args, CmdArgs); 2462 } 2463 2464 if (!Args.hasArg(options::OPT_nostdlib) && 2465 !Args.hasArg(options::OPT_nodefaultlibs)) { 2466 // FIXME: For some reason GCC passes -lgcc before adding 2467 // the default system libraries. Just mimic this for now. 2468 CmdArgs.push_back("-lgcc"); 2469 2470 if (Args.hasArg(options::OPT_pthread)) 2471 CmdArgs.push_back("-pthread"); 2472 if (!Args.hasArg(options::OPT_shared)) 2473 CmdArgs.push_back("-lc"); 2474 CmdArgs.push_back("-lgcc"); 2475 } 2476 2477 if (!Args.hasArg(options::OPT_nostdlib) && 2478 !Args.hasArg(options::OPT_nostartfiles)) { 2479 if (!Args.hasArg(options::OPT_shared)) 2480 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crtend.o"))); 2481 else 2482 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crtendS.o"))); 2483 } 2484 2485 const char *Exec = 2486 Args.MakeArgString(getToolChain().GetProgramPath(C, "ld")); 2487 Dest.addCommand(new Command(JA, *this, Exec, CmdArgs)); 2488} 2489 2490void freebsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA, 2491 Job &Dest, const InputInfo &Output, 2492 const InputInfoList &Inputs, 2493 const ArgList &Args, 2494 const char *LinkingOutput) const { 2495 ArgStringList CmdArgs; 2496 2497 // When building 32-bit code on FreeBSD/amd64, we have to explicitly 2498 // instruct as in the base system to assemble 32-bit code. 2499 if (getToolChain().getArchName() == "i386") 2500 CmdArgs.push_back("--32"); 2501 2502 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, 2503 options::OPT_Xassembler); 2504 2505 CmdArgs.push_back("-o"); 2506 if (Output.isPipe()) 2507 CmdArgs.push_back("-"); 2508 else 2509 CmdArgs.push_back(Output.getFilename()); 2510 2511 for (InputInfoList::const_iterator 2512 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 2513 const InputInfo &II = *it; 2514 if (II.isPipe()) 2515 CmdArgs.push_back("-"); 2516 else 2517 CmdArgs.push_back(II.getFilename()); 2518 } 2519 2520 const char *Exec = 2521 Args.MakeArgString(getToolChain().GetProgramPath(C, "as")); 2522 Dest.addCommand(new Command(JA, *this, Exec, CmdArgs)); 2523} 2524 2525void freebsd::Link::ConstructJob(Compilation &C, const JobAction &JA, 2526 Job &Dest, const InputInfo &Output, 2527 const InputInfoList &Inputs, 2528 const ArgList &Args, 2529 const char *LinkingOutput) const { 2530 const Driver &D = getToolChain().getDriver(); 2531 ArgStringList CmdArgs; 2532 2533 if (Args.hasArg(options::OPT_static)) { 2534 CmdArgs.push_back("-Bstatic"); 2535 } else { 2536 CmdArgs.push_back("--eh-frame-hdr"); 2537 if (Args.hasArg(options::OPT_shared)) { 2538 CmdArgs.push_back("-Bshareable"); 2539 } else { 2540 CmdArgs.push_back("-dynamic-linker"); 2541 CmdArgs.push_back("/libexec/ld-elf.so.1"); 2542 } 2543 } 2544 2545 // When building 32-bit code on FreeBSD/amd64, we have to explicitly 2546 // instruct ld in the base system to link 32-bit code. 2547 if (getToolChain().getArchName() == "i386") { 2548 CmdArgs.push_back("-m"); 2549 CmdArgs.push_back("elf_i386_fbsd"); 2550 } 2551 2552 if (Output.isPipe()) { 2553 CmdArgs.push_back("-o"); 2554 CmdArgs.push_back("-"); 2555 } else if (Output.isFilename()) { 2556 CmdArgs.push_back("-o"); 2557 CmdArgs.push_back(Output.getFilename()); 2558 } else { 2559 assert(Output.isNothing() && "Invalid output."); 2560 } 2561 2562 if (!Args.hasArg(options::OPT_nostdlib) && 2563 !Args.hasArg(options::OPT_nostartfiles)) { 2564 if (!Args.hasArg(options::OPT_shared)) { 2565 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crt1.o"))); 2566 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crti.o"))); 2567 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crtbegin.o"))); 2568 } else { 2569 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crti.o"))); 2570 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crtbeginS.o"))); 2571 } 2572 } 2573 2574 Args.AddAllArgs(CmdArgs, options::OPT_L); 2575 Args.AddAllArgs(CmdArgs, options::OPT_T_Group); 2576 Args.AddAllArgs(CmdArgs, options::OPT_e); 2577 2578 for (InputInfoList::const_iterator 2579 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 2580 const InputInfo &II = *it; 2581 2582 // Don't try to pass LLVM inputs to a generic gcc. 2583 if (II.getType() == types::TY_LLVMBC) 2584 D.Diag(clang::diag::err_drv_no_linker_llvm_support) 2585 << getToolChain().getTripleString(); 2586 2587 if (II.isPipe()) 2588 CmdArgs.push_back("-"); 2589 else if (II.isFilename()) 2590 CmdArgs.push_back(II.getFilename()); 2591 else 2592 II.getInputArg().renderAsInput(Args, CmdArgs); 2593 } 2594 2595 if (!Args.hasArg(options::OPT_nostdlib) && 2596 !Args.hasArg(options::OPT_nodefaultlibs)) { 2597 // FIXME: For some reason GCC passes -lgcc and -lgcc_s before adding 2598 // the default system libraries. Just mimic this for now. 2599 CmdArgs.push_back("-lgcc"); 2600 if (D.CCCIsCXX) 2601 CmdArgs.push_back("-lstdc++"); 2602 if (Args.hasArg(options::OPT_static)) { 2603 CmdArgs.push_back("-lgcc_eh"); 2604 } else { 2605 CmdArgs.push_back("--as-needed"); 2606 CmdArgs.push_back("-lgcc_s"); 2607 CmdArgs.push_back("--no-as-needed"); 2608 } 2609 2610 if (Args.hasArg(options::OPT_pthread)) 2611 CmdArgs.push_back("-lpthread"); 2612 CmdArgs.push_back("-lc"); 2613 2614 CmdArgs.push_back("-lgcc"); 2615 if (Args.hasArg(options::OPT_static)) { 2616 CmdArgs.push_back("-lgcc_eh"); 2617 } else { 2618 CmdArgs.push_back("--as-needed"); 2619 CmdArgs.push_back("-lgcc_s"); 2620 CmdArgs.push_back("--no-as-needed"); 2621 } 2622 } 2623 2624 if (!Args.hasArg(options::OPT_nostdlib) && 2625 !Args.hasArg(options::OPT_nostartfiles)) { 2626 if (!Args.hasArg(options::OPT_shared)) 2627 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crtend.o"))); 2628 else 2629 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crtendS.o"))); 2630 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crtn.o"))); 2631 } 2632 2633 const char *Exec = 2634 Args.MakeArgString(getToolChain().GetProgramPath(C, "ld")); 2635 Dest.addCommand(new Command(JA, *this, Exec, CmdArgs)); 2636} 2637 2638/// DragonFly Tools 2639 2640// For now, DragonFly Assemble does just about the same as for 2641// FreeBSD, but this may change soon. 2642void dragonfly::Assemble::ConstructJob(Compilation &C, const JobAction &JA, 2643 Job &Dest, const InputInfo &Output, 2644 const InputInfoList &Inputs, 2645 const ArgList &Args, 2646 const char *LinkingOutput) const { 2647 ArgStringList CmdArgs; 2648 2649 // When building 32-bit code on DragonFly/pc64, we have to explicitly 2650 // instruct as in the base system to assemble 32-bit code. 2651 if (getToolChain().getArchName() == "i386") 2652 CmdArgs.push_back("--32"); 2653 2654 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, 2655 options::OPT_Xassembler); 2656 2657 CmdArgs.push_back("-o"); 2658 if (Output.isPipe()) 2659 CmdArgs.push_back("-"); 2660 else 2661 CmdArgs.push_back(Output.getFilename()); 2662 2663 for (InputInfoList::const_iterator 2664 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 2665 const InputInfo &II = *it; 2666 if (II.isPipe()) 2667 CmdArgs.push_back("-"); 2668 else 2669 CmdArgs.push_back(II.getFilename()); 2670 } 2671 2672 const char *Exec = 2673 Args.MakeArgString(getToolChain().GetProgramPath(C, "as")); 2674 Dest.addCommand(new Command(JA, *this, Exec, CmdArgs)); 2675} 2676 2677void dragonfly::Link::ConstructJob(Compilation &C, const JobAction &JA, 2678 Job &Dest, const InputInfo &Output, 2679 const InputInfoList &Inputs, 2680 const ArgList &Args, 2681 const char *LinkingOutput) const { 2682 const Driver &D = getToolChain().getDriver(); 2683 ArgStringList CmdArgs; 2684 2685 if (Args.hasArg(options::OPT_static)) { 2686 CmdArgs.push_back("-Bstatic"); 2687 } else { 2688 if (Args.hasArg(options::OPT_shared)) 2689 CmdArgs.push_back("-Bshareable"); 2690 else { 2691 CmdArgs.push_back("-dynamic-linker"); 2692 CmdArgs.push_back("/usr/libexec/ld-elf.so.2"); 2693 } 2694 } 2695 2696 // When building 32-bit code on DragonFly/pc64, we have to explicitly 2697 // instruct ld in the base system to link 32-bit code. 2698 if (getToolChain().getArchName() == "i386") { 2699 CmdArgs.push_back("-m"); 2700 CmdArgs.push_back("elf_i386"); 2701 } 2702 2703 if (Output.isPipe()) { 2704 CmdArgs.push_back("-o"); 2705 CmdArgs.push_back("-"); 2706 } else if (Output.isFilename()) { 2707 CmdArgs.push_back("-o"); 2708 CmdArgs.push_back(Output.getFilename()); 2709 } else { 2710 assert(Output.isNothing() && "Invalid output."); 2711 } 2712 2713 if (!Args.hasArg(options::OPT_nostdlib) && 2714 !Args.hasArg(options::OPT_nostartfiles)) { 2715 if (!Args.hasArg(options::OPT_shared)) { 2716 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crt1.o"))); 2717 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crti.o"))); 2718 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crtbegin.o"))); 2719 } else { 2720 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crti.o"))); 2721 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crtbeginS.o"))); 2722 } 2723 } 2724 2725 Args.AddAllArgs(CmdArgs, options::OPT_L); 2726 Args.AddAllArgs(CmdArgs, options::OPT_T_Group); 2727 Args.AddAllArgs(CmdArgs, options::OPT_e); 2728 2729 for (InputInfoList::const_iterator 2730 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 2731 const InputInfo &II = *it; 2732 2733 // Don't try to pass LLVM inputs to a generic gcc. 2734 if (II.getType() == types::TY_LLVMBC) 2735 D.Diag(clang::diag::err_drv_no_linker_llvm_support) 2736 << getToolChain().getTripleString(); 2737 2738 if (II.isPipe()) 2739 CmdArgs.push_back("-"); 2740 else if (II.isFilename()) 2741 CmdArgs.push_back(II.getFilename()); 2742 else 2743 II.getInputArg().renderAsInput(Args, CmdArgs); 2744 } 2745 2746 if (!Args.hasArg(options::OPT_nostdlib) && 2747 !Args.hasArg(options::OPT_nodefaultlibs)) { 2748 // FIXME: GCC passes on -lgcc, -lgcc_pic and a whole lot of 2749 // rpaths 2750 CmdArgs.push_back("-L/usr/lib/gcc41"); 2751 2752 if (!Args.hasArg(options::OPT_static)) { 2753 CmdArgs.push_back("-rpath"); 2754 CmdArgs.push_back("/usr/lib/gcc41"); 2755 2756 CmdArgs.push_back("-rpath-link"); 2757 CmdArgs.push_back("/usr/lib/gcc41"); 2758 2759 CmdArgs.push_back("-rpath"); 2760 CmdArgs.push_back("/usr/lib"); 2761 2762 CmdArgs.push_back("-rpath-link"); 2763 CmdArgs.push_back("/usr/lib"); 2764 } 2765 2766 if (Args.hasArg(options::OPT_shared)) { 2767 CmdArgs.push_back("-lgcc_pic"); 2768 } else { 2769 CmdArgs.push_back("-lgcc"); 2770 } 2771 2772 2773 if (Args.hasArg(options::OPT_pthread)) 2774 CmdArgs.push_back("-lpthread"); 2775 2776 if (!Args.hasArg(options::OPT_nolibc)) { 2777 CmdArgs.push_back("-lc"); 2778 } 2779 2780 if (Args.hasArg(options::OPT_shared)) { 2781 CmdArgs.push_back("-lgcc_pic"); 2782 } else { 2783 CmdArgs.push_back("-lgcc"); 2784 } 2785 } 2786 2787 if (!Args.hasArg(options::OPT_nostdlib) && 2788 !Args.hasArg(options::OPT_nostartfiles)) { 2789 if (!Args.hasArg(options::OPT_shared)) 2790 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crtend.o"))); 2791 else 2792 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crtendS.o"))); 2793 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crtn.o"))); 2794 } 2795 2796 const char *Exec = 2797 Args.MakeArgString(getToolChain().GetProgramPath(C, "ld")); 2798 Dest.addCommand(new Command(JA, *this, Exec, CmdArgs)); 2799} 2800