Tools.cpp revision c16bb76f25ada63864aa89827a9906c1579d2ad3
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/FileSystem.h" 29#include "llvm/Support/Format.h" 30#include "llvm/Support/raw_ostream.h" 31#include "llvm/Support/Host.h" 32#include "llvm/Support/Process.h" 33 34#include "InputInfo.h" 35#include "ToolChains.h" 36 37using namespace clang::driver; 38using namespace clang::driver::tools; 39 40/// CheckPreprocessingOptions - Perform some validation of preprocessing 41/// arguments that is shared with gcc. 42static void CheckPreprocessingOptions(const Driver &D, const ArgList &Args) { 43 if (Arg *A = Args.getLastArg(options::OPT_C, options::OPT_CC)) 44 if (!Args.hasArg(options::OPT_E)) 45 D.Diag(clang::diag::err_drv_argument_only_allowed_with) 46 << A->getAsString(Args) << "-E"; 47} 48 49/// CheckCodeGenerationOptions - Perform some validation of code generation 50/// arguments that is shared with gcc. 51static void CheckCodeGenerationOptions(const Driver &D, const ArgList &Args) { 52 // In gcc, only ARM checks this, but it seems reasonable to check universally. 53 if (Args.hasArg(options::OPT_static)) 54 if (const Arg *A = Args.getLastArg(options::OPT_dynamic, 55 options::OPT_mdynamic_no_pic)) 56 D.Diag(clang::diag::err_drv_argument_not_allowed_with) 57 << A->getAsString(Args) << "-static"; 58} 59 60// Quote target names for inclusion in GNU Make dependency files. 61// Only the characters '$', '#', ' ', '\t' are quoted. 62static void QuoteTarget(llvm::StringRef Target, 63 llvm::SmallVectorImpl<char> &Res) { 64 for (unsigned i = 0, e = Target.size(); i != e; ++i) { 65 switch (Target[i]) { 66 case ' ': 67 case '\t': 68 // Escape the preceding backslashes 69 for (int j = i - 1; j >= 0 && Target[j] == '\\'; --j) 70 Res.push_back('\\'); 71 72 // Escape the space/tab 73 Res.push_back('\\'); 74 break; 75 case '$': 76 Res.push_back('$'); 77 break; 78 case '#': 79 Res.push_back('\\'); 80 break; 81 default: 82 break; 83 } 84 85 Res.push_back(Target[i]); 86 } 87} 88 89static void AddLinkerInputs(const ToolChain &TC, 90 const InputInfoList &Inputs, const ArgList &Args, 91 ArgStringList &CmdArgs) { 92 const Driver &D = TC.getDriver(); 93 94 for (InputInfoList::const_iterator 95 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 96 const InputInfo &II = *it; 97 98 if (!TC.HasNativeLLVMSupport()) { 99 // Don't try to pass LLVM inputs unless we have native support. 100 if (II.getType() == types::TY_LLVM_IR || 101 II.getType() == types::TY_LTO_IR || 102 II.getType() == types::TY_LLVM_BC || 103 II.getType() == types::TY_LTO_BC) 104 D.Diag(clang::diag::err_drv_no_linker_llvm_support) 105 << TC.getTripleString(); 106 } 107 108 // Add filenames immediately. 109 if (II.isFilename()) { 110 CmdArgs.push_back(II.getFilename()); 111 continue; 112 } 113 114 // Otherwise, this is a linker input argument. 115 const Arg &A = II.getInputArg(); 116 117 // Handle reserved library options. 118 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) { 119 TC.AddCXXStdlibLibArgs(Args, CmdArgs); 120 } else if (A.getOption().matches(options::OPT_Z_reserved_lib_cckext)) { 121 TC.AddCCKextLibArgs(Args, CmdArgs); 122 } else 123 A.renderAsInput(Args, CmdArgs); 124 } 125} 126 127void Clang::AddPreprocessingOptions(const Driver &D, 128 const ArgList &Args, 129 ArgStringList &CmdArgs, 130 const InputInfo &Output, 131 const InputInfoList &Inputs) const { 132 Arg *A; 133 134 CheckPreprocessingOptions(D, Args); 135 136 Args.AddLastArg(CmdArgs, options::OPT_C); 137 Args.AddLastArg(CmdArgs, options::OPT_CC); 138 139 // Handle dependency file generation. 140 if ((A = Args.getLastArg(options::OPT_M, options::OPT_MM)) || 141 (A = Args.getLastArg(options::OPT_MD)) || 142 (A = Args.getLastArg(options::OPT_MMD))) { 143 // Determine the output location. 144 const char *DepFile; 145 if (Output.getType() == types::TY_Dependencies) { 146 DepFile = Output.getFilename(); 147 } else if (Arg *MF = Args.getLastArg(options::OPT_MF)) { 148 DepFile = MF->getValue(Args); 149 } else if (A->getOption().matches(options::OPT_M) || 150 A->getOption().matches(options::OPT_MM)) { 151 DepFile = "-"; 152 } else { 153 DepFile = darwin::CC1::getDependencyFileName(Args, Inputs); 154 } 155 CmdArgs.push_back("-dependency-file"); 156 CmdArgs.push_back(DepFile); 157 158 // Add a default target if one wasn't specified. 159 if (!Args.hasArg(options::OPT_MT) && !Args.hasArg(options::OPT_MQ)) { 160 const char *DepTarget; 161 162 // If user provided -o, that is the dependency target, except 163 // when we are only generating a dependency file. 164 Arg *OutputOpt = Args.getLastArg(options::OPT_o); 165 if (OutputOpt && Output.getType() != types::TY_Dependencies) { 166 DepTarget = OutputOpt->getValue(Args); 167 } else { 168 // Otherwise derive from the base input. 169 // 170 // FIXME: This should use the computed output file location. 171 llvm::SmallString<128> P(Inputs[0].getBaseInput()); 172 llvm::sys::path::replace_extension(P, "o"); 173 DepTarget = Args.MakeArgString(llvm::sys::path::filename(P)); 174 } 175 176 CmdArgs.push_back("-MT"); 177 llvm::SmallString<128> Quoted; 178 QuoteTarget(DepTarget, Quoted); 179 CmdArgs.push_back(Args.MakeArgString(Quoted)); 180 } 181 182 if (A->getOption().matches(options::OPT_M) || 183 A->getOption().matches(options::OPT_MD)) 184 CmdArgs.push_back("-sys-header-deps"); 185 } 186 187 Args.AddLastArg(CmdArgs, options::OPT_MP); 188 189 // Convert all -MQ <target> args to -MT <quoted target> 190 for (arg_iterator it = Args.filtered_begin(options::OPT_MT, 191 options::OPT_MQ), 192 ie = Args.filtered_end(); it != ie; ++it) { 193 const Arg *A = *it; 194 A->claim(); 195 196 if (A->getOption().matches(options::OPT_MQ)) { 197 CmdArgs.push_back("-MT"); 198 llvm::SmallString<128> Quoted; 199 QuoteTarget(A->getValue(Args), Quoted); 200 CmdArgs.push_back(Args.MakeArgString(Quoted)); 201 202 // -MT flag - no change 203 } else { 204 A->render(Args, CmdArgs); 205 } 206 } 207 208 // Add -i* options, and automatically translate to 209 // -include-pch/-include-pth for transparent PCH support. It's 210 // wonky, but we include looking for .gch so we can support seamless 211 // replacement into a build system already set up to be generating 212 // .gch files. 213 bool RenderedImplicitInclude = false; 214 for (arg_iterator it = Args.filtered_begin(options::OPT_clang_i_Group), 215 ie = Args.filtered_end(); it != ie; ++it) { 216 const Arg *A = it; 217 218 if (A->getOption().matches(options::OPT_include)) { 219 bool IsFirstImplicitInclude = !RenderedImplicitInclude; 220 RenderedImplicitInclude = true; 221 222 // Use PCH if the user requested it. 223 bool UsePCH = D.CCCUsePCH; 224 225 bool FoundPTH = false; 226 bool FoundPCH = false; 227 llvm::sys::Path P(A->getValue(Args)); 228 bool Exists; 229 if (UsePCH) { 230 P.appendSuffix("pch"); 231 if (!llvm::sys::fs::exists(P.str(), Exists) && Exists) 232 FoundPCH = true; 233 else 234 P.eraseSuffix(); 235 } 236 237 if (!FoundPCH) { 238 P.appendSuffix("pth"); 239 if (!llvm::sys::fs::exists(P.str(), Exists) && Exists) 240 FoundPTH = true; 241 else 242 P.eraseSuffix(); 243 } 244 245 if (!FoundPCH && !FoundPTH) { 246 P.appendSuffix("gch"); 247 if (!llvm::sys::fs::exists(P.str(), Exists) && Exists) { 248 FoundPCH = UsePCH; 249 FoundPTH = !UsePCH; 250 } 251 else 252 P.eraseSuffix(); 253 } 254 255 if (FoundPCH || FoundPTH) { 256 if (IsFirstImplicitInclude) { 257 A->claim(); 258 if (UsePCH) 259 CmdArgs.push_back("-include-pch"); 260 else 261 CmdArgs.push_back("-include-pth"); 262 CmdArgs.push_back(Args.MakeArgString(P.str())); 263 continue; 264 } else { 265 // Ignore the PCH if not first on command line and emit warning. 266 D.Diag(clang::diag::warn_drv_pch_not_first_include) 267 << P.str() << A->getAsString(Args); 268 } 269 } 270 } 271 272 // Not translated, render as usual. 273 A->claim(); 274 A->render(Args, CmdArgs); 275 } 276 277 Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U); 278 Args.AddAllArgs(CmdArgs, options::OPT_I_Group, options::OPT_F); 279 280 // Add C++ include arguments, if needed. 281 types::ID InputType = Inputs[0].getType(); 282 if (types::isCXX(InputType)) 283 getToolChain().AddClangCXXStdlibIncludeArgs(Args, CmdArgs); 284 285 // Add -Wp, and -Xassembler if using the preprocessor. 286 287 // FIXME: There is a very unfortunate problem here, some troubled 288 // souls abuse -Wp, to pass preprocessor options in gcc syntax. To 289 // really support that we would have to parse and then translate 290 // those options. :( 291 Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA, 292 options::OPT_Xpreprocessor); 293 294 // -I- is a deprecated GCC feature, reject it. 295 if (Arg *A = Args.getLastArg(options::OPT_I_)) 296 D.Diag(clang::diag::err_drv_I_dash_not_supported) << A->getAsString(Args); 297 298 // If we have a --sysroot, and don't have an explicit -isysroot flag, add an 299 // -isysroot to the CC1 invocation. 300 if (Arg *A = Args.getLastArg(options::OPT__sysroot_EQ)) { 301 if (!Args.hasArg(options::OPT_isysroot)) { 302 CmdArgs.push_back("-isysroot"); 303 CmdArgs.push_back(A->getValue(Args)); 304 } 305 } 306} 307 308/// getARMTargetCPU - Get the (LLVM) name of the ARM cpu we are targetting. 309// 310// FIXME: tblgen this. 311static const char *getARMTargetCPU(const ArgList &Args, 312 const llvm::Triple &Triple) { 313 // FIXME: Warn on inconsistent use of -mcpu and -march. 314 315 // If we have -mcpu=, use that. 316 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) 317 return A->getValue(Args); 318 319 llvm::StringRef MArch; 320 if (Arg *A = Args.getLastArg(options::OPT_march_EQ)) { 321 // Otherwise, if we have -march= choose the base CPU for that arch. 322 MArch = A->getValue(Args); 323 } else { 324 // Otherwise, use the Arch from the triple. 325 MArch = Triple.getArchName(); 326 } 327 328 if (MArch == "armv2" || MArch == "armv2a") 329 return "arm2"; 330 if (MArch == "armv3") 331 return "arm6"; 332 if (MArch == "armv3m") 333 return "arm7m"; 334 if (MArch == "armv4" || MArch == "armv4t") 335 return "arm7tdmi"; 336 if (MArch == "armv5" || MArch == "armv5t") 337 return "arm10tdmi"; 338 if (MArch == "armv5e" || MArch == "armv5te") 339 return "arm1026ejs"; 340 if (MArch == "armv5tej") 341 return "arm926ej-s"; 342 if (MArch == "armv6" || MArch == "armv6k") 343 return "arm1136jf-s"; 344 if (MArch == "armv6j") 345 return "arm1136j-s"; 346 if (MArch == "armv6z" || MArch == "armv6zk") 347 return "arm1176jzf-s"; 348 if (MArch == "armv6t2") 349 return "arm1156t2-s"; 350 if (MArch == "armv7" || MArch == "armv7a" || MArch == "armv7-a") 351 return "cortex-a8"; 352 if (MArch == "armv7r" || MArch == "armv7-r") 353 return "cortex-r4"; 354 if (MArch == "armv7m" || MArch == "armv7-m") 355 return "cortex-m3"; 356 if (MArch == "ep9312") 357 return "ep9312"; 358 if (MArch == "iwmmxt") 359 return "iwmmxt"; 360 if (MArch == "xscale") 361 return "xscale"; 362 363 // If all else failed, return the most base CPU LLVM supports. 364 return "arm7tdmi"; 365} 366 367/// getLLVMArchSuffixForARM - Get the LLVM arch name to use for a particular 368/// CPU. 369// 370// FIXME: This is redundant with -mcpu, why does LLVM use this. 371// FIXME: tblgen this, or kill it! 372static const char *getLLVMArchSuffixForARM(llvm::StringRef CPU) { 373 if (CPU == "arm7tdmi" || CPU == "arm7tdmi-s" || CPU == "arm710t" || 374 CPU == "arm720t" || CPU == "arm9" || CPU == "arm9tdmi" || 375 CPU == "arm920" || CPU == "arm920t" || CPU == "arm922t" || 376 CPU == "arm940t" || CPU == "ep9312") 377 return "v4t"; 378 379 if (CPU == "arm10tdmi" || CPU == "arm1020t") 380 return "v5"; 381 382 if (CPU == "arm9e" || CPU == "arm926ej-s" || CPU == "arm946e-s" || 383 CPU == "arm966e-s" || CPU == "arm968e-s" || CPU == "arm10e" || 384 CPU == "arm1020e" || CPU == "arm1022e" || CPU == "xscale" || 385 CPU == "iwmmxt") 386 return "v5e"; 387 388 if (CPU == "arm1136j-s" || CPU == "arm1136jf-s" || CPU == "arm1176jz-s" || 389 CPU == "arm1176jzf-s" || CPU == "mpcorenovfp" || CPU == "mpcore") 390 return "v6"; 391 392 if (CPU == "arm1156t2-s" || CPU == "arm1156t2f-s") 393 return "v6t2"; 394 395 if (CPU == "cortex-a8" || CPU == "cortex-a9") 396 return "v7"; 397 398 return ""; 399} 400 401// FIXME: Move to target hook. 402static bool isSignedCharDefault(const llvm::Triple &Triple) { 403 switch (Triple.getArch()) { 404 default: 405 return true; 406 407 case llvm::Triple::ppc: 408 case llvm::Triple::ppc64: 409 if (Triple.getOS() == llvm::Triple::Darwin) 410 return true; 411 return false; 412 413 case llvm::Triple::systemz: 414 return false; 415 } 416} 417 418void Clang::AddARMTargetArgs(const ArgList &Args, 419 ArgStringList &CmdArgs) const { 420 const Driver &D = getToolChain().getDriver(); 421 llvm::Triple Triple = getToolChain().getTriple(); 422 423 // Select the ABI to use. 424 // 425 // FIXME: Support -meabi. 426 const char *ABIName = 0; 427 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) { 428 ABIName = A->getValue(Args); 429 } else { 430 // Select the default based on the platform. 431 switch(Triple.getEnvironment()) { 432 case llvm::Triple::GNUEABI: 433 ABIName = "aapcs-linux"; 434 break; 435 case llvm::Triple::EABI: 436 ABIName = "aapcs"; 437 break; 438 default: 439 ABIName = "apcs-gnu"; 440 } 441 } 442 CmdArgs.push_back("-target-abi"); 443 CmdArgs.push_back(ABIName); 444 445 // Set the CPU based on -march= and -mcpu=. 446 CmdArgs.push_back("-target-cpu"); 447 CmdArgs.push_back(getARMTargetCPU(Args, Triple)); 448 449 // Select the float ABI as determined by -msoft-float, -mhard-float, and 450 // -mfloat-abi=. 451 llvm::StringRef FloatABI; 452 if (Arg *A = Args.getLastArg(options::OPT_msoft_float, 453 options::OPT_mhard_float, 454 options::OPT_mfloat_abi_EQ)) { 455 if (A->getOption().matches(options::OPT_msoft_float)) 456 FloatABI = "soft"; 457 else if (A->getOption().matches(options::OPT_mhard_float)) 458 FloatABI = "hard"; 459 else { 460 FloatABI = A->getValue(Args); 461 if (FloatABI != "soft" && FloatABI != "softfp" && FloatABI != "hard") { 462 D.Diag(clang::diag::err_drv_invalid_mfloat_abi) 463 << A->getAsString(Args); 464 FloatABI = "soft"; 465 } 466 } 467 } 468 469 // If unspecified, choose the default based on the platform. 470 if (FloatABI.empty()) { 471 const llvm::Triple &Triple = getToolChain().getTriple(); 472 switch (Triple.getOS()) { 473 case llvm::Triple::Darwin: { 474 // Darwin defaults to "softfp" for v6 and v7. 475 // 476 // FIXME: Factor out an ARM class so we can cache the arch somewhere. 477 llvm::StringRef ArchName = 478 getLLVMArchSuffixForARM(getARMTargetCPU(Args, Triple)); 479 if (ArchName.startswith("v6") || ArchName.startswith("v7")) 480 FloatABI = "softfp"; 481 else 482 FloatABI = "soft"; 483 break; 484 } 485 486 case llvm::Triple::Linux: { 487 if (getToolChain().getTriple().getEnvironment() == llvm::Triple::GNUEABI) { 488 FloatABI = "softfp"; 489 break; 490 } 491 } 492 // fall through 493 494 default: 495 switch(Triple.getEnvironment()) { 496 case llvm::Triple::GNUEABI: 497 FloatABI = "softfp"; 498 break; 499 case llvm::Triple::EABI: 500 // EABI is always AAPCS, and if it was not marked 'hard', it's softfp 501 FloatABI = "softfp"; 502 break; 503 default: 504 // Assume "soft", but warn the user we are guessing. 505 FloatABI = "soft"; 506 D.Diag(clang::diag::warn_drv_assuming_mfloat_abi_is) << "soft"; 507 break; 508 } 509 } 510 } 511 512 if (FloatABI == "soft") { 513 // Floating point operations and argument passing are soft. 514 // 515 // FIXME: This changes CPP defines, we need -target-soft-float. 516 CmdArgs.push_back("-msoft-float"); 517 CmdArgs.push_back("-mfloat-abi"); 518 CmdArgs.push_back("soft"); 519 } else if (FloatABI == "softfp") { 520 // Floating point operations are hard, but argument passing is soft. 521 CmdArgs.push_back("-mfloat-abi"); 522 CmdArgs.push_back("soft"); 523 } else { 524 // Floating point operations and argument passing are hard. 525 assert(FloatABI == "hard" && "Invalid float abi!"); 526 CmdArgs.push_back("-mfloat-abi"); 527 CmdArgs.push_back("hard"); 528 } 529 530 // Set appropriate target features for floating point mode. 531 // 532 // FIXME: Note, this is a hack, the LLVM backend doesn't actually use these 533 // yet (it uses the -mfloat-abi and -msoft-float options above), and it is 534 // stripped out by the ARM target. 535 536 // Use software floating point operations? 537 if (FloatABI == "soft") { 538 CmdArgs.push_back("-target-feature"); 539 CmdArgs.push_back("+soft-float"); 540 } 541 542 // Use software floating point argument passing? 543 if (FloatABI != "hard") { 544 CmdArgs.push_back("-target-feature"); 545 CmdArgs.push_back("+soft-float-abi"); 546 } 547 548 // Honor -mfpu=. 549 // 550 // FIXME: Centralize feature selection, defaulting shouldn't be also in the 551 // frontend target. 552 if (const Arg *A = Args.getLastArg(options::OPT_mfpu_EQ)) { 553 llvm::StringRef FPU = A->getValue(Args); 554 555 // Set the target features based on the FPU. 556 if (FPU == "fpa" || FPU == "fpe2" || FPU == "fpe3" || FPU == "maverick") { 557 // Disable any default FPU support. 558 CmdArgs.push_back("-target-feature"); 559 CmdArgs.push_back("-vfp2"); 560 CmdArgs.push_back("-target-feature"); 561 CmdArgs.push_back("-vfp3"); 562 CmdArgs.push_back("-target-feature"); 563 CmdArgs.push_back("-neon"); 564 } else if (FPU == "vfp") { 565 CmdArgs.push_back("-target-feature"); 566 CmdArgs.push_back("+vfp2"); 567 } else if (FPU == "vfp3") { 568 CmdArgs.push_back("-target-feature"); 569 CmdArgs.push_back("+vfp3"); 570 } else if (FPU == "neon") { 571 CmdArgs.push_back("-target-feature"); 572 CmdArgs.push_back("+neon"); 573 } else 574 D.Diag(clang::diag::err_drv_clang_unsupported) << A->getAsString(Args); 575 } 576} 577 578void Clang::AddMIPSTargetArgs(const ArgList &Args, 579 ArgStringList &CmdArgs) const { 580 const Driver &D = getToolChain().getDriver(); 581 582 // Select the ABI to use. 583 const char *ABIName = 0; 584 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) { 585 ABIName = A->getValue(Args); 586 } else { 587 ABIName = "o32"; 588 } 589 590 CmdArgs.push_back("-target-abi"); 591 CmdArgs.push_back(ABIName); 592 593 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) { 594 llvm::StringRef MArch = A->getValue(Args); 595 CmdArgs.push_back("-target-cpu"); 596 597 if ((MArch == "r2000") || (MArch == "r3000")) 598 CmdArgs.push_back("mips1"); 599 else if (MArch == "r6000") 600 CmdArgs.push_back("mips2"); 601 else 602 CmdArgs.push_back(MArch.str().c_str()); 603 } 604 605 // Select the float ABI as determined by -msoft-float, -mhard-float, and 606 llvm::StringRef FloatABI; 607 if (Arg *A = Args.getLastArg(options::OPT_msoft_float, 608 options::OPT_mhard_float)) { 609 if (A->getOption().matches(options::OPT_msoft_float)) 610 FloatABI = "soft"; 611 else if (A->getOption().matches(options::OPT_mhard_float)) 612 FloatABI = "hard"; 613 } 614 615 // If unspecified, choose the default based on the platform. 616 if (FloatABI.empty()) { 617 // Assume "soft", but warn the user we are guessing. 618 FloatABI = "soft"; 619 D.Diag(clang::diag::warn_drv_assuming_mfloat_abi_is) << "soft"; 620 } 621 622 if (FloatABI == "soft") { 623 // Floating point operations and argument passing are soft. 624 // 625 // FIXME: This changes CPP defines, we need -target-soft-float. 626 CmdArgs.push_back("-msoft-float"); 627 } else { 628 assert(FloatABI == "hard" && "Invalid float abi!"); 629 CmdArgs.push_back("-mhard-float"); 630 } 631} 632 633void Clang::AddSparcTargetArgs(const ArgList &Args, 634 ArgStringList &CmdArgs) const { 635 const Driver &D = getToolChain().getDriver(); 636 637 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) { 638 llvm::StringRef MArch = A->getValue(Args); 639 CmdArgs.push_back("-target-cpu"); 640 CmdArgs.push_back(MArch.str().c_str()); 641 } 642 643 // Select the float ABI as determined by -msoft-float, -mhard-float, and 644 llvm::StringRef FloatABI; 645 if (Arg *A = Args.getLastArg(options::OPT_msoft_float, 646 options::OPT_mhard_float)) { 647 if (A->getOption().matches(options::OPT_msoft_float)) 648 FloatABI = "soft"; 649 else if (A->getOption().matches(options::OPT_mhard_float)) 650 FloatABI = "hard"; 651 } 652 653 // If unspecified, choose the default based on the platform. 654 if (FloatABI.empty()) { 655 switch (getToolChain().getTriple().getOS()) { 656 default: 657 // Assume "soft", but warn the user we are guessing. 658 FloatABI = "soft"; 659 D.Diag(clang::diag::warn_drv_assuming_mfloat_abi_is) << "soft"; 660 break; 661 } 662 } 663 664 if (FloatABI == "soft") { 665 // Floating point operations and argument passing are soft. 666 // 667 // FIXME: This changes CPP defines, we need -target-soft-float. 668 CmdArgs.push_back("-msoft-float"); 669 CmdArgs.push_back("soft"); 670 CmdArgs.push_back("-target-feature"); 671 CmdArgs.push_back("+soft-float"); 672 } else { 673 assert(FloatABI == "hard" && "Invalid float abi!"); 674 CmdArgs.push_back("-mhard-float"); 675 } 676} 677 678void Clang::AddX86TargetArgs(const ArgList &Args, 679 ArgStringList &CmdArgs) const { 680 if (!Args.hasFlag(options::OPT_mred_zone, 681 options::OPT_mno_red_zone, 682 true) || 683 Args.hasArg(options::OPT_mkernel) || 684 Args.hasArg(options::OPT_fapple_kext)) 685 CmdArgs.push_back("-disable-red-zone"); 686 687 if (Args.hasFlag(options::OPT_msoft_float, 688 options::OPT_mno_soft_float, 689 false)) 690 CmdArgs.push_back("-no-implicit-float"); 691 692 const char *CPUName = 0; 693 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) { 694 if (llvm::StringRef(A->getValue(Args)) == "native") { 695 // FIXME: Reject attempts to use -march=native unless the target matches 696 // the host. 697 // 698 // FIXME: We should also incorporate the detected target features for use 699 // with -native. 700 std::string CPU = llvm::sys::getHostCPUName(); 701 if (!CPU.empty()) 702 CPUName = Args.MakeArgString(CPU); 703 } else 704 CPUName = A->getValue(Args); 705 } 706 707 // Select the default CPU if none was given (or detection failed). 708 if (!CPUName) { 709 // FIXME: Need target hooks. 710 if (getToolChain().getOS().startswith("darwin")) { 711 if (getToolChain().getArchName() == "x86_64") 712 CPUName = "core2"; 713 else if (getToolChain().getArchName() == "i386") 714 CPUName = "yonah"; 715 } else if (getToolChain().getOS().startswith("haiku")) { 716 if (getToolChain().getArchName() == "x86_64") 717 CPUName = "x86-64"; 718 else if (getToolChain().getArchName() == "i386") 719 CPUName = "i586"; 720 } else if (getToolChain().getOS().startswith("openbsd")) { 721 if (getToolChain().getArchName() == "x86_64") 722 CPUName = "x86-64"; 723 else if (getToolChain().getArchName() == "i386") 724 CPUName = "i486"; 725 } else if (getToolChain().getOS().startswith("netbsd")) { 726 if (getToolChain().getArchName() == "x86_64") 727 CPUName = "x86-64"; 728 else if (getToolChain().getArchName() == "i386") 729 CPUName = "i486"; 730 } else { 731 if (getToolChain().getArchName() == "x86_64") 732 CPUName = "x86-64"; 733 else if (getToolChain().getArchName() == "i386") 734 CPUName = "pentium4"; 735 } 736 } 737 738 if (CPUName) { 739 CmdArgs.push_back("-target-cpu"); 740 CmdArgs.push_back(CPUName); 741 } 742 743 for (arg_iterator it = Args.filtered_begin(options::OPT_m_x86_Features_Group), 744 ie = Args.filtered_end(); it != ie; ++it) { 745 llvm::StringRef Name = (*it)->getOption().getName(); 746 (*it)->claim(); 747 748 // Skip over "-m". 749 assert(Name.startswith("-m") && "Invalid feature name."); 750 Name = Name.substr(2); 751 752 bool IsNegative = Name.startswith("no-"); 753 if (IsNegative) 754 Name = Name.substr(3); 755 756 CmdArgs.push_back("-target-feature"); 757 CmdArgs.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name)); 758 } 759} 760 761static bool needsExceptions(const ArgList &Args, types::ID InputType, 762 const llvm::Triple &Triple) { 763 // Handle -fno-exceptions. 764 if (Arg *A = Args.getLastArg(options::OPT_fexceptions, 765 options::OPT_fno_exceptions)) { 766 if (A->getOption().matches(options::OPT_fexceptions)) 767 return true; 768 else 769 return false; 770 } 771 772 // Otherwise, C++ inputs use exceptions. 773 if (types::isCXX(InputType)) 774 return true; 775 776 // As do Objective-C non-fragile ABI inputs and all Objective-C inputs on 777 // x86_64 and ARM after SnowLeopard. 778 if (types::isObjC(InputType)) { 779 if (Args.hasArg(options::OPT_fobjc_nonfragile_abi)) 780 return true; 781 if (Triple.getOS() != llvm::Triple::Darwin) 782 return false; 783 return (Triple.getDarwinMajorNumber() >= 9 && 784 (Triple.getArch() == llvm::Triple::x86_64 || 785 Triple.getArch() == llvm::Triple::arm)); 786 } 787 788 return false; 789} 790 791void Clang::ConstructJob(Compilation &C, const JobAction &JA, 792 const InputInfo &Output, 793 const InputInfoList &Inputs, 794 const ArgList &Args, 795 const char *LinkingOutput) const { 796 bool KernelOrKext = Args.hasArg(options::OPT_mkernel, 797 options::OPT_fapple_kext); 798 const Driver &D = getToolChain().getDriver(); 799 ArgStringList CmdArgs; 800 801 assert(Inputs.size() == 1 && "Unable to handle multiple inputs."); 802 803 // Invoke ourselves in -cc1 mode. 804 // 805 // FIXME: Implement custom jobs for internal actions. 806 CmdArgs.push_back("-cc1"); 807 808 // Add the "effective" target triple. 809 CmdArgs.push_back("-triple"); 810 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args); 811 CmdArgs.push_back(Args.MakeArgString(TripleStr)); 812 813 // Select the appropriate action. 814 bool IsRewriter = false; 815 if (isa<AnalyzeJobAction>(JA)) { 816 assert(JA.getType() == types::TY_Plist && "Invalid output type."); 817 CmdArgs.push_back("-analyze"); 818 } else if (isa<PreprocessJobAction>(JA)) { 819 if (Output.getType() == types::TY_Dependencies) 820 CmdArgs.push_back("-Eonly"); 821 else 822 CmdArgs.push_back("-E"); 823 } else if (isa<AssembleJobAction>(JA)) { 824 CmdArgs.push_back("-emit-obj"); 825 826 // At -O0, we use -mrelax-all by default. 827 bool IsOpt = false; 828 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) 829 IsOpt = !A->getOption().matches(options::OPT_O0); 830 if (Args.hasFlag(options::OPT_mrelax_all, 831 options::OPT_mno_relax_all, 832 !IsOpt)) 833 CmdArgs.push_back("-mrelax-all"); 834 835 // When using an integrated assembler, translate -Wa, and -Xassembler 836 // options. 837 for (arg_iterator it = Args.filtered_begin(options::OPT_Wa_COMMA, 838 options::OPT_Xassembler), 839 ie = Args.filtered_end(); it != ie; ++it) { 840 const Arg *A = *it; 841 A->claim(); 842 843 for (unsigned i = 0, e = A->getNumValues(); i != e; ++i) { 844 llvm::StringRef Value = A->getValue(Args, i); 845 846 if (Value == "-force_cpusubtype_ALL") { 847 // Do nothing, this is the default and we don't support anything else. 848 } else if (Value == "-L") { 849 // We don't support -L yet, but it isn't important enough to error 850 // on. No one should really be using it for a semantic change. 851 D.Diag(clang::diag::warn_drv_unsupported_option_argument) 852 << A->getOption().getName() << Value; 853 } else { 854 D.Diag(clang::diag::err_drv_unsupported_option_argument) 855 << A->getOption().getName() << Value; 856 } 857 } 858 } 859 860 // Also ignore explicit -force_cpusubtype_ALL option. 861 (void) Args.hasArg(options::OPT_force__cpusubtype__ALL); 862 } else if (isa<PrecompileJobAction>(JA)) { 863 // Use PCH if the user requested it. 864 bool UsePCH = D.CCCUsePCH; 865 866 if (UsePCH) 867 CmdArgs.push_back("-emit-pch"); 868 else 869 CmdArgs.push_back("-emit-pth"); 870 } else { 871 assert(isa<CompileJobAction>(JA) && "Invalid action for clang tool."); 872 873 if (JA.getType() == types::TY_Nothing) { 874 CmdArgs.push_back("-fsyntax-only"); 875 } else if (JA.getType() == types::TY_LLVM_IR || 876 JA.getType() == types::TY_LTO_IR) { 877 CmdArgs.push_back("-emit-llvm"); 878 } else if (JA.getType() == types::TY_LLVM_BC || 879 JA.getType() == types::TY_LTO_BC) { 880 CmdArgs.push_back("-emit-llvm-bc"); 881 } else if (JA.getType() == types::TY_PP_Asm) { 882 CmdArgs.push_back("-S"); 883 } else if (JA.getType() == types::TY_AST) { 884 CmdArgs.push_back("-emit-pch"); 885 } else if (JA.getType() == types::TY_RewrittenObjC) { 886 CmdArgs.push_back("-rewrite-objc"); 887 IsRewriter = true; 888 } else { 889 assert(JA.getType() == types::TY_PP_Asm && 890 "Unexpected output type!"); 891 } 892 } 893 894 // The make clang go fast button. 895 CmdArgs.push_back("-disable-free"); 896 897 // Disable the verification pass in -asserts builds. 898#ifdef NDEBUG 899 CmdArgs.push_back("-disable-llvm-verifier"); 900#endif 901 902 // Set the main file name, so that debug info works even with 903 // -save-temps. 904 CmdArgs.push_back("-main-file-name"); 905 CmdArgs.push_back(darwin::CC1::getBaseInputName(Args, Inputs)); 906 907 // Some flags which affect the language (via preprocessor 908 // defines). See darwin::CC1::AddCPPArgs. 909 if (Args.hasArg(options::OPT_static)) 910 CmdArgs.push_back("-static-define"); 911 912 if (isa<AnalyzeJobAction>(JA)) { 913 // Enable region store model by default. 914 CmdArgs.push_back("-analyzer-store=region"); 915 916 // Treat blocks as analysis entry points. 917 CmdArgs.push_back("-analyzer-opt-analyze-nested-blocks"); 918 919 // Add default argument set. 920 if (!Args.hasArg(options::OPT__analyzer_no_default_checks)) { 921 types::ID InputType = Inputs[0].getType(); 922 923 // Checks to perform for all language types. 924 CmdArgs.push_back("-analyzer-check-dead-stores"); 925 926 // Checks to perform for Objective-C/Objective-C++. 927 if (types::isObjC(InputType)) { 928 CmdArgs.push_back("-analyzer-check-objc-methodsigs"); 929 CmdArgs.push_back("-analyzer-check-objc-unused-ivars"); 930 CmdArgs.push_back("-analyzer-check-objc-self-init"); 931 // Do not enable the missing -dealloc check. 932 // '-analyzer-check-objc-missing-dealloc', 933 } 934 935 // Checks to perform for all languages *except* C++. 936 if (!types::isCXX(InputType)) { 937 // Do not enable the security-syntatic check since it 938 // it needs to be refined (known issues). 939 // CmdArgs.push_back("-analyzer-check-security-syntactic"); 940 941 // NOTE: Leaving -analyzer-check-objc-mem here is intentional. 942 // It also checks C code. 943 CmdArgs.push_back("-analyzer-check-objc-mem"); 944 945 CmdArgs.push_back("-analyzer-eagerly-assume"); 946 CmdArgs.push_back("-analyzer-check-idempotent-operations"); 947 } 948 } 949 950 // Set the output format. The default is plist, for (lame) historical 951 // reasons. 952 CmdArgs.push_back("-analyzer-output"); 953 if (Arg *A = Args.getLastArg(options::OPT__analyzer_output)) 954 CmdArgs.push_back(A->getValue(Args)); 955 else 956 CmdArgs.push_back("plist"); 957 958 // Disable the presentation of standard compiler warnings when 959 // using --analyze. We only want to show static analyzer diagnostics 960 // or frontend errors. 961 CmdArgs.push_back("-w"); 962 963 // Add -Xanalyzer arguments when running as analyzer. 964 Args.AddAllArgValues(CmdArgs, options::OPT_Xanalyzer); 965 } 966 967 CheckCodeGenerationOptions(D, Args); 968 969 // Perform argument translation for LLVM backend. This 970 // takes some care in reconciling with llvm-gcc. The 971 // issue is that llvm-gcc translates these options based on 972 // the values in cc1, whereas we are processing based on 973 // the driver arguments. 974 975 // This comes from the default translation the driver + cc1 976 // would do to enable flag_pic. 977 // 978 // FIXME: Centralize this code. 979 bool PICEnabled = (Args.hasArg(options::OPT_fPIC) || 980 Args.hasArg(options::OPT_fpic) || 981 Args.hasArg(options::OPT_fPIE) || 982 Args.hasArg(options::OPT_fpie)); 983 bool PICDisabled = (Args.hasArg(options::OPT_mkernel) || 984 Args.hasArg(options::OPT_static)); 985 const char *Model = getToolChain().GetForcedPicModel(); 986 if (!Model) { 987 if (Args.hasArg(options::OPT_mdynamic_no_pic)) 988 Model = "dynamic-no-pic"; 989 else if (PICDisabled) 990 Model = "static"; 991 else if (PICEnabled) 992 Model = "pic"; 993 else 994 Model = getToolChain().GetDefaultRelocationModel(); 995 } 996 if (llvm::StringRef(Model) != "pic") { 997 CmdArgs.push_back("-mrelocation-model"); 998 CmdArgs.push_back(Model); 999 } 1000 1001 // Infer the __PIC__ value. 1002 // 1003 // FIXME: This isn't quite right on Darwin, which always sets 1004 // __PIC__=2. 1005 if (strcmp(Model, "pic") == 0 || strcmp(Model, "dynamic-no-pic") == 0) { 1006 CmdArgs.push_back("-pic-level"); 1007 CmdArgs.push_back(Args.hasArg(options::OPT_fPIC) ? "2" : "1"); 1008 } 1009 if (!Args.hasFlag(options::OPT_fmerge_all_constants, 1010 options::OPT_fno_merge_all_constants)) 1011 CmdArgs.push_back("-no-merge-all-constants"); 1012 1013 // LLVM Code Generator Options. 1014 1015 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) { 1016 CmdArgs.push_back("-mregparm"); 1017 CmdArgs.push_back(A->getValue(Args)); 1018 } 1019 1020 // FIXME: Set --enable-unsafe-fp-math. 1021 if (Args.hasFlag(options::OPT_fno_omit_frame_pointer, 1022 options::OPT_fomit_frame_pointer)) 1023 CmdArgs.push_back("-mdisable-fp-elim"); 1024 if (!Args.hasFlag(options::OPT_fzero_initialized_in_bss, 1025 options::OPT_fno_zero_initialized_in_bss)) 1026 CmdArgs.push_back("-mno-zero-initialized-in-bss"); 1027 if (!Args.hasFlag(options::OPT_fstrict_aliasing, 1028 options::OPT_fno_strict_aliasing, 1029 getToolChain().IsStrictAliasingDefault())) 1030 CmdArgs.push_back("-relaxed-aliasing"); 1031 1032 // Decide whether to use verbose asm. Verbose assembly is the default on 1033 // toolchains which have the integrated assembler on by default. 1034 bool IsVerboseAsmDefault = getToolChain().IsIntegratedAssemblerDefault(); 1035 if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm, 1036 IsVerboseAsmDefault) || 1037 Args.hasArg(options::OPT_dA)) 1038 CmdArgs.push_back("-masm-verbose"); 1039 1040 if (Args.hasArg(options::OPT_fdebug_pass_structure)) { 1041 CmdArgs.push_back("-mdebug-pass"); 1042 CmdArgs.push_back("Structure"); 1043 } 1044 if (Args.hasArg(options::OPT_fdebug_pass_arguments)) { 1045 CmdArgs.push_back("-mdebug-pass"); 1046 CmdArgs.push_back("Arguments"); 1047 } 1048 1049 // Enable -mconstructor-aliases except on darwin, where we have to 1050 // work around a linker bug; see <rdar://problem/7651567>. 1051 if (getToolChain().getTriple().getOS() != llvm::Triple::Darwin) 1052 CmdArgs.push_back("-mconstructor-aliases"); 1053 1054 if (Args.hasArg(options::OPT_mms_bitfields)) { 1055 CmdArgs.push_back("-mms-bitfields"); 1056 } 1057 1058 // This is a coarse approximation of what llvm-gcc actually does, both 1059 // -fasynchronous-unwind-tables and -fnon-call-exceptions interact in more 1060 // complicated ways. 1061 bool AsynchronousUnwindTables = 1062 Args.hasFlag(options::OPT_fasynchronous_unwind_tables, 1063 options::OPT_fno_asynchronous_unwind_tables, 1064 getToolChain().IsUnwindTablesDefault() && 1065 !KernelOrKext); 1066 if (Args.hasFlag(options::OPT_funwind_tables, options::OPT_fno_unwind_tables, 1067 AsynchronousUnwindTables)) 1068 CmdArgs.push_back("-munwind-tables"); 1069 1070 if (Arg *A = Args.getLastArg(options::OPT_flimited_precision_EQ)) { 1071 CmdArgs.push_back("-mlimit-float-precision"); 1072 CmdArgs.push_back(A->getValue(Args)); 1073 } 1074 1075 // FIXME: Handle -mtune=. 1076 (void) Args.hasArg(options::OPT_mtune_EQ); 1077 1078 if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) { 1079 CmdArgs.push_back("-mcode-model"); 1080 CmdArgs.push_back(A->getValue(Args)); 1081 } 1082 1083 // Add target specific cpu and features flags. 1084 switch(getToolChain().getTriple().getArch()) { 1085 default: 1086 break; 1087 1088 case llvm::Triple::arm: 1089 case llvm::Triple::thumb: 1090 AddARMTargetArgs(Args, CmdArgs); 1091 break; 1092 1093 case llvm::Triple::mips: 1094 case llvm::Triple::mipsel: 1095 AddMIPSTargetArgs(Args, CmdArgs); 1096 break; 1097 1098 case llvm::Triple::sparc: 1099 AddSparcTargetArgs(Args, CmdArgs); 1100 break; 1101 1102 case llvm::Triple::x86: 1103 case llvm::Triple::x86_64: 1104 AddX86TargetArgs(Args, CmdArgs); 1105 break; 1106 } 1107 1108 // Pass the linker version in use. 1109 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) { 1110 CmdArgs.push_back("-target-linker-version"); 1111 CmdArgs.push_back(A->getValue(Args)); 1112 } 1113 1114 // -mno-omit-leaf-frame-pointer is the default on Darwin. 1115 if (Args.hasFlag(options::OPT_momit_leaf_frame_pointer, 1116 options::OPT_mno_omit_leaf_frame_pointer, 1117 getToolChain().getTriple().getOS() != llvm::Triple::Darwin)) 1118 CmdArgs.push_back("-momit-leaf-frame-pointer"); 1119 1120 // -fno-math-errno is default. 1121 if (Args.hasFlag(options::OPT_fmath_errno, 1122 options::OPT_fno_math_errno, 1123 false)) 1124 CmdArgs.push_back("-fmath-errno"); 1125 1126 // Explicitly error on some things we know we don't support and can't just 1127 // ignore. 1128 types::ID InputType = Inputs[0].getType(); 1129 if (!Args.hasArg(options::OPT_fallow_unsupported)) { 1130 Arg *Unsupported; 1131 if ((Unsupported = Args.getLastArg(options::OPT_MG)) || 1132 (Unsupported = Args.getLastArg(options::OPT_iframework))) 1133 D.Diag(clang::diag::err_drv_clang_unsupported) 1134 << Unsupported->getOption().getName(); 1135 1136 if (types::isCXX(InputType) && 1137 getToolChain().getTriple().getOS() == llvm::Triple::Darwin && 1138 getToolChain().getTriple().getArch() == llvm::Triple::x86) { 1139 if ((Unsupported = Args.getLastArg(options::OPT_fapple_kext))) 1140 D.Diag(clang::diag::err_drv_clang_unsupported_opt_cxx_darwin_i386) 1141 << Unsupported->getOption().getName(); 1142 } 1143 } 1144 1145 Args.AddAllArgs(CmdArgs, options::OPT_v); 1146 Args.AddLastArg(CmdArgs, options::OPT_H); 1147 if (D.CCPrintHeaders) { 1148 CmdArgs.push_back("-header-include-file"); 1149 CmdArgs.push_back(D.CCPrintHeadersFilename ? 1150 D.CCPrintHeadersFilename : "-"); 1151 } 1152 Args.AddLastArg(CmdArgs, options::OPT_P); 1153 Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout); 1154 1155 // Special case debug options to only pass -g to clang. This is 1156 // wrong. 1157 Args.ClaimAllArgs(options::OPT_g_Group); 1158 if (Arg *A = Args.getLastArg(options::OPT_g_Group)) 1159 if (!A->getOption().matches(options::OPT_g0)) 1160 CmdArgs.push_back("-g"); 1161 1162 Args.AddAllArgs(CmdArgs, options::OPT_ffunction_sections); 1163 Args.AddAllArgs(CmdArgs, options::OPT_fdata_sections); 1164 1165 Args.AddAllArgs(CmdArgs, options::OPT_finstrument_functions); 1166 1167 Args.AddLastArg(CmdArgs, options::OPT_nostdinc); 1168 Args.AddLastArg(CmdArgs, options::OPT_nostdincxx); 1169 Args.AddLastArg(CmdArgs, options::OPT_nobuiltininc); 1170 1171 // Pass the path to compiler resource files. 1172 CmdArgs.push_back("-resource-dir"); 1173 CmdArgs.push_back(D.ResourceDir.c_str()); 1174 1175 Args.AddLastArg(CmdArgs, options::OPT_working_directory); 1176 1177 // Add preprocessing options like -I, -D, etc. if we are using the 1178 // preprocessor. 1179 // 1180 // FIXME: Support -fpreprocessed 1181 if (types::getPreprocessedType(InputType) != types::TY_INVALID) 1182 AddPreprocessingOptions(D, Args, CmdArgs, Output, Inputs); 1183 1184 // Manually translate -O to -O2 and -O4 to -O3; let clang reject 1185 // others. 1186 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) { 1187 if (A->getOption().matches(options::OPT_O4)) 1188 CmdArgs.push_back("-O3"); 1189 else if (A->getOption().matches(options::OPT_O) && 1190 A->getValue(Args)[0] == '\0') 1191 CmdArgs.push_back("-O2"); 1192 else if (A->getOption().matches(options::OPT_O) && 1193 A->getValue(Args)[0] == 'z' && 1194 A->getValue(Args)[1] == '\0') 1195 CmdArgs.push_back("-Os"); 1196 else 1197 A->render(Args, CmdArgs); 1198 } 1199 1200 Args.AddAllArgs(CmdArgs, options::OPT_W_Group); 1201 Args.AddLastArg(CmdArgs, options::OPT_pedantic); 1202 Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors); 1203 Args.AddLastArg(CmdArgs, options::OPT_w); 1204 1205 // Handle -{std, ansi, trigraphs} -- take the last of -{std, ansi} 1206 // (-ansi is equivalent to -std=c89). 1207 // 1208 // If a std is supplied, only add -trigraphs if it follows the 1209 // option. 1210 if (Arg *Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) { 1211 if (Std->getOption().matches(options::OPT_ansi)) 1212 if (types::isCXX(InputType)) 1213 CmdArgs.push_back("-std=c++98"); 1214 else 1215 CmdArgs.push_back("-std=c89"); 1216 else 1217 Std->render(Args, CmdArgs); 1218 1219 if (Arg *A = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi, 1220 options::OPT_trigraphs)) 1221 if (A != Std) 1222 A->render(Args, CmdArgs); 1223 } else { 1224 // Honor -std-default. 1225 // 1226 // FIXME: Clang doesn't correctly handle -std= when the input language 1227 // doesn't match. For the time being just ignore this for C++ inputs; 1228 // eventually we want to do all the standard defaulting here instead of 1229 // splitting it between the driver and clang -cc1. 1230 if (!types::isCXX(InputType)) 1231 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ, 1232 "-std=", /*Joined=*/true); 1233 Args.AddLastArg(CmdArgs, options::OPT_trigraphs); 1234 } 1235 1236 // Translate GCC's misnamer '-fasm' arguments to '-fgnu-keywords'. 1237 if (Arg *Asm = Args.getLastArg(options::OPT_fasm, options::OPT_fno_asm)) { 1238 if (Asm->getOption().matches(options::OPT_fasm)) 1239 CmdArgs.push_back("-fgnu-keywords"); 1240 else 1241 CmdArgs.push_back("-fno-gnu-keywords"); 1242 } 1243 1244 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_depth_)) { 1245 CmdArgs.push_back("-ftemplate-depth"); 1246 CmdArgs.push_back(A->getValue(Args)); 1247 } 1248 1249 if (Arg *A = Args.getLastArg(options::OPT_Wlarge_by_value_copy_EQ, 1250 options::OPT_Wlarge_by_value_copy_def)) { 1251 CmdArgs.push_back("-Wlarge-by-value-copy"); 1252 if (A->getNumValues()) 1253 CmdArgs.push_back(A->getValue(Args)); 1254 else 1255 CmdArgs.push_back("64"); // default value for -Wlarge-by-value-copy. 1256 } 1257 1258 if (Args.hasArg(options::OPT__relocatable_pch)) 1259 CmdArgs.push_back("-relocatable-pch"); 1260 1261 if (Arg *A = Args.getLastArg(options::OPT_fconstant_string_class_EQ)) { 1262 CmdArgs.push_back("-fconstant-string-class"); 1263 CmdArgs.push_back(A->getValue(Args)); 1264 } 1265 1266 if (Arg *A = Args.getLastArg(options::OPT_ftabstop_EQ)) { 1267 CmdArgs.push_back("-ftabstop"); 1268 CmdArgs.push_back(A->getValue(Args)); 1269 } 1270 1271 CmdArgs.push_back("-ferror-limit"); 1272 if (Arg *A = Args.getLastArg(options::OPT_ferror_limit_EQ)) 1273 CmdArgs.push_back(A->getValue(Args)); 1274 else 1275 CmdArgs.push_back("19"); 1276 1277 if (Arg *A = Args.getLastArg(options::OPT_fmacro_backtrace_limit_EQ)) { 1278 CmdArgs.push_back("-fmacro-backtrace-limit"); 1279 CmdArgs.push_back(A->getValue(Args)); 1280 } 1281 1282 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_backtrace_limit_EQ)) { 1283 CmdArgs.push_back("-ftemplate-backtrace-limit"); 1284 CmdArgs.push_back(A->getValue(Args)); 1285 } 1286 1287 // Pass -fmessage-length=. 1288 CmdArgs.push_back("-fmessage-length"); 1289 if (Arg *A = Args.getLastArg(options::OPT_fmessage_length_EQ)) { 1290 CmdArgs.push_back(A->getValue(Args)); 1291 } else { 1292 // If -fmessage-length=N was not specified, determine whether this is a 1293 // terminal and, if so, implicitly define -fmessage-length appropriately. 1294 unsigned N = llvm::sys::Process::StandardErrColumns(); 1295 CmdArgs.push_back(Args.MakeArgString(llvm::Twine(N))); 1296 } 1297 1298 if (const Arg *A = Args.getLastArg(options::OPT_fvisibility_EQ)) { 1299 CmdArgs.push_back("-fvisibility"); 1300 CmdArgs.push_back(A->getValue(Args)); 1301 } 1302 1303 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden); 1304 1305 // -fhosted is default. 1306 if (KernelOrKext || Args.hasFlag(options::OPT_ffreestanding, 1307 options::OPT_fhosted, 1308 false)) 1309 CmdArgs.push_back("-ffreestanding"); 1310 1311 // Forward -f (flag) options which we can pass directly. 1312 Args.AddLastArg(CmdArgs, options::OPT_fcatch_undefined_behavior); 1313 Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls); 1314 Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions); 1315 Args.AddLastArg(CmdArgs, options::OPT_flimit_debug_info); 1316 Args.AddLastArg(CmdArgs, options::OPT_pg); 1317 1318 // -flax-vector-conversions is default. 1319 if (!Args.hasFlag(options::OPT_flax_vector_conversions, 1320 options::OPT_fno_lax_vector_conversions)) 1321 CmdArgs.push_back("-fno-lax-vector-conversions"); 1322 1323 // Handle -fobjc-gc and -fobjc-gc-only. They are exclusive, and -fobjc-gc-only 1324 // takes precedence. 1325 const Arg *GCArg = Args.getLastArg(options::OPT_fobjc_gc_only); 1326 if (!GCArg) 1327 GCArg = Args.getLastArg(options::OPT_fobjc_gc); 1328 if (GCArg) { 1329 if (getToolChain().SupportsObjCGC()) { 1330 GCArg->render(Args, CmdArgs); 1331 } else { 1332 // FIXME: We should move this to a hard error. 1333 D.Diag(clang::diag::warn_drv_objc_gc_unsupported) 1334 << GCArg->getAsString(Args); 1335 } 1336 } 1337 1338 if (Args.getLastArg(options::OPT_fapple_kext)) 1339 CmdArgs.push_back("-fapple-kext"); 1340 1341 Args.AddLastArg(CmdArgs, options::OPT_fno_show_column); 1342 Args.AddLastArg(CmdArgs, options::OPT_fobjc_sender_dependent_dispatch); 1343 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_print_source_range_info); 1344 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_parseable_fixits); 1345 Args.AddLastArg(CmdArgs, options::OPT_ftime_report); 1346 Args.AddLastArg(CmdArgs, options::OPT_ftrapv); 1347 1348 if (Arg *A = Args.getLastArg(options::OPT_ftrapv_handler_EQ)) { 1349 CmdArgs.push_back("-ftrapv-handler"); 1350 CmdArgs.push_back(A->getValue(Args)); 1351 } 1352 1353 Args.AddLastArg(CmdArgs, options::OPT_fwrapv); 1354 Args.AddLastArg(CmdArgs, options::OPT_fwritable_strings); 1355 Args.AddLastArg(CmdArgs, options::OPT_funroll_loops); 1356 1357 Args.AddLastArg(CmdArgs, options::OPT_pthread); 1358 1359 // -stack-protector=0 is default. 1360 unsigned StackProtectorLevel = 0; 1361 if (Arg *A = Args.getLastArg(options::OPT_fno_stack_protector, 1362 options::OPT_fstack_protector_all, 1363 options::OPT_fstack_protector)) { 1364 if (A->getOption().matches(options::OPT_fstack_protector)) 1365 StackProtectorLevel = 1; 1366 else if (A->getOption().matches(options::OPT_fstack_protector_all)) 1367 StackProtectorLevel = 2; 1368 } else 1369 StackProtectorLevel = getToolChain().GetDefaultStackProtectorLevel(); 1370 if (StackProtectorLevel) { 1371 CmdArgs.push_back("-stack-protector"); 1372 CmdArgs.push_back(Args.MakeArgString(llvm::Twine(StackProtectorLevel))); 1373 } 1374 1375 // Forward -f options with positive and negative forms; we translate 1376 // these by hand. 1377 1378 if (Args.hasArg(options::OPT_mkernel)) { 1379 if (!Args.hasArg(options::OPT_fapple_kext) && types::isCXX(InputType)) 1380 CmdArgs.push_back("-fapple-kext"); 1381 if (!Args.hasArg(options::OPT_fbuiltin)) 1382 CmdArgs.push_back("-fno-builtin"); 1383 } 1384 // -fbuiltin is default. 1385 else if (!Args.hasFlag(options::OPT_fbuiltin, options::OPT_fno_builtin)) 1386 CmdArgs.push_back("-fno-builtin"); 1387 1388 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new, 1389 options::OPT_fno_assume_sane_operator_new)) 1390 CmdArgs.push_back("-fno-assume-sane-operator-new"); 1391 1392 // -fblocks=0 is default. 1393 if (Args.hasFlag(options::OPT_fblocks, options::OPT_fno_blocks, 1394 getToolChain().IsBlocksDefault())) { 1395 CmdArgs.push_back("-fblocks"); 1396 } 1397 1398 // -faccess-control is default. 1399 if (Args.hasFlag(options::OPT_fno_access_control, 1400 options::OPT_faccess_control, 1401 false)) 1402 CmdArgs.push_back("-fno-access-control"); 1403 1404 // -felide-constructors is the default. 1405 if (Args.hasFlag(options::OPT_fno_elide_constructors, 1406 options::OPT_felide_constructors, 1407 false)) 1408 CmdArgs.push_back("-fno-elide-constructors"); 1409 1410 // -fexceptions=0 is default. 1411 if (!KernelOrKext && 1412 needsExceptions(Args, InputType, getToolChain().getTriple())) 1413 CmdArgs.push_back("-fexceptions"); 1414 1415 if (getToolChain().UseSjLjExceptions()) 1416 CmdArgs.push_back("-fsjlj-exceptions"); 1417 1418 // -frtti is default. 1419 if (KernelOrKext || 1420 !Args.hasFlag(options::OPT_frtti, options::OPT_fno_rtti)) 1421 CmdArgs.push_back("-fno-rtti"); 1422 1423 // -fshort-enums=0 is default. 1424 // FIXME: Are there targers where -fshort-enums is on by default ? 1425 if (Args.hasFlag(options::OPT_fshort_enums, 1426 options::OPT_fno_short_enums, false)) 1427 CmdArgs.push_back("-fshort-enums"); 1428 1429 // -fsigned-char is default. 1430 if (!Args.hasFlag(options::OPT_fsigned_char, options::OPT_funsigned_char, 1431 isSignedCharDefault(getToolChain().getTriple()))) 1432 CmdArgs.push_back("-fno-signed-char"); 1433 1434 // -fthreadsafe-static is default. 1435 if (!Args.hasFlag(options::OPT_fthreadsafe_statics, 1436 options::OPT_fno_threadsafe_statics)) 1437 CmdArgs.push_back("-fno-threadsafe-statics"); 1438 1439 // -fuse-cxa-atexit is default. 1440 if (KernelOrKext || 1441 !Args.hasFlag(options::OPT_fuse_cxa_atexit, options::OPT_fno_use_cxa_atexit, 1442 getToolChain().getTriple().getOS() != llvm::Triple::Cygwin && 1443 getToolChain().getTriple().getOS() != llvm::Triple::MinGW32 && 1444 getToolChain().getTriple().getOS() != llvm::Triple::MinGW64)) 1445 CmdArgs.push_back("-fno-use-cxa-atexit"); 1446 1447 // -fms-extensions=0 is default. 1448 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions, 1449 getToolChain().getTriple().getOS() == llvm::Triple::Win32)) 1450 CmdArgs.push_back("-fms-extensions"); 1451 1452 // -fmsc-version=1300 is default. 1453 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions, 1454 getToolChain().getTriple().getOS() == llvm::Triple::Win32) || 1455 Args.hasArg(options::OPT_fmsc_version)) { 1456 llvm::StringRef msc_ver = Args.getLastArgValue(options::OPT_fmsc_version); 1457 if (msc_ver.empty()) 1458 CmdArgs.push_back("-fmsc-version=1300"); 1459 else 1460 CmdArgs.push_back(Args.MakeArgString("-fmsc-version=" + msc_ver)); 1461 } 1462 1463 1464 // -fborland-extensions=0 is default. 1465 if (Args.hasFlag(options::OPT_fborland_extensions, 1466 options::OPT_fno_borland_extensions, false)) 1467 CmdArgs.push_back("-fborland-extensions"); 1468 1469 // -fgnu-keywords default varies depending on language; only pass if 1470 // specified. 1471 if (Arg *A = Args.getLastArg(options::OPT_fgnu_keywords, 1472 options::OPT_fno_gnu_keywords)) 1473 A->render(Args, CmdArgs); 1474 1475 // -fnext-runtime defaults to on Darwin and when rewriting Objective-C, and is 1476 // -the -cc1 default. 1477 bool NeXTRuntimeIsDefault = 1478 IsRewriter || getToolChain().getTriple().getOS() == llvm::Triple::Darwin; 1479 if (!Args.hasFlag(options::OPT_fnext_runtime, options::OPT_fgnu_runtime, 1480 NeXTRuntimeIsDefault)) 1481 CmdArgs.push_back("-fgnu-runtime"); 1482 1483 // -fobjc-nonfragile-abi=0 is default. 1484 if (types::isObjC(InputType)) { 1485 // Compute the Objective-C ABI "version" to use. Version numbers are 1486 // slightly confusing for historical reasons: 1487 // 1 - Traditional "fragile" ABI 1488 // 2 - Non-fragile ABI, version 1 1489 // 3 - Non-fragile ABI, version 2 1490 unsigned Version = 1; 1491 // If -fobjc-abi-version= is present, use that to set the version. 1492 if (Arg *A = Args.getLastArg(options::OPT_fobjc_abi_version_EQ)) { 1493 if (llvm::StringRef(A->getValue(Args)) == "1") 1494 Version = 1; 1495 else if (llvm::StringRef(A->getValue(Args)) == "2") 1496 Version = 2; 1497 else if (llvm::StringRef(A->getValue(Args)) == "3") 1498 Version = 3; 1499 else 1500 D.Diag(clang::diag::err_drv_clang_unsupported) << A->getAsString(Args); 1501 } else { 1502 // Otherwise, determine if we are using the non-fragile ABI. 1503 if (Args.hasFlag(options::OPT_fobjc_nonfragile_abi, 1504 options::OPT_fno_objc_nonfragile_abi, 1505 getToolChain().IsObjCNonFragileABIDefault())) { 1506 // Determine the non-fragile ABI version to use. 1507#ifdef DISABLE_DEFAULT_NONFRAGILEABI_TWO 1508 unsigned NonFragileABIVersion = 1; 1509#else 1510 unsigned NonFragileABIVersion = 2; 1511#endif 1512 1513 if (Arg *A = Args.getLastArg( 1514 options::OPT_fobjc_nonfragile_abi_version_EQ)) { 1515 if (llvm::StringRef(A->getValue(Args)) == "1") 1516 NonFragileABIVersion = 1; 1517 else if (llvm::StringRef(A->getValue(Args)) == "2") 1518 NonFragileABIVersion = 2; 1519 else 1520 D.Diag(clang::diag::err_drv_clang_unsupported) 1521 << A->getAsString(Args); 1522 } 1523 1524 Version = 1 + NonFragileABIVersion; 1525 } else { 1526 Version = 1; 1527 } 1528 } 1529 1530 if (Version == 2 || Version == 3) { 1531 CmdArgs.push_back("-fobjc-nonfragile-abi"); 1532 1533 // -fobjc-dispatch-method is only relevant with the nonfragile-abi, and 1534 // legacy is the default. 1535 if (!Args.hasFlag(options::OPT_fobjc_legacy_dispatch, 1536 options::OPT_fno_objc_legacy_dispatch, 1537 getToolChain().IsObjCLegacyDispatchDefault())) { 1538 if (getToolChain().UseObjCMixedDispatch()) 1539 CmdArgs.push_back("-fobjc-dispatch-method=mixed"); 1540 else 1541 CmdArgs.push_back("-fobjc-dispatch-method=non-legacy"); 1542 } 1543 } 1544 1545 // -fobjc-default-synthesize-properties=0 is default. 1546 if (Args.hasFlag(options::OPT_fobjc_default_synthesize_properties, 1547 options::OPT_fno_objc_default_synthesize_properties, 1548 getToolChain().IsObjCDefaultSynthPropertiesDefault())) { 1549 CmdArgs.push_back("-fobjc-default-synthesize-properties"); 1550 } 1551 } 1552 1553 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new, 1554 options::OPT_fno_assume_sane_operator_new)) 1555 CmdArgs.push_back("-fno-assume-sane-operator-new"); 1556 1557 // -fconstant-cfstrings is default, and may be subject to argument translation 1558 // on Darwin. 1559 if (!Args.hasFlag(options::OPT_fconstant_cfstrings, 1560 options::OPT_fno_constant_cfstrings) || 1561 !Args.hasFlag(options::OPT_mconstant_cfstrings, 1562 options::OPT_mno_constant_cfstrings)) 1563 CmdArgs.push_back("-fno-constant-cfstrings"); 1564 1565 // -fshort-wchar default varies depending on platform; only 1566 // pass if specified. 1567 if (Arg *A = Args.getLastArg(options::OPT_fshort_wchar)) 1568 A->render(Args, CmdArgs); 1569 1570 // -fno-pascal-strings is default, only pass non-default. If the tool chain 1571 // happened to translate to -mpascal-strings, we want to back translate here. 1572 // 1573 // FIXME: This is gross; that translation should be pulled from the 1574 // tool chain. 1575 if (Args.hasFlag(options::OPT_fpascal_strings, 1576 options::OPT_fno_pascal_strings, 1577 false) || 1578 Args.hasFlag(options::OPT_mpascal_strings, 1579 options::OPT_mno_pascal_strings, 1580 false)) 1581 CmdArgs.push_back("-fpascal-strings"); 1582 1583 if (Args.hasArg(options::OPT_mkernel) || 1584 Args.hasArg(options::OPT_fapple_kext)) { 1585 if (!Args.hasArg(options::OPT_fcommon)) 1586 CmdArgs.push_back("-fno-common"); 1587 } 1588 // -fcommon is default, only pass non-default. 1589 else if (!Args.hasFlag(options::OPT_fcommon, options::OPT_fno_common)) 1590 CmdArgs.push_back("-fno-common"); 1591 1592 // -fsigned-bitfields is default, and clang doesn't yet support 1593 // -funsigned-bitfields. 1594 if (!Args.hasFlag(options::OPT_fsigned_bitfields, 1595 options::OPT_funsigned_bitfields)) 1596 D.Diag(clang::diag::warn_drv_clang_unsupported) 1597 << Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args); 1598 1599 // -fsigned-bitfields is default, and clang doesn't support -fno-for-scope. 1600 if (!Args.hasFlag(options::OPT_ffor_scope, 1601 options::OPT_fno_for_scope)) 1602 D.Diag(clang::diag::err_drv_clang_unsupported) 1603 << Args.getLastArg(options::OPT_fno_for_scope)->getAsString(Args); 1604 1605 // -fcaret-diagnostics is default. 1606 if (!Args.hasFlag(options::OPT_fcaret_diagnostics, 1607 options::OPT_fno_caret_diagnostics, true)) 1608 CmdArgs.push_back("-fno-caret-diagnostics"); 1609 1610 // -fdiagnostics-fixit-info is default, only pass non-default. 1611 if (!Args.hasFlag(options::OPT_fdiagnostics_fixit_info, 1612 options::OPT_fno_diagnostics_fixit_info)) 1613 CmdArgs.push_back("-fno-diagnostics-fixit-info"); 1614 1615 // Enable -fdiagnostics-show-option by default. 1616 if (Args.hasFlag(options::OPT_fdiagnostics_show_option, 1617 options::OPT_fno_diagnostics_show_option)) 1618 CmdArgs.push_back("-fdiagnostics-show-option"); 1619 1620 if (const Arg *A = 1621 Args.getLastArg(options::OPT_fdiagnostics_show_category_EQ)) { 1622 CmdArgs.push_back("-fdiagnostics-show-category"); 1623 CmdArgs.push_back(A->getValue(Args)); 1624 } 1625 1626 // Color diagnostics are the default, unless the terminal doesn't support 1627 // them. 1628 if (Args.hasFlag(options::OPT_fcolor_diagnostics, 1629 options::OPT_fno_color_diagnostics, 1630 llvm::sys::Process::StandardErrHasColors())) 1631 CmdArgs.push_back("-fcolor-diagnostics"); 1632 1633 if (!Args.hasFlag(options::OPT_fshow_source_location, 1634 options::OPT_fno_show_source_location)) 1635 CmdArgs.push_back("-fno-show-source-location"); 1636 1637 if (!Args.hasFlag(options::OPT_fspell_checking, 1638 options::OPT_fno_spell_checking)) 1639 CmdArgs.push_back("-fno-spell-checking"); 1640 1641 1642 // Silently ignore -fasm-blocks for now. 1643 (void) Args.hasFlag(options::OPT_fasm_blocks, options::OPT_fno_asm_blocks, 1644 false); 1645 1646 if (Arg *A = Args.getLastArg(options::OPT_fshow_overloads_EQ)) 1647 A->render(Args, CmdArgs); 1648 1649 // -fdollars-in-identifiers default varies depending on platform and 1650 // language; only pass if specified. 1651 if (Arg *A = Args.getLastArg(options::OPT_fdollars_in_identifiers, 1652 options::OPT_fno_dollars_in_identifiers)) { 1653 if (A->getOption().matches(options::OPT_fdollars_in_identifiers)) 1654 CmdArgs.push_back("-fdollars-in-identifiers"); 1655 else 1656 CmdArgs.push_back("-fno-dollars-in-identifiers"); 1657 } 1658 1659 // -funit-at-a-time is default, and we don't support -fno-unit-at-a-time for 1660 // practical purposes. 1661 if (Arg *A = Args.getLastArg(options::OPT_funit_at_a_time, 1662 options::OPT_fno_unit_at_a_time)) { 1663 if (A->getOption().matches(options::OPT_fno_unit_at_a_time)) 1664 D.Diag(clang::diag::warn_drv_clang_unsupported) << A->getAsString(Args); 1665 } 1666 1667 // Default to -fno-builtin-str{cat,cpy} on Darwin for ARM. 1668 // 1669 // FIXME: This is disabled until clang -cc1 supports -fno-builtin-foo. PR4941. 1670#if 0 1671 if (getToolChain().getTriple().getOS() == llvm::Triple::Darwin && 1672 (getToolChain().getTriple().getArch() == llvm::Triple::arm || 1673 getToolChain().getTriple().getArch() == llvm::Triple::thumb)) { 1674 if (!Args.hasArg(options::OPT_fbuiltin_strcat)) 1675 CmdArgs.push_back("-fno-builtin-strcat"); 1676 if (!Args.hasArg(options::OPT_fbuiltin_strcpy)) 1677 CmdArgs.push_back("-fno-builtin-strcpy"); 1678 } 1679#endif 1680 1681 if (Arg *A = Args.getLastArg(options::OPT_traditional, 1682 options::OPT_traditional_cpp)) 1683 D.Diag(clang::diag::err_drv_clang_unsupported) << A->getAsString(Args); 1684 1685 Args.AddLastArg(CmdArgs, options::OPT_dM); 1686 Args.AddLastArg(CmdArgs, options::OPT_dD); 1687 1688 // Forward -Xclang arguments to -cc1, and -mllvm arguments to the LLVM option 1689 // parser. 1690 Args.AddAllArgValues(CmdArgs, options::OPT_Xclang); 1691 for (arg_iterator it = Args.filtered_begin(options::OPT_mllvm), 1692 ie = Args.filtered_end(); it != ie; ++it) { 1693 (*it)->claim(); 1694 1695 // We translate this by hand to the -cc1 argument, since nightly test uses 1696 // it and developers have been trained to spell it with -mllvm. 1697 if (llvm::StringRef((*it)->getValue(Args, 0)) == "-disable-llvm-optzns") 1698 CmdArgs.push_back("-disable-llvm-optzns"); 1699 else 1700 (*it)->render(Args, CmdArgs); 1701 } 1702 1703 if (Output.getType() == types::TY_Dependencies) { 1704 // Handled with other dependency code. 1705 } else if (Output.isFilename()) { 1706 CmdArgs.push_back("-o"); 1707 CmdArgs.push_back(Output.getFilename()); 1708 } else { 1709 assert(Output.isNothing() && "Invalid output."); 1710 } 1711 1712 for (InputInfoList::const_iterator 1713 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 1714 const InputInfo &II = *it; 1715 CmdArgs.push_back("-x"); 1716 CmdArgs.push_back(types::getTypeName(II.getType())); 1717 if (II.isFilename()) 1718 CmdArgs.push_back(II.getFilename()); 1719 else 1720 II.getInputArg().renderAsInput(Args, CmdArgs); 1721 } 1722 1723 Args.AddAllArgs(CmdArgs, options::OPT_undef); 1724 1725 const char *Exec = getToolChain().getDriver().getClangProgramPath(); 1726 1727 // Optionally embed the -cc1 level arguments into the debug info, for build 1728 // analysis. 1729 if (getToolChain().UseDwarfDebugFlags()) { 1730 ArgStringList OriginalArgs; 1731 for (ArgList::const_iterator it = Args.begin(), 1732 ie = Args.end(); it != ie; ++it) 1733 (*it)->render(Args, OriginalArgs); 1734 1735 llvm::SmallString<256> Flags; 1736 Flags += Exec; 1737 for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) { 1738 Flags += " "; 1739 Flags += OriginalArgs[i]; 1740 } 1741 CmdArgs.push_back("-dwarf-debug-flags"); 1742 CmdArgs.push_back(Args.MakeArgString(Flags.str())); 1743 } 1744 1745 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 1746 1747 if (Arg *A = Args.getLastArg(options::OPT_pg)) 1748 if (Args.hasArg(options::OPT_fomit_frame_pointer)) 1749 D.Diag(clang::diag::err_drv_argument_not_allowed_with) 1750 << "-fomit-frame-pointer" << A->getAsString(Args); 1751 1752 // Claim some arguments which clang supports automatically. 1753 1754 // -fpch-preprocess is used with gcc to add a special marker in the output to 1755 // include the PCH file. Clang's PTH solution is completely transparent, so we 1756 // do not need to deal with it at all. 1757 Args.ClaimAllArgs(options::OPT_fpch_preprocess); 1758 1759 // Claim some arguments which clang doesn't support, but we don't 1760 // care to warn the user about. 1761 Args.ClaimAllArgs(options::OPT_clang_ignored_f_Group); 1762 Args.ClaimAllArgs(options::OPT_clang_ignored_m_Group); 1763} 1764 1765void ClangAs::ConstructJob(Compilation &C, const JobAction &JA, 1766 const InputInfo &Output, 1767 const InputInfoList &Inputs, 1768 const ArgList &Args, 1769 const char *LinkingOutput) const { 1770 ArgStringList CmdArgs; 1771 1772 assert(Inputs.size() == 1 && "Unexpected number of inputs."); 1773 const InputInfo &Input = Inputs[0]; 1774 1775 // Don't warn about "clang -w -c foo.s" 1776 Args.ClaimAllArgs(options::OPT_w); 1777 1778 // Invoke ourselves in -cc1as mode. 1779 // 1780 // FIXME: Implement custom jobs for internal actions. 1781 CmdArgs.push_back("-cc1as"); 1782 1783 // Add the "effective" target triple. 1784 CmdArgs.push_back("-triple"); 1785 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args); 1786 CmdArgs.push_back(Args.MakeArgString(TripleStr)); 1787 1788 // Set the output mode, we currently only expect to be used as a real 1789 // assembler. 1790 CmdArgs.push_back("-filetype"); 1791 CmdArgs.push_back("obj"); 1792 1793 // At -O0, we use -mrelax-all by default. 1794 bool IsOpt = false; 1795 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) 1796 IsOpt = !A->getOption().matches(options::OPT_O0); 1797 if (Args.hasFlag(options::OPT_mrelax_all, 1798 options::OPT_mno_relax_all, 1799 !IsOpt)) 1800 CmdArgs.push_back("-relax-all"); 1801 1802 // FIXME: Add -force_cpusubtype_ALL support, once we have it. 1803 1804 // FIXME: Add -g support, once we have it. 1805 1806 // FIXME: Add -static support, once we have it. 1807 1808 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, 1809 options::OPT_Xassembler); 1810 1811 assert(Output.isFilename() && "Unexpected lipo output."); 1812 CmdArgs.push_back("-o"); 1813 CmdArgs.push_back(Output.getFilename()); 1814 1815 assert(Input.isFilename() && "Invalid input."); 1816 CmdArgs.push_back(Input.getFilename()); 1817 1818 const char *Exec = getToolChain().getDriver().getClangProgramPath(); 1819 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 1820} 1821 1822void gcc::Common::ConstructJob(Compilation &C, const JobAction &JA, 1823 const InputInfo &Output, 1824 const InputInfoList &Inputs, 1825 const ArgList &Args, 1826 const char *LinkingOutput) const { 1827 const Driver &D = getToolChain().getDriver(); 1828 ArgStringList CmdArgs; 1829 1830 for (ArgList::const_iterator 1831 it = Args.begin(), ie = Args.end(); it != ie; ++it) { 1832 Arg *A = *it; 1833 if (A->getOption().hasForwardToGCC()) { 1834 // Don't forward any -g arguments to assembly steps. 1835 if (isa<AssembleJobAction>(JA) && 1836 A->getOption().matches(options::OPT_g_Group)) 1837 continue; 1838 1839 // It is unfortunate that we have to claim here, as this means 1840 // we will basically never report anything interesting for 1841 // platforms using a generic gcc, even if we are just using gcc 1842 // to get to the assembler. 1843 A->claim(); 1844 A->render(Args, CmdArgs); 1845 } 1846 } 1847 1848 RenderExtraToolArgs(JA, CmdArgs); 1849 1850 // If using a driver driver, force the arch. 1851 const std::string &Arch = getToolChain().getArchName(); 1852 if (getToolChain().getTriple().getOS() == llvm::Triple::Darwin) { 1853 CmdArgs.push_back("-arch"); 1854 1855 // FIXME: Remove these special cases. 1856 if (Arch == "powerpc") 1857 CmdArgs.push_back("ppc"); 1858 else if (Arch == "powerpc64") 1859 CmdArgs.push_back("ppc64"); 1860 else 1861 CmdArgs.push_back(Args.MakeArgString(Arch)); 1862 } 1863 1864 // Try to force gcc to match the tool chain we want, if we recognize 1865 // the arch. 1866 // 1867 // FIXME: The triple class should directly provide the information we want 1868 // here. 1869 if (Arch == "i386" || Arch == "powerpc") 1870 CmdArgs.push_back("-m32"); 1871 else if (Arch == "x86_64" || Arch == "powerpc64") 1872 CmdArgs.push_back("-m64"); 1873 1874 if (Output.isFilename()) { 1875 CmdArgs.push_back("-o"); 1876 CmdArgs.push_back(Output.getFilename()); 1877 } else { 1878 assert(Output.isNothing() && "Unexpected output"); 1879 CmdArgs.push_back("-fsyntax-only"); 1880 } 1881 1882 1883 // Only pass -x if gcc will understand it; otherwise hope gcc 1884 // understands the suffix correctly. The main use case this would go 1885 // wrong in is for linker inputs if they happened to have an odd 1886 // suffix; really the only way to get this to happen is a command 1887 // like '-x foobar a.c' which will treat a.c like a linker input. 1888 // 1889 // FIXME: For the linker case specifically, can we safely convert 1890 // inputs into '-Wl,' options? 1891 for (InputInfoList::const_iterator 1892 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 1893 const InputInfo &II = *it; 1894 1895 // Don't try to pass LLVM or AST inputs to a generic gcc. 1896 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR || 1897 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC) 1898 D.Diag(clang::diag::err_drv_no_linker_llvm_support) 1899 << getToolChain().getTripleString(); 1900 else if (II.getType() == types::TY_AST) 1901 D.Diag(clang::diag::err_drv_no_ast_support) 1902 << getToolChain().getTripleString(); 1903 1904 if (types::canTypeBeUserSpecified(II.getType())) { 1905 CmdArgs.push_back("-x"); 1906 CmdArgs.push_back(types::getTypeName(II.getType())); 1907 } 1908 1909 if (II.isFilename()) 1910 CmdArgs.push_back(II.getFilename()); 1911 else { 1912 const Arg &A = II.getInputArg(); 1913 1914 // Reverse translate some rewritten options. 1915 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) { 1916 CmdArgs.push_back("-lstdc++"); 1917 continue; 1918 } 1919 1920 // Don't render as input, we need gcc to do the translations. 1921 A.render(Args, CmdArgs); 1922 } 1923 } 1924 1925 const char *GCCName = getToolChain().getDriver().getCCCGenericGCCName().c_str(); 1926 const char *Exec = 1927 Args.MakeArgString(getToolChain().GetProgramPath(GCCName)); 1928 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 1929} 1930 1931void gcc::Preprocess::RenderExtraToolArgs(const JobAction &JA, 1932 ArgStringList &CmdArgs) const { 1933 CmdArgs.push_back("-E"); 1934} 1935 1936void gcc::Precompile::RenderExtraToolArgs(const JobAction &JA, 1937 ArgStringList &CmdArgs) const { 1938 // The type is good enough. 1939} 1940 1941void gcc::Compile::RenderExtraToolArgs(const JobAction &JA, 1942 ArgStringList &CmdArgs) const { 1943 const Driver &D = getToolChain().getDriver(); 1944 1945 // If -flto, etc. are present then make sure not to force assembly output. 1946 if (JA.getType() == types::TY_LLVM_IR || JA.getType() == types::TY_LTO_IR || 1947 JA.getType() == types::TY_LLVM_BC || JA.getType() == types::TY_LTO_BC) 1948 CmdArgs.push_back("-c"); 1949 else { 1950 if (JA.getType() != types::TY_PP_Asm) 1951 D.Diag(clang::diag::err_drv_invalid_gcc_output_type) 1952 << getTypeName(JA.getType()); 1953 1954 CmdArgs.push_back("-S"); 1955 } 1956} 1957 1958void gcc::Assemble::RenderExtraToolArgs(const JobAction &JA, 1959 ArgStringList &CmdArgs) const { 1960 CmdArgs.push_back("-c"); 1961} 1962 1963void gcc::Link::RenderExtraToolArgs(const JobAction &JA, 1964 ArgStringList &CmdArgs) const { 1965 // The types are (hopefully) good enough. 1966} 1967 1968const char *darwin::CC1::getCC1Name(types::ID Type) const { 1969 switch (Type) { 1970 default: 1971 assert(0 && "Unexpected type for Darwin CC1 tool."); 1972 case types::TY_Asm: 1973 case types::TY_C: case types::TY_CHeader: 1974 case types::TY_PP_C: case types::TY_PP_CHeader: 1975 return "cc1"; 1976 case types::TY_ObjC: case types::TY_ObjCHeader: 1977 case types::TY_PP_ObjC: case types::TY_PP_ObjCHeader: 1978 return "cc1obj"; 1979 case types::TY_CXX: case types::TY_CXXHeader: 1980 case types::TY_PP_CXX: case types::TY_PP_CXXHeader: 1981 return "cc1plus"; 1982 case types::TY_ObjCXX: case types::TY_ObjCXXHeader: 1983 case types::TY_PP_ObjCXX: case types::TY_PP_ObjCXXHeader: 1984 return "cc1objplus"; 1985 } 1986} 1987 1988const char *darwin::CC1::getBaseInputName(const ArgList &Args, 1989 const InputInfoList &Inputs) { 1990 return Args.MakeArgString( 1991 llvm::sys::path::filename(Inputs[0].getBaseInput())); 1992} 1993 1994const char *darwin::CC1::getBaseInputStem(const ArgList &Args, 1995 const InputInfoList &Inputs) { 1996 const char *Str = getBaseInputName(Args, Inputs); 1997 1998 if (const char *End = strrchr(Str, '.')) 1999 return Args.MakeArgString(std::string(Str, End)); 2000 2001 return Str; 2002} 2003 2004const char * 2005darwin::CC1::getDependencyFileName(const ArgList &Args, 2006 const InputInfoList &Inputs) { 2007 // FIXME: Think about this more. 2008 std::string Res; 2009 2010 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) { 2011 std::string Str(OutputOpt->getValue(Args)); 2012 2013 Res = Str.substr(0, Str.rfind('.')); 2014 } else 2015 Res = darwin::CC1::getBaseInputStem(Args, Inputs); 2016 2017 return Args.MakeArgString(Res + ".d"); 2018} 2019 2020void darwin::CC1::AddCC1Args(const ArgList &Args, 2021 ArgStringList &CmdArgs) const { 2022 const Driver &D = getToolChain().getDriver(); 2023 2024 CheckCodeGenerationOptions(D, Args); 2025 2026 // Derived from cc1 spec. 2027 if (!Args.hasArg(options::OPT_mkernel) && !Args.hasArg(options::OPT_static) && 2028 !Args.hasArg(options::OPT_mdynamic_no_pic)) 2029 CmdArgs.push_back("-fPIC"); 2030 2031 if (getToolChain().getTriple().getArch() == llvm::Triple::arm || 2032 getToolChain().getTriple().getArch() == llvm::Triple::thumb) { 2033 if (!Args.hasArg(options::OPT_fbuiltin_strcat)) 2034 CmdArgs.push_back("-fno-builtin-strcat"); 2035 if (!Args.hasArg(options::OPT_fbuiltin_strcpy)) 2036 CmdArgs.push_back("-fno-builtin-strcpy"); 2037 } 2038 2039 // gcc has some code here to deal with when no -mmacosx-version-min 2040 // and no -miphoneos-version-min is present, but this never happens 2041 // due to tool chain specific argument translation. 2042 2043 if (Args.hasArg(options::OPT_g_Flag) && 2044 !Args.hasArg(options::OPT_fno_eliminate_unused_debug_symbols)) 2045 CmdArgs.push_back("-feliminate-unused-debug-symbols"); 2046} 2047 2048void darwin::CC1::AddCC1OptionsArgs(const ArgList &Args, ArgStringList &CmdArgs, 2049 const InputInfoList &Inputs, 2050 const ArgStringList &OutputArgs) const { 2051 const Driver &D = getToolChain().getDriver(); 2052 2053 // Derived from cc1_options spec. 2054 if (Args.hasArg(options::OPT_fast) || 2055 Args.hasArg(options::OPT_fastf) || 2056 Args.hasArg(options::OPT_fastcp)) 2057 CmdArgs.push_back("-O3"); 2058 2059 if (Arg *A = Args.getLastArg(options::OPT_pg)) 2060 if (Args.hasArg(options::OPT_fomit_frame_pointer)) 2061 D.Diag(clang::diag::err_drv_argument_not_allowed_with) 2062 << A->getAsString(Args) << "-fomit-frame-pointer"; 2063 2064 AddCC1Args(Args, CmdArgs); 2065 2066 if (!Args.hasArg(options::OPT_Q)) 2067 CmdArgs.push_back("-quiet"); 2068 2069 CmdArgs.push_back("-dumpbase"); 2070 CmdArgs.push_back(darwin::CC1::getBaseInputName(Args, Inputs)); 2071 2072 Args.AddAllArgs(CmdArgs, options::OPT_d_Group); 2073 2074 Args.AddAllArgs(CmdArgs, options::OPT_m_Group); 2075 Args.AddAllArgs(CmdArgs, options::OPT_a_Group); 2076 2077 // FIXME: The goal is to use the user provided -o if that is our 2078 // final output, otherwise to drive from the original input 2079 // name. Find a clean way to go about this. 2080 if ((Args.hasArg(options::OPT_c) || Args.hasArg(options::OPT_S)) && 2081 Args.hasArg(options::OPT_o)) { 2082 Arg *OutputOpt = Args.getLastArg(options::OPT_o); 2083 CmdArgs.push_back("-auxbase-strip"); 2084 CmdArgs.push_back(OutputOpt->getValue(Args)); 2085 } else { 2086 CmdArgs.push_back("-auxbase"); 2087 CmdArgs.push_back(darwin::CC1::getBaseInputStem(Args, Inputs)); 2088 } 2089 2090 Args.AddAllArgs(CmdArgs, options::OPT_g_Group); 2091 2092 Args.AddAllArgs(CmdArgs, options::OPT_O); 2093 // FIXME: -Wall is getting some special treatment. Investigate. 2094 Args.AddAllArgs(CmdArgs, options::OPT_W_Group, options::OPT_pedantic_Group); 2095 Args.AddLastArg(CmdArgs, options::OPT_w); 2096 Args.AddAllArgs(CmdArgs, options::OPT_std_EQ, options::OPT_ansi, 2097 options::OPT_trigraphs); 2098 if (!Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) { 2099 // Honor -std-default. 2100 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ, 2101 "-std=", /*Joined=*/true); 2102 } 2103 2104 if (Args.hasArg(options::OPT_v)) 2105 CmdArgs.push_back("-version"); 2106 if (Args.hasArg(options::OPT_pg)) 2107 CmdArgs.push_back("-p"); 2108 Args.AddLastArg(CmdArgs, options::OPT_p); 2109 2110 // The driver treats -fsyntax-only specially. 2111 if (getToolChain().getTriple().getArch() == llvm::Triple::arm || 2112 getToolChain().getTriple().getArch() == llvm::Triple::thumb) { 2113 // Removes -fbuiltin-str{cat,cpy}; these aren't recognized by cc1 but are 2114 // used to inhibit the default -fno-builtin-str{cat,cpy}. 2115 // 2116 // FIXME: Should we grow a better way to deal with "removing" args? 2117 for (arg_iterator it = Args.filtered_begin(options::OPT_f_Group, 2118 options::OPT_fsyntax_only), 2119 ie = Args.filtered_end(); it != ie; ++it) { 2120 if (!(*it)->getOption().matches(options::OPT_fbuiltin_strcat) && 2121 !(*it)->getOption().matches(options::OPT_fbuiltin_strcpy)) { 2122 (*it)->claim(); 2123 (*it)->render(Args, CmdArgs); 2124 } 2125 } 2126 } else 2127 Args.AddAllArgs(CmdArgs, options::OPT_f_Group, options::OPT_fsyntax_only); 2128 2129 Args.AddAllArgs(CmdArgs, options::OPT_undef); 2130 if (Args.hasArg(options::OPT_Qn)) 2131 CmdArgs.push_back("-fno-ident"); 2132 2133 // FIXME: This isn't correct. 2134 //Args.AddLastArg(CmdArgs, options::OPT__help) 2135 //Args.AddLastArg(CmdArgs, options::OPT__targetHelp) 2136 2137 CmdArgs.append(OutputArgs.begin(), OutputArgs.end()); 2138 2139 // FIXME: Still don't get what is happening here. Investigate. 2140 Args.AddAllArgs(CmdArgs, options::OPT__param); 2141 2142 if (Args.hasArg(options::OPT_fmudflap) || 2143 Args.hasArg(options::OPT_fmudflapth)) { 2144 CmdArgs.push_back("-fno-builtin"); 2145 CmdArgs.push_back("-fno-merge-constants"); 2146 } 2147 2148 if (Args.hasArg(options::OPT_coverage)) { 2149 CmdArgs.push_back("-fprofile-arcs"); 2150 CmdArgs.push_back("-ftest-coverage"); 2151 } 2152 2153 if (types::isCXX(Inputs[0].getType())) 2154 CmdArgs.push_back("-D__private_extern__=extern"); 2155} 2156 2157void darwin::CC1::AddCPPOptionsArgs(const ArgList &Args, ArgStringList &CmdArgs, 2158 const InputInfoList &Inputs, 2159 const ArgStringList &OutputArgs) const { 2160 // Derived from cpp_options 2161 AddCPPUniqueOptionsArgs(Args, CmdArgs, Inputs); 2162 2163 CmdArgs.append(OutputArgs.begin(), OutputArgs.end()); 2164 2165 AddCC1Args(Args, CmdArgs); 2166 2167 // NOTE: The code below has some commonality with cpp_options, but 2168 // in classic gcc style ends up sending things in different 2169 // orders. This may be a good merge candidate once we drop pedantic 2170 // compatibility. 2171 2172 Args.AddAllArgs(CmdArgs, options::OPT_m_Group); 2173 Args.AddAllArgs(CmdArgs, options::OPT_std_EQ, options::OPT_ansi, 2174 options::OPT_trigraphs); 2175 if (!Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) { 2176 // Honor -std-default. 2177 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ, 2178 "-std=", /*Joined=*/true); 2179 } 2180 Args.AddAllArgs(CmdArgs, options::OPT_W_Group, options::OPT_pedantic_Group); 2181 Args.AddLastArg(CmdArgs, options::OPT_w); 2182 2183 // The driver treats -fsyntax-only specially. 2184 Args.AddAllArgs(CmdArgs, options::OPT_f_Group, options::OPT_fsyntax_only); 2185 2186 if (Args.hasArg(options::OPT_g_Group) && !Args.hasArg(options::OPT_g0) && 2187 !Args.hasArg(options::OPT_fno_working_directory)) 2188 CmdArgs.push_back("-fworking-directory"); 2189 2190 Args.AddAllArgs(CmdArgs, options::OPT_O); 2191 Args.AddAllArgs(CmdArgs, options::OPT_undef); 2192 if (Args.hasArg(options::OPT_save_temps)) 2193 CmdArgs.push_back("-fpch-preprocess"); 2194} 2195 2196void darwin::CC1::AddCPPUniqueOptionsArgs(const ArgList &Args, 2197 ArgStringList &CmdArgs, 2198 const InputInfoList &Inputs) const { 2199 const Driver &D = getToolChain().getDriver(); 2200 2201 CheckPreprocessingOptions(D, Args); 2202 2203 // Derived from cpp_unique_options. 2204 // -{C,CC} only with -E is checked in CheckPreprocessingOptions(). 2205 Args.AddLastArg(CmdArgs, options::OPT_C); 2206 Args.AddLastArg(CmdArgs, options::OPT_CC); 2207 if (!Args.hasArg(options::OPT_Q)) 2208 CmdArgs.push_back("-quiet"); 2209 Args.AddAllArgs(CmdArgs, options::OPT_nostdinc); 2210 Args.AddAllArgs(CmdArgs, options::OPT_nostdincxx); 2211 Args.AddLastArg(CmdArgs, options::OPT_v); 2212 Args.AddAllArgs(CmdArgs, options::OPT_I_Group, options::OPT_F); 2213 Args.AddLastArg(CmdArgs, options::OPT_P); 2214 2215 // FIXME: Handle %I properly. 2216 if (getToolChain().getArchName() == "x86_64") { 2217 CmdArgs.push_back("-imultilib"); 2218 CmdArgs.push_back("x86_64"); 2219 } 2220 2221 if (Args.hasArg(options::OPT_MD)) { 2222 CmdArgs.push_back("-MD"); 2223 CmdArgs.push_back(darwin::CC1::getDependencyFileName(Args, Inputs)); 2224 } 2225 2226 if (Args.hasArg(options::OPT_MMD)) { 2227 CmdArgs.push_back("-MMD"); 2228 CmdArgs.push_back(darwin::CC1::getDependencyFileName(Args, Inputs)); 2229 } 2230 2231 Args.AddLastArg(CmdArgs, options::OPT_M); 2232 Args.AddLastArg(CmdArgs, options::OPT_MM); 2233 Args.AddAllArgs(CmdArgs, options::OPT_MF); 2234 Args.AddLastArg(CmdArgs, options::OPT_MG); 2235 Args.AddLastArg(CmdArgs, options::OPT_MP); 2236 Args.AddAllArgs(CmdArgs, options::OPT_MQ); 2237 Args.AddAllArgs(CmdArgs, options::OPT_MT); 2238 if (!Args.hasArg(options::OPT_M) && !Args.hasArg(options::OPT_MM) && 2239 (Args.hasArg(options::OPT_MD) || Args.hasArg(options::OPT_MMD))) { 2240 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) { 2241 CmdArgs.push_back("-MQ"); 2242 CmdArgs.push_back(OutputOpt->getValue(Args)); 2243 } 2244 } 2245 2246 Args.AddLastArg(CmdArgs, options::OPT_remap); 2247 if (Args.hasArg(options::OPT_g3)) 2248 CmdArgs.push_back("-dD"); 2249 Args.AddLastArg(CmdArgs, options::OPT_H); 2250 2251 AddCPPArgs(Args, CmdArgs); 2252 2253 Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U, options::OPT_A); 2254 Args.AddAllArgs(CmdArgs, options::OPT_i_Group); 2255 2256 for (InputInfoList::const_iterator 2257 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 2258 const InputInfo &II = *it; 2259 2260 CmdArgs.push_back(II.getFilename()); 2261 } 2262 2263 Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA, 2264 options::OPT_Xpreprocessor); 2265 2266 if (Args.hasArg(options::OPT_fmudflap)) { 2267 CmdArgs.push_back("-D_MUDFLAP"); 2268 CmdArgs.push_back("-include"); 2269 CmdArgs.push_back("mf-runtime.h"); 2270 } 2271 2272 if (Args.hasArg(options::OPT_fmudflapth)) { 2273 CmdArgs.push_back("-D_MUDFLAP"); 2274 CmdArgs.push_back("-D_MUDFLAPTH"); 2275 CmdArgs.push_back("-include"); 2276 CmdArgs.push_back("mf-runtime.h"); 2277 } 2278} 2279 2280void darwin::CC1::AddCPPArgs(const ArgList &Args, 2281 ArgStringList &CmdArgs) const { 2282 // Derived from cpp spec. 2283 2284 if (Args.hasArg(options::OPT_static)) { 2285 // The gcc spec is broken here, it refers to dynamic but 2286 // that has been translated. Start by being bug compatible. 2287 2288 // if (!Args.hasArg(arglist.parser.dynamicOption)) 2289 CmdArgs.push_back("-D__STATIC__"); 2290 } else 2291 CmdArgs.push_back("-D__DYNAMIC__"); 2292 2293 if (Args.hasArg(options::OPT_pthread)) 2294 CmdArgs.push_back("-D_REENTRANT"); 2295} 2296 2297void darwin::Preprocess::ConstructJob(Compilation &C, const JobAction &JA, 2298 const InputInfo &Output, 2299 const InputInfoList &Inputs, 2300 const ArgList &Args, 2301 const char *LinkingOutput) const { 2302 ArgStringList CmdArgs; 2303 2304 assert(Inputs.size() == 1 && "Unexpected number of inputs!"); 2305 2306 CmdArgs.push_back("-E"); 2307 2308 if (Args.hasArg(options::OPT_traditional) || 2309 Args.hasArg(options::OPT_traditional_cpp)) 2310 CmdArgs.push_back("-traditional-cpp"); 2311 2312 ArgStringList OutputArgs; 2313 assert(Output.isFilename() && "Unexpected CC1 output."); 2314 OutputArgs.push_back("-o"); 2315 OutputArgs.push_back(Output.getFilename()); 2316 2317 if (Args.hasArg(options::OPT_E)) { 2318 AddCPPOptionsArgs(Args, CmdArgs, Inputs, OutputArgs); 2319 } else { 2320 AddCPPOptionsArgs(Args, CmdArgs, Inputs, ArgStringList()); 2321 CmdArgs.append(OutputArgs.begin(), OutputArgs.end()); 2322 } 2323 2324 Args.AddAllArgs(CmdArgs, options::OPT_d_Group); 2325 2326 const char *CC1Name = getCC1Name(Inputs[0].getType()); 2327 const char *Exec = 2328 Args.MakeArgString(getToolChain().GetProgramPath(CC1Name)); 2329 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 2330} 2331 2332void darwin::Compile::ConstructJob(Compilation &C, const JobAction &JA, 2333 const InputInfo &Output, 2334 const InputInfoList &Inputs, 2335 const ArgList &Args, 2336 const char *LinkingOutput) const { 2337 const Driver &D = getToolChain().getDriver(); 2338 ArgStringList CmdArgs; 2339 2340 assert(Inputs.size() == 1 && "Unexpected number of inputs!"); 2341 2342 types::ID InputType = Inputs[0].getType(); 2343 const Arg *A; 2344 if ((A = Args.getLastArg(options::OPT_traditional))) 2345 D.Diag(clang::diag::err_drv_argument_only_allowed_with) 2346 << A->getAsString(Args) << "-E"; 2347 2348 if (JA.getType() == types::TY_LLVM_IR || 2349 JA.getType() == types::TY_LTO_IR) 2350 CmdArgs.push_back("-emit-llvm"); 2351 else if (JA.getType() == types::TY_LLVM_BC || 2352 JA.getType() == types::TY_LTO_BC) 2353 CmdArgs.push_back("-emit-llvm-bc"); 2354 else if (Output.getType() == types::TY_AST) 2355 D.Diag(clang::diag::err_drv_no_ast_support) 2356 << getToolChain().getTripleString(); 2357 else if (JA.getType() != types::TY_PP_Asm && 2358 JA.getType() != types::TY_PCH) 2359 D.Diag(clang::diag::err_drv_invalid_gcc_output_type) 2360 << getTypeName(JA.getType()); 2361 2362 ArgStringList OutputArgs; 2363 if (Output.getType() != types::TY_PCH) { 2364 OutputArgs.push_back("-o"); 2365 if (Output.isNothing()) 2366 OutputArgs.push_back("/dev/null"); 2367 else 2368 OutputArgs.push_back(Output.getFilename()); 2369 } 2370 2371 // There is no need for this level of compatibility, but it makes 2372 // diffing easier. 2373 bool OutputArgsEarly = (Args.hasArg(options::OPT_fsyntax_only) || 2374 Args.hasArg(options::OPT_S)); 2375 2376 if (types::getPreprocessedType(InputType) != types::TY_INVALID) { 2377 AddCPPUniqueOptionsArgs(Args, CmdArgs, Inputs); 2378 if (OutputArgsEarly) { 2379 AddCC1OptionsArgs(Args, CmdArgs, Inputs, OutputArgs); 2380 } else { 2381 AddCC1OptionsArgs(Args, CmdArgs, Inputs, ArgStringList()); 2382 CmdArgs.append(OutputArgs.begin(), OutputArgs.end()); 2383 } 2384 } else { 2385 CmdArgs.push_back("-fpreprocessed"); 2386 2387 for (InputInfoList::const_iterator 2388 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 2389 const InputInfo &II = *it; 2390 2391 // Reject AST inputs. 2392 if (II.getType() == types::TY_AST) { 2393 D.Diag(clang::diag::err_drv_no_ast_support) 2394 << getToolChain().getTripleString(); 2395 return; 2396 } 2397 2398 CmdArgs.push_back(II.getFilename()); 2399 } 2400 2401 if (OutputArgsEarly) { 2402 AddCC1OptionsArgs(Args, CmdArgs, Inputs, OutputArgs); 2403 } else { 2404 AddCC1OptionsArgs(Args, CmdArgs, Inputs, ArgStringList()); 2405 CmdArgs.append(OutputArgs.begin(), OutputArgs.end()); 2406 } 2407 } 2408 2409 if (Output.getType() == types::TY_PCH) { 2410 assert(Output.isFilename() && "Invalid PCH output."); 2411 2412 CmdArgs.push_back("-o"); 2413 // NOTE: gcc uses a temp .s file for this, but there doesn't seem 2414 // to be a good reason. 2415 CmdArgs.push_back("/dev/null"); 2416 2417 CmdArgs.push_back("--output-pch="); 2418 CmdArgs.push_back(Output.getFilename()); 2419 } 2420 2421 const char *CC1Name = getCC1Name(Inputs[0].getType()); 2422 const char *Exec = 2423 Args.MakeArgString(getToolChain().GetProgramPath(CC1Name)); 2424 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 2425} 2426 2427void darwin::Assemble::ConstructJob(Compilation &C, const JobAction &JA, 2428 const InputInfo &Output, 2429 const InputInfoList &Inputs, 2430 const ArgList &Args, 2431 const char *LinkingOutput) const { 2432 ArgStringList CmdArgs; 2433 2434 assert(Inputs.size() == 1 && "Unexpected number of inputs."); 2435 const InputInfo &Input = Inputs[0]; 2436 2437 // Bit of a hack, this is only used for original inputs. 2438 // 2439 // FIXME: This is broken for preprocessed .s inputs. 2440 if (Input.isFilename() && 2441 strcmp(Input.getFilename(), Input.getBaseInput()) == 0) { 2442 if (Args.hasArg(options::OPT_gstabs)) 2443 CmdArgs.push_back("--gstabs"); 2444 else if (Args.hasArg(options::OPT_g_Group)) 2445 CmdArgs.push_back("--gdwarf2"); 2446 } 2447 2448 // Derived from asm spec. 2449 AddDarwinArch(Args, CmdArgs); 2450 2451 // Use -force_cpusubtype_ALL on x86 by default. 2452 if (getToolChain().getTriple().getArch() == llvm::Triple::x86 || 2453 getToolChain().getTriple().getArch() == llvm::Triple::x86_64 || 2454 Args.hasArg(options::OPT_force__cpusubtype__ALL)) 2455 CmdArgs.push_back("-force_cpusubtype_ALL"); 2456 2457 if (getToolChain().getTriple().getArch() != llvm::Triple::x86_64 && 2458 (Args.hasArg(options::OPT_mkernel) || 2459 Args.hasArg(options::OPT_static) || 2460 Args.hasArg(options::OPT_fapple_kext))) 2461 CmdArgs.push_back("-static"); 2462 2463 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, 2464 options::OPT_Xassembler); 2465 2466 assert(Output.isFilename() && "Unexpected lipo output."); 2467 CmdArgs.push_back("-o"); 2468 CmdArgs.push_back(Output.getFilename()); 2469 2470 assert(Input.isFilename() && "Invalid input."); 2471 CmdArgs.push_back(Input.getFilename()); 2472 2473 // asm_final spec is empty. 2474 2475 const char *Exec = 2476 Args.MakeArgString(getToolChain().GetProgramPath("as")); 2477 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 2478} 2479 2480void darwin::DarwinTool::AddDarwinArch(const ArgList &Args, 2481 ArgStringList &CmdArgs) const { 2482 llvm::StringRef ArchName = getDarwinToolChain().getDarwinArchName(Args); 2483 2484 // Derived from darwin_arch spec. 2485 CmdArgs.push_back("-arch"); 2486 CmdArgs.push_back(Args.MakeArgString(ArchName)); 2487 2488 // FIXME: Is this needed anymore? 2489 if (ArchName == "arm") 2490 CmdArgs.push_back("-force_cpusubtype_ALL"); 2491} 2492 2493void darwin::Link::AddLinkArgs(Compilation &C, 2494 const ArgList &Args, 2495 ArgStringList &CmdArgs) const { 2496 const Driver &D = getToolChain().getDriver(); 2497 2498 unsigned Version[3] = { 0, 0, 0 }; 2499 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) { 2500 bool HadExtra; 2501 if (!Driver::GetReleaseVersion(A->getValue(Args), Version[0], 2502 Version[1], Version[2], HadExtra) || 2503 HadExtra) 2504 D.Diag(clang::diag::err_drv_invalid_version_number) 2505 << A->getAsString(Args); 2506 } 2507 2508 // Newer linkers support -demangle, pass it if supported and not disabled by 2509 // the user. 2510 // 2511 // FIXME: We temporarily avoid passing -demangle to any iOS linker, because 2512 // unfortunately we can't be guaranteed that the linker version used there 2513 // will match the linker version detected at configure time. We need the 2514 // universal driver. 2515 if (Version[0] >= 100 && !Args.hasArg(options::OPT_Z_Xlinker__no_demangle) && 2516 !getDarwinToolChain().isTargetIPhoneOS()) { 2517 // Don't pass -demangle to ld_classic. 2518 // 2519 // FIXME: This is a temporary workaround, ld should be handling this. 2520 bool UsesLdClassic = (getToolChain().getArch() == llvm::Triple::x86 && 2521 Args.hasArg(options::OPT_static)); 2522 if (getToolChain().getArch() == llvm::Triple::x86) { 2523 for (arg_iterator it = Args.filtered_begin(options::OPT_Xlinker, 2524 options::OPT_Wl_COMMA), 2525 ie = Args.filtered_end(); it != ie; ++it) { 2526 const Arg *A = *it; 2527 for (unsigned i = 0, e = A->getNumValues(); i != e; ++i) 2528 if (llvm::StringRef(A->getValue(Args, i)) == "-kext") 2529 UsesLdClassic = true; 2530 } 2531 } 2532 if (!UsesLdClassic) 2533 CmdArgs.push_back("-demangle"); 2534 } 2535 2536 // Derived from the "link" spec. 2537 Args.AddAllArgs(CmdArgs, options::OPT_static); 2538 if (!Args.hasArg(options::OPT_static)) 2539 CmdArgs.push_back("-dynamic"); 2540 if (Args.hasArg(options::OPT_fgnu_runtime)) { 2541 // FIXME: gcc replaces -lobjc in forward args with -lobjc-gnu 2542 // here. How do we wish to handle such things? 2543 } 2544 2545 if (!Args.hasArg(options::OPT_dynamiclib)) { 2546 AddDarwinArch(Args, CmdArgs); 2547 // FIXME: Why do this only on this path? 2548 Args.AddLastArg(CmdArgs, options::OPT_force__cpusubtype__ALL); 2549 2550 Args.AddLastArg(CmdArgs, options::OPT_bundle); 2551 Args.AddAllArgs(CmdArgs, options::OPT_bundle__loader); 2552 Args.AddAllArgs(CmdArgs, options::OPT_client__name); 2553 2554 Arg *A; 2555 if ((A = Args.getLastArg(options::OPT_compatibility__version)) || 2556 (A = Args.getLastArg(options::OPT_current__version)) || 2557 (A = Args.getLastArg(options::OPT_install__name))) 2558 D.Diag(clang::diag::err_drv_argument_only_allowed_with) 2559 << A->getAsString(Args) << "-dynamiclib"; 2560 2561 Args.AddLastArg(CmdArgs, options::OPT_force__flat__namespace); 2562 Args.AddLastArg(CmdArgs, options::OPT_keep__private__externs); 2563 Args.AddLastArg(CmdArgs, options::OPT_private__bundle); 2564 } else { 2565 CmdArgs.push_back("-dylib"); 2566 2567 Arg *A; 2568 if ((A = Args.getLastArg(options::OPT_bundle)) || 2569 (A = Args.getLastArg(options::OPT_bundle__loader)) || 2570 (A = Args.getLastArg(options::OPT_client__name)) || 2571 (A = Args.getLastArg(options::OPT_force__flat__namespace)) || 2572 (A = Args.getLastArg(options::OPT_keep__private__externs)) || 2573 (A = Args.getLastArg(options::OPT_private__bundle))) 2574 D.Diag(clang::diag::err_drv_argument_not_allowed_with) 2575 << A->getAsString(Args) << "-dynamiclib"; 2576 2577 Args.AddAllArgsTranslated(CmdArgs, options::OPT_compatibility__version, 2578 "-dylib_compatibility_version"); 2579 Args.AddAllArgsTranslated(CmdArgs, options::OPT_current__version, 2580 "-dylib_current_version"); 2581 2582 AddDarwinArch(Args, CmdArgs); 2583 2584 Args.AddAllArgsTranslated(CmdArgs, options::OPT_install__name, 2585 "-dylib_install_name"); 2586 } 2587 2588 Args.AddLastArg(CmdArgs, options::OPT_all__load); 2589 Args.AddAllArgs(CmdArgs, options::OPT_allowable__client); 2590 Args.AddLastArg(CmdArgs, options::OPT_bind__at__load); 2591 if (getDarwinToolChain().isTargetIPhoneOS()) 2592 Args.AddLastArg(CmdArgs, options::OPT_arch__errors__fatal); 2593 Args.AddLastArg(CmdArgs, options::OPT_dead__strip); 2594 Args.AddLastArg(CmdArgs, options::OPT_no__dead__strip__inits__and__terms); 2595 Args.AddAllArgs(CmdArgs, options::OPT_dylib__file); 2596 Args.AddLastArg(CmdArgs, options::OPT_dynamic); 2597 Args.AddAllArgs(CmdArgs, options::OPT_exported__symbols__list); 2598 Args.AddLastArg(CmdArgs, options::OPT_flat__namespace); 2599 Args.AddAllArgs(CmdArgs, options::OPT_headerpad__max__install__names); 2600 Args.AddAllArgs(CmdArgs, options::OPT_image__base); 2601 Args.AddAllArgs(CmdArgs, options::OPT_init); 2602 2603 // Adding all arguments doesn't make sense here but this is what gcc does. One 2604 // of this should always be present thanks to argument translation. 2605 assert((Args.hasArg(options::OPT_mmacosx_version_min_EQ) || 2606 Args.hasArg(options::OPT_miphoneos_version_min_EQ)) && 2607 "Missing version argument (lost in translation)?"); 2608 Args.AddAllArgsTranslated(CmdArgs, options::OPT_mmacosx_version_min_EQ, 2609 "-macosx_version_min"); 2610 Args.AddAllArgsTranslated(CmdArgs, options::OPT_miphoneos_version_min_EQ, 2611 "-iphoneos_version_min"); 2612 Args.AddLastArg(CmdArgs, options::OPT_nomultidefs); 2613 Args.AddLastArg(CmdArgs, options::OPT_multi__module); 2614 Args.AddLastArg(CmdArgs, options::OPT_single__module); 2615 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined); 2616 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined__unused); 2617 2618 if (const Arg *A = Args.getLastArg(options::OPT_fpie, options::OPT_fPIE, 2619 options::OPT_fno_pie, 2620 options::OPT_fno_PIE)) { 2621 if (A->getOption().matches(options::OPT_fpie) || 2622 A->getOption().matches(options::OPT_fPIE)) 2623 CmdArgs.push_back("-pie"); 2624 else 2625 CmdArgs.push_back("-no_pie"); 2626 } 2627 2628 Args.AddLastArg(CmdArgs, options::OPT_prebind); 2629 Args.AddLastArg(CmdArgs, options::OPT_noprebind); 2630 Args.AddLastArg(CmdArgs, options::OPT_nofixprebinding); 2631 Args.AddLastArg(CmdArgs, options::OPT_prebind__all__twolevel__modules); 2632 Args.AddLastArg(CmdArgs, options::OPT_read__only__relocs); 2633 Args.AddAllArgs(CmdArgs, options::OPT_sectcreate); 2634 Args.AddAllArgs(CmdArgs, options::OPT_sectorder); 2635 Args.AddAllArgs(CmdArgs, options::OPT_seg1addr); 2636 Args.AddAllArgs(CmdArgs, options::OPT_segprot); 2637 Args.AddAllArgs(CmdArgs, options::OPT_segaddr); 2638 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__only__addr); 2639 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__write__addr); 2640 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table); 2641 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table__filename); 2642 Args.AddAllArgs(CmdArgs, options::OPT_sub__library); 2643 Args.AddAllArgs(CmdArgs, options::OPT_sub__umbrella); 2644 2645 Args.AddAllArgsTranslated(CmdArgs, options::OPT_isysroot, "-syslibroot"); 2646 if (getDarwinToolChain().isTargetIPhoneOS()) { 2647 if (!Args.hasArg(options::OPT_isysroot)) { 2648 CmdArgs.push_back("-syslibroot"); 2649 CmdArgs.push_back("/Developer/SDKs/Extra"); 2650 } 2651 } 2652 2653 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace); 2654 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace__hints); 2655 Args.AddAllArgs(CmdArgs, options::OPT_umbrella); 2656 Args.AddAllArgs(CmdArgs, options::OPT_undefined); 2657 Args.AddAllArgs(CmdArgs, options::OPT_unexported__symbols__list); 2658 Args.AddAllArgs(CmdArgs, options::OPT_weak__reference__mismatches); 2659 Args.AddLastArg(CmdArgs, options::OPT_X_Flag); 2660 Args.AddAllArgs(CmdArgs, options::OPT_y); 2661 Args.AddLastArg(CmdArgs, options::OPT_w); 2662 Args.AddAllArgs(CmdArgs, options::OPT_pagezero__size); 2663 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__); 2664 Args.AddLastArg(CmdArgs, options::OPT_seglinkedit); 2665 Args.AddLastArg(CmdArgs, options::OPT_noseglinkedit); 2666 Args.AddAllArgs(CmdArgs, options::OPT_sectalign); 2667 Args.AddAllArgs(CmdArgs, options::OPT_sectobjectsymbols); 2668 Args.AddAllArgs(CmdArgs, options::OPT_segcreate); 2669 Args.AddLastArg(CmdArgs, options::OPT_whyload); 2670 Args.AddLastArg(CmdArgs, options::OPT_whatsloaded); 2671 Args.AddAllArgs(CmdArgs, options::OPT_dylinker__install__name); 2672 Args.AddLastArg(CmdArgs, options::OPT_dylinker); 2673 Args.AddLastArg(CmdArgs, options::OPT_Mach); 2674} 2675 2676void darwin::Link::ConstructJob(Compilation &C, const JobAction &JA, 2677 const InputInfo &Output, 2678 const InputInfoList &Inputs, 2679 const ArgList &Args, 2680 const char *LinkingOutput) const { 2681 assert(Output.getType() == types::TY_Image && "Invalid linker output type."); 2682 2683 // The logic here is derived from gcc's behavior; most of which 2684 // comes from specs (starting with link_command). Consult gcc for 2685 // more information. 2686 ArgStringList CmdArgs; 2687 2688 // I'm not sure why this particular decomposition exists in gcc, but 2689 // we follow suite for ease of comparison. 2690 AddLinkArgs(C, Args, CmdArgs); 2691 2692 Args.AddAllArgs(CmdArgs, options::OPT_d_Flag); 2693 Args.AddAllArgs(CmdArgs, options::OPT_s); 2694 Args.AddAllArgs(CmdArgs, options::OPT_t); 2695 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag); 2696 Args.AddAllArgs(CmdArgs, options::OPT_u_Group); 2697 Args.AddAllArgs(CmdArgs, options::OPT_A); 2698 Args.AddLastArg(CmdArgs, options::OPT_e); 2699 Args.AddAllArgs(CmdArgs, options::OPT_m_Separate); 2700 Args.AddAllArgs(CmdArgs, options::OPT_r); 2701 2702 // Forward -ObjC when either -ObjC or -ObjC++ is used, to force loading 2703 // members of static archive libraries which implement Objective-C classes or 2704 // categories. 2705 if (Args.hasArg(options::OPT_ObjC) || Args.hasArg(options::OPT_ObjCXX)) 2706 CmdArgs.push_back("-ObjC"); 2707 2708 CmdArgs.push_back("-o"); 2709 CmdArgs.push_back(Output.getFilename()); 2710 2711 if (!Args.hasArg(options::OPT_A) && 2712 !Args.hasArg(options::OPT_nostdlib) && 2713 !Args.hasArg(options::OPT_nostartfiles)) { 2714 // Derived from startfile spec. 2715 if (Args.hasArg(options::OPT_dynamiclib)) { 2716 // Derived from darwin_dylib1 spec. 2717 if (getDarwinToolChain().isTargetIPhoneOS()) { 2718 if (getDarwinToolChain().isIPhoneOSVersionLT(3, 1)) 2719 CmdArgs.push_back("-ldylib1.o"); 2720 } else { 2721 if (getDarwinToolChain().isMacosxVersionLT(10, 5)) 2722 CmdArgs.push_back("-ldylib1.o"); 2723 else if (getDarwinToolChain().isMacosxVersionLT(10, 6)) 2724 CmdArgs.push_back("-ldylib1.10.5.o"); 2725 } 2726 } else { 2727 if (Args.hasArg(options::OPT_bundle)) { 2728 if (!Args.hasArg(options::OPT_static)) { 2729 // Derived from darwin_bundle1 spec. 2730 if (getDarwinToolChain().isTargetIPhoneOS()) { 2731 if (getDarwinToolChain().isIPhoneOSVersionLT(3, 1)) 2732 CmdArgs.push_back("-lbundle1.o"); 2733 } else { 2734 if (getDarwinToolChain().isMacosxVersionLT(10, 6)) 2735 CmdArgs.push_back("-lbundle1.o"); 2736 } 2737 } 2738 } else { 2739 if (Args.hasArg(options::OPT_pg)) { 2740 if (Args.hasArg(options::OPT_static) || 2741 Args.hasArg(options::OPT_object) || 2742 Args.hasArg(options::OPT_preload)) { 2743 CmdArgs.push_back("-lgcrt0.o"); 2744 } else { 2745 CmdArgs.push_back("-lgcrt1.o"); 2746 2747 // darwin_crt2 spec is empty. 2748 } 2749 } else { 2750 if (Args.hasArg(options::OPT_static) || 2751 Args.hasArg(options::OPT_object) || 2752 Args.hasArg(options::OPT_preload)) { 2753 CmdArgs.push_back("-lcrt0.o"); 2754 } else { 2755 // Derived from darwin_crt1 spec. 2756 if (getDarwinToolChain().isTargetIPhoneOS()) { 2757 if (getDarwinToolChain().isIPhoneOSVersionLT(3, 1)) 2758 CmdArgs.push_back("-lcrt1.o"); 2759 else 2760 CmdArgs.push_back("-lcrt1.3.1.o"); 2761 } else { 2762 if (getDarwinToolChain().isMacosxVersionLT(10, 5)) 2763 CmdArgs.push_back("-lcrt1.o"); 2764 else if (getDarwinToolChain().isMacosxVersionLT(10, 6)) 2765 CmdArgs.push_back("-lcrt1.10.5.o"); 2766 else 2767 CmdArgs.push_back("-lcrt1.10.6.o"); 2768 2769 // darwin_crt2 spec is empty. 2770 } 2771 } 2772 } 2773 } 2774 } 2775 2776 if (!getDarwinToolChain().isTargetIPhoneOS() && 2777 Args.hasArg(options::OPT_shared_libgcc) && 2778 getDarwinToolChain().isMacosxVersionLT(10, 5)) { 2779 const char *Str = 2780 Args.MakeArgString(getToolChain().GetFilePath("crt3.o")); 2781 CmdArgs.push_back(Str); 2782 } 2783 } 2784 2785 Args.AddAllArgs(CmdArgs, options::OPT_L); 2786 2787 if (Args.hasArg(options::OPT_fopenmp)) 2788 // This is more complicated in gcc... 2789 CmdArgs.push_back("-lgomp"); 2790 2791 getDarwinToolChain().AddLinkSearchPathArgs(Args, CmdArgs); 2792 2793 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs); 2794 2795 if (LinkingOutput) { 2796 CmdArgs.push_back("-arch_multiple"); 2797 CmdArgs.push_back("-final_output"); 2798 CmdArgs.push_back(LinkingOutput); 2799 } 2800 2801 if (Args.hasArg(options::OPT_fprofile_arcs) || 2802 Args.hasArg(options::OPT_fprofile_generate) || 2803 Args.hasArg(options::OPT_fcreate_profile) || 2804 Args.hasArg(options::OPT_coverage)) 2805 CmdArgs.push_back("-lgcov"); 2806 2807 if (Args.hasArg(options::OPT_fnested_functions)) 2808 CmdArgs.push_back("-allow_stack_execute"); 2809 2810 if (!Args.hasArg(options::OPT_nostdlib) && 2811 !Args.hasArg(options::OPT_nodefaultlibs)) { 2812 if (getToolChain().getDriver().CCCIsCXX) 2813 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs); 2814 2815 // link_ssp spec is empty. 2816 2817 // Let the tool chain choose which runtime library to link. 2818 getDarwinToolChain().AddLinkRuntimeLibArgs(Args, CmdArgs); 2819 } 2820 2821 if (!Args.hasArg(options::OPT_A) && 2822 !Args.hasArg(options::OPT_nostdlib) && 2823 !Args.hasArg(options::OPT_nostartfiles)) { 2824 // endfile_spec is empty. 2825 } 2826 2827 Args.AddAllArgs(CmdArgs, options::OPT_T_Group); 2828 Args.AddAllArgs(CmdArgs, options::OPT_F); 2829 2830 const char *Exec = 2831 Args.MakeArgString(getToolChain().GetProgramPath("ld")); 2832 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 2833} 2834 2835void darwin::Lipo::ConstructJob(Compilation &C, const JobAction &JA, 2836 const InputInfo &Output, 2837 const InputInfoList &Inputs, 2838 const ArgList &Args, 2839 const char *LinkingOutput) const { 2840 ArgStringList CmdArgs; 2841 2842 CmdArgs.push_back("-create"); 2843 assert(Output.isFilename() && "Unexpected lipo output."); 2844 2845 CmdArgs.push_back("-output"); 2846 CmdArgs.push_back(Output.getFilename()); 2847 2848 for (InputInfoList::const_iterator 2849 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 2850 const InputInfo &II = *it; 2851 assert(II.isFilename() && "Unexpected lipo input."); 2852 CmdArgs.push_back(II.getFilename()); 2853 } 2854 const char *Exec = 2855 Args.MakeArgString(getToolChain().GetProgramPath("lipo")); 2856 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 2857} 2858 2859void darwin::Dsymutil::ConstructJob(Compilation &C, const JobAction &JA, 2860 const InputInfo &Output, 2861 const InputInfoList &Inputs, 2862 const ArgList &Args, 2863 const char *LinkingOutput) const { 2864 ArgStringList CmdArgs; 2865 2866 assert(Inputs.size() == 1 && "Unable to handle multiple inputs."); 2867 const InputInfo &Input = Inputs[0]; 2868 assert(Input.isFilename() && "Unexpected dsymutil input."); 2869 CmdArgs.push_back(Input.getFilename()); 2870 2871 CmdArgs.push_back("-o"); 2872 CmdArgs.push_back(Output.getFilename()); 2873 2874 const char *Exec = 2875 Args.MakeArgString(getToolChain().GetProgramPath("dsymutil")); 2876 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 2877} 2878 2879void auroraux::Assemble::ConstructJob(Compilation &C, const JobAction &JA, 2880 const InputInfo &Output, 2881 const InputInfoList &Inputs, 2882 const ArgList &Args, 2883 const char *LinkingOutput) const { 2884 ArgStringList CmdArgs; 2885 2886 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, 2887 options::OPT_Xassembler); 2888 2889 CmdArgs.push_back("-o"); 2890 CmdArgs.push_back(Output.getFilename()); 2891 2892 for (InputInfoList::const_iterator 2893 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 2894 const InputInfo &II = *it; 2895 CmdArgs.push_back(II.getFilename()); 2896 } 2897 2898 const char *Exec = 2899 Args.MakeArgString(getToolChain().GetProgramPath("gas")); 2900 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 2901} 2902 2903void auroraux::Link::ConstructJob(Compilation &C, const JobAction &JA, 2904 const InputInfo &Output, 2905 const InputInfoList &Inputs, 2906 const ArgList &Args, 2907 const char *LinkingOutput) const { 2908 ArgStringList CmdArgs; 2909 2910 if ((!Args.hasArg(options::OPT_nostdlib)) && 2911 (!Args.hasArg(options::OPT_shared))) { 2912 CmdArgs.push_back("-e"); 2913 CmdArgs.push_back("_start"); 2914 } 2915 2916 if (Args.hasArg(options::OPT_static)) { 2917 CmdArgs.push_back("-Bstatic"); 2918 CmdArgs.push_back("-dn"); 2919 } else { 2920// CmdArgs.push_back("--eh-frame-hdr"); 2921 CmdArgs.push_back("-Bdynamic"); 2922 if (Args.hasArg(options::OPT_shared)) { 2923 CmdArgs.push_back("-shared"); 2924 } else { 2925 CmdArgs.push_back("--dynamic-linker"); 2926 CmdArgs.push_back("/lib/ld.so.1"); // 64Bit Path /lib/amd64/ld.so.1 2927 } 2928 } 2929 2930 if (Output.isFilename()) { 2931 CmdArgs.push_back("-o"); 2932 CmdArgs.push_back(Output.getFilename()); 2933 } else { 2934 assert(Output.isNothing() && "Invalid output."); 2935 } 2936 2937 if (!Args.hasArg(options::OPT_nostdlib) && 2938 !Args.hasArg(options::OPT_nostartfiles)) { 2939 if (!Args.hasArg(options::OPT_shared)) { 2940 CmdArgs.push_back(Args.MakeArgString( 2941 getToolChain().GetFilePath("crt1.o"))); 2942 CmdArgs.push_back(Args.MakeArgString( 2943 getToolChain().GetFilePath("crti.o"))); 2944 CmdArgs.push_back(Args.MakeArgString( 2945 getToolChain().GetFilePath("crtbegin.o"))); 2946 } else { 2947 CmdArgs.push_back(Args.MakeArgString( 2948 getToolChain().GetFilePath("crti.o"))); 2949 } 2950 CmdArgs.push_back(Args.MakeArgString( 2951 getToolChain().GetFilePath("crtn.o"))); 2952 } 2953 2954 CmdArgs.push_back(Args.MakeArgString("-L/opt/gcc4/lib/gcc/" 2955 + getToolChain().getTripleString() 2956 + "/4.2.4")); 2957 2958 Args.AddAllArgs(CmdArgs, options::OPT_L); 2959 Args.AddAllArgs(CmdArgs, options::OPT_T_Group); 2960 Args.AddAllArgs(CmdArgs, options::OPT_e); 2961 2962 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs); 2963 2964 if (!Args.hasArg(options::OPT_nostdlib) && 2965 !Args.hasArg(options::OPT_nodefaultlibs)) { 2966 // FIXME: For some reason GCC passes -lgcc before adding 2967 // the default system libraries. Just mimic this for now. 2968 CmdArgs.push_back("-lgcc"); 2969 2970 if (Args.hasArg(options::OPT_pthread)) 2971 CmdArgs.push_back("-pthread"); 2972 if (!Args.hasArg(options::OPT_shared)) 2973 CmdArgs.push_back("-lc"); 2974 CmdArgs.push_back("-lgcc"); 2975 } 2976 2977 if (!Args.hasArg(options::OPT_nostdlib) && 2978 !Args.hasArg(options::OPT_nostartfiles)) { 2979 if (!Args.hasArg(options::OPT_shared)) 2980 CmdArgs.push_back(Args.MakeArgString( 2981 getToolChain().GetFilePath("crtend.o"))); 2982 } 2983 2984 const char *Exec = 2985 Args.MakeArgString(getToolChain().GetProgramPath("ld")); 2986 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 2987} 2988 2989void openbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA, 2990 const InputInfo &Output, 2991 const InputInfoList &Inputs, 2992 const ArgList &Args, 2993 const char *LinkingOutput) const { 2994 ArgStringList CmdArgs; 2995 2996 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, 2997 options::OPT_Xassembler); 2998 2999 CmdArgs.push_back("-o"); 3000 CmdArgs.push_back(Output.getFilename()); 3001 3002 for (InputInfoList::const_iterator 3003 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 3004 const InputInfo &II = *it; 3005 CmdArgs.push_back(II.getFilename()); 3006 } 3007 3008 const char *Exec = 3009 Args.MakeArgString(getToolChain().GetProgramPath("as")); 3010 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 3011} 3012 3013void openbsd::Link::ConstructJob(Compilation &C, const JobAction &JA, 3014 const InputInfo &Output, 3015 const InputInfoList &Inputs, 3016 const ArgList &Args, 3017 const char *LinkingOutput) const { 3018 const Driver &D = getToolChain().getDriver(); 3019 ArgStringList CmdArgs; 3020 3021 if ((!Args.hasArg(options::OPT_nostdlib)) && 3022 (!Args.hasArg(options::OPT_shared))) { 3023 CmdArgs.push_back("-e"); 3024 CmdArgs.push_back("__start"); 3025 } 3026 3027 if (Args.hasArg(options::OPT_static)) { 3028 CmdArgs.push_back("-Bstatic"); 3029 } else { 3030 if (Args.hasArg(options::OPT_rdynamic)) 3031 CmdArgs.push_back("-export-dynamic"); 3032 CmdArgs.push_back("--eh-frame-hdr"); 3033 CmdArgs.push_back("-Bdynamic"); 3034 if (Args.hasArg(options::OPT_shared)) { 3035 CmdArgs.push_back("-shared"); 3036 } else { 3037 CmdArgs.push_back("-dynamic-linker"); 3038 CmdArgs.push_back("/usr/libexec/ld.so"); 3039 } 3040 } 3041 3042 if (Output.isFilename()) { 3043 CmdArgs.push_back("-o"); 3044 CmdArgs.push_back(Output.getFilename()); 3045 } else { 3046 assert(Output.isNothing() && "Invalid output."); 3047 } 3048 3049 if (!Args.hasArg(options::OPT_nostdlib) && 3050 !Args.hasArg(options::OPT_nostartfiles)) { 3051 if (!Args.hasArg(options::OPT_shared)) { 3052 CmdArgs.push_back(Args.MakeArgString( 3053 getToolChain().GetFilePath("crt0.o"))); 3054 CmdArgs.push_back(Args.MakeArgString( 3055 getToolChain().GetFilePath("crtbegin.o"))); 3056 } else { 3057 CmdArgs.push_back(Args.MakeArgString( 3058 getToolChain().GetFilePath("crtbeginS.o"))); 3059 } 3060 } 3061 3062 std::string Triple = getToolChain().getTripleString(); 3063 if (Triple.substr(0, 6) == "x86_64") 3064 Triple.replace(0, 6, "amd64"); 3065 CmdArgs.push_back(Args.MakeArgString("-L/usr/lib/gcc-lib/" + Triple + 3066 "/4.2.1")); 3067 3068 Args.AddAllArgs(CmdArgs, options::OPT_L); 3069 Args.AddAllArgs(CmdArgs, options::OPT_T_Group); 3070 Args.AddAllArgs(CmdArgs, options::OPT_e); 3071 3072 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs); 3073 3074 if (!Args.hasArg(options::OPT_nostdlib) && 3075 !Args.hasArg(options::OPT_nodefaultlibs)) { 3076 if (D.CCCIsCXX) { 3077 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs); 3078 CmdArgs.push_back("-lm"); 3079 } 3080 3081 // FIXME: For some reason GCC passes -lgcc before adding 3082 // the default system libraries. Just mimic this for now. 3083 CmdArgs.push_back("-lgcc"); 3084 3085 if (Args.hasArg(options::OPT_pthread)) 3086 CmdArgs.push_back("-pthread"); 3087 if (!Args.hasArg(options::OPT_shared)) 3088 CmdArgs.push_back("-lc"); 3089 CmdArgs.push_back("-lgcc"); 3090 } 3091 3092 if (!Args.hasArg(options::OPT_nostdlib) && 3093 !Args.hasArg(options::OPT_nostartfiles)) { 3094 if (!Args.hasArg(options::OPT_shared)) 3095 CmdArgs.push_back(Args.MakeArgString( 3096 getToolChain().GetFilePath("crtend.o"))); 3097 else 3098 CmdArgs.push_back(Args.MakeArgString( 3099 getToolChain().GetFilePath("crtendS.o"))); 3100 } 3101 3102 const char *Exec = 3103 Args.MakeArgString(getToolChain().GetProgramPath("ld")); 3104 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 3105} 3106 3107void freebsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA, 3108 const InputInfo &Output, 3109 const InputInfoList &Inputs, 3110 const ArgList &Args, 3111 const char *LinkingOutput) const { 3112 ArgStringList CmdArgs; 3113 3114 // When building 32-bit code on FreeBSD/amd64, we have to explicitly 3115 // instruct as in the base system to assemble 32-bit code. 3116 if (getToolChain().getArchName() == "i386") 3117 CmdArgs.push_back("--32"); 3118 3119 3120 // Set byte order explicitly 3121 if (getToolChain().getArchName() == "mips") 3122 CmdArgs.push_back("-EB"); 3123 else if (getToolChain().getArchName() == "mipsel") 3124 CmdArgs.push_back("-EL"); 3125 3126 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, 3127 options::OPT_Xassembler); 3128 3129 CmdArgs.push_back("-o"); 3130 CmdArgs.push_back(Output.getFilename()); 3131 3132 for (InputInfoList::const_iterator 3133 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 3134 const InputInfo &II = *it; 3135 CmdArgs.push_back(II.getFilename()); 3136 } 3137 3138 const char *Exec = 3139 Args.MakeArgString(getToolChain().GetProgramPath("as")); 3140 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 3141} 3142 3143void freebsd::Link::ConstructJob(Compilation &C, const JobAction &JA, 3144 const InputInfo &Output, 3145 const InputInfoList &Inputs, 3146 const ArgList &Args, 3147 const char *LinkingOutput) const { 3148 const Driver &D = getToolChain().getDriver(); 3149 ArgStringList CmdArgs; 3150 3151 if (Args.hasArg(options::OPT_static)) { 3152 CmdArgs.push_back("-Bstatic"); 3153 } else { 3154 if (Args.hasArg(options::OPT_rdynamic)) 3155 CmdArgs.push_back("-export-dynamic"); 3156 CmdArgs.push_back("--eh-frame-hdr"); 3157 if (Args.hasArg(options::OPT_shared)) { 3158 CmdArgs.push_back("-Bshareable"); 3159 } else { 3160 CmdArgs.push_back("-dynamic-linker"); 3161 CmdArgs.push_back("/libexec/ld-elf.so.1"); 3162 } 3163 } 3164 3165 // When building 32-bit code on FreeBSD/amd64, we have to explicitly 3166 // instruct ld in the base system to link 32-bit code. 3167 if (getToolChain().getArchName() == "i386") { 3168 CmdArgs.push_back("-m"); 3169 CmdArgs.push_back("elf_i386_fbsd"); 3170 } 3171 3172 if (Output.isFilename()) { 3173 CmdArgs.push_back("-o"); 3174 CmdArgs.push_back(Output.getFilename()); 3175 } else { 3176 assert(Output.isNothing() && "Invalid output."); 3177 } 3178 3179 if (!Args.hasArg(options::OPT_nostdlib) && 3180 !Args.hasArg(options::OPT_nostartfiles)) { 3181 if (!Args.hasArg(options::OPT_shared)) { 3182 if (Args.hasArg(options::OPT_pg)) 3183 CmdArgs.push_back(Args.MakeArgString( 3184 getToolChain().GetFilePath("gcrt1.o"))); 3185 else 3186 CmdArgs.push_back(Args.MakeArgString( 3187 getToolChain().GetFilePath("crt1.o"))); 3188 CmdArgs.push_back(Args.MakeArgString( 3189 getToolChain().GetFilePath("crti.o"))); 3190 CmdArgs.push_back(Args.MakeArgString( 3191 getToolChain().GetFilePath("crtbegin.o"))); 3192 } else { 3193 CmdArgs.push_back(Args.MakeArgString( 3194 getToolChain().GetFilePath("crti.o"))); 3195 CmdArgs.push_back(Args.MakeArgString( 3196 getToolChain().GetFilePath("crtbeginS.o"))); 3197 } 3198 } 3199 3200 Args.AddAllArgs(CmdArgs, options::OPT_L); 3201 CmdArgs.push_back("-L/usr/lib"); 3202 Args.AddAllArgs(CmdArgs, options::OPT_T_Group); 3203 Args.AddAllArgs(CmdArgs, options::OPT_e); 3204 Args.AddAllArgs(CmdArgs, options::OPT_s); 3205 Args.AddAllArgs(CmdArgs, options::OPT_t); 3206 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag); 3207 Args.AddAllArgs(CmdArgs, options::OPT_r); 3208 3209 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs); 3210 3211 if (!Args.hasArg(options::OPT_nostdlib) && 3212 !Args.hasArg(options::OPT_nodefaultlibs)) { 3213 if (D.CCCIsCXX) { 3214 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs); 3215 if (Args.hasArg(options::OPT_pg)) 3216 CmdArgs.push_back("-lm_p"); 3217 else 3218 CmdArgs.push_back("-lm"); 3219 } 3220 // FIXME: For some reason GCC passes -lgcc and -lgcc_s before adding 3221 // the default system libraries. Just mimic this for now. 3222 if (Args.hasArg(options::OPT_pg)) 3223 CmdArgs.push_back("-lgcc_p"); 3224 else 3225 CmdArgs.push_back("-lgcc"); 3226 if (Args.hasArg(options::OPT_static)) { 3227 CmdArgs.push_back("-lgcc_eh"); 3228 } else if (Args.hasArg(options::OPT_pg)) { 3229 CmdArgs.push_back("-lgcc_eh_p"); 3230 } else { 3231 CmdArgs.push_back("--as-needed"); 3232 CmdArgs.push_back("-lgcc_s"); 3233 CmdArgs.push_back("--no-as-needed"); 3234 } 3235 3236 if (Args.hasArg(options::OPT_pthread)) 3237 if (Args.hasArg(options::OPT_pg)) 3238 CmdArgs.push_back("-lpthread_p"); 3239 else 3240 CmdArgs.push_back("-lpthread"); 3241 3242 if (Args.hasArg(options::OPT_pg)) { 3243 if (Args.hasArg(options::OPT_shared)) 3244 CmdArgs.push_back("-lc"); 3245 else 3246 CmdArgs.push_back("-lc_p"); 3247 CmdArgs.push_back("-lgcc_p"); 3248 } else { 3249 CmdArgs.push_back("-lc"); 3250 CmdArgs.push_back("-lgcc"); 3251 } 3252 3253 if (Args.hasArg(options::OPT_static)) { 3254 CmdArgs.push_back("-lgcc_eh"); 3255 } else if (Args.hasArg(options::OPT_pg)) { 3256 CmdArgs.push_back("-lgcc_eh_p"); 3257 } else { 3258 CmdArgs.push_back("--as-needed"); 3259 CmdArgs.push_back("-lgcc_s"); 3260 CmdArgs.push_back("--no-as-needed"); 3261 } 3262 } 3263 3264 if (!Args.hasArg(options::OPT_nostdlib) && 3265 !Args.hasArg(options::OPT_nostartfiles)) { 3266 if (!Args.hasArg(options::OPT_shared)) 3267 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath( 3268 "crtend.o"))); 3269 else 3270 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath( 3271 "crtendS.o"))); 3272 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath( 3273 "crtn.o"))); 3274 } 3275 3276 const char *Exec = 3277 Args.MakeArgString(getToolChain().GetProgramPath("ld")); 3278 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 3279} 3280 3281void netbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA, 3282 const InputInfo &Output, 3283 const InputInfoList &Inputs, 3284 const ArgList &Args, 3285 const char *LinkingOutput) const { 3286 ArgStringList CmdArgs; 3287 3288 // When building 32-bit code on NetBSD/amd64, we have to explicitly 3289 // instruct as in the base system to assemble 32-bit code. 3290 if (getToolChain().getArchName() == "i386") 3291 CmdArgs.push_back("--32"); 3292 3293 3294 // Set byte order explicitly 3295 if (getToolChain().getArchName() == "mips") 3296 CmdArgs.push_back("-EB"); 3297 else if (getToolChain().getArchName() == "mipsel") 3298 CmdArgs.push_back("-EL"); 3299 3300 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, 3301 options::OPT_Xassembler); 3302 3303 CmdArgs.push_back("-o"); 3304 CmdArgs.push_back(Output.getFilename()); 3305 3306 for (InputInfoList::const_iterator 3307 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 3308 const InputInfo &II = *it; 3309 CmdArgs.push_back(II.getFilename()); 3310 } 3311 3312 const char *Exec = 3313 Args.MakeArgString(getToolChain().GetProgramPath("as")); 3314 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 3315} 3316 3317void netbsd::Link::ConstructJob(Compilation &C, const JobAction &JA, 3318 const InputInfo &Output, 3319 const InputInfoList &Inputs, 3320 const ArgList &Args, 3321 const char *LinkingOutput) const { 3322 const Driver &D = getToolChain().getDriver(); 3323 ArgStringList CmdArgs; 3324 3325 if (Args.hasArg(options::OPT_static)) { 3326 CmdArgs.push_back("-Bstatic"); 3327 } else { 3328 if (Args.hasArg(options::OPT_rdynamic)) 3329 CmdArgs.push_back("-export-dynamic"); 3330 CmdArgs.push_back("--eh-frame-hdr"); 3331 if (Args.hasArg(options::OPT_shared)) { 3332 CmdArgs.push_back("-Bshareable"); 3333 } else { 3334 CmdArgs.push_back("-dynamic-linker"); 3335 CmdArgs.push_back("/libexec/ld.elf_so"); 3336 } 3337 } 3338 3339 // When building 32-bit code on NetBSD/amd64, we have to explicitly 3340 // instruct ld in the base system to link 32-bit code. 3341 if (getToolChain().getArchName() == "i386") { 3342 CmdArgs.push_back("-m"); 3343 CmdArgs.push_back("elf_i386"); 3344 } 3345 3346 if (Output.isFilename()) { 3347 CmdArgs.push_back("-o"); 3348 CmdArgs.push_back(Output.getFilename()); 3349 } else { 3350 assert(Output.isNothing() && "Invalid output."); 3351 } 3352 3353 if (!Args.hasArg(options::OPT_nostdlib) && 3354 !Args.hasArg(options::OPT_nostartfiles)) { 3355 if (!Args.hasArg(options::OPT_shared)) { 3356 CmdArgs.push_back(Args.MakeArgString( 3357 getToolChain().GetFilePath("crt0.o"))); 3358 CmdArgs.push_back(Args.MakeArgString( 3359 getToolChain().GetFilePath("crti.o"))); 3360 CmdArgs.push_back(Args.MakeArgString( 3361 getToolChain().GetFilePath("crtbegin.o"))); 3362 } else { 3363 CmdArgs.push_back(Args.MakeArgString( 3364 getToolChain().GetFilePath("crti.o"))); 3365 CmdArgs.push_back(Args.MakeArgString( 3366 getToolChain().GetFilePath("crtbeginS.o"))); 3367 } 3368 } 3369 3370 Args.AddAllArgs(CmdArgs, options::OPT_L); 3371 Args.AddAllArgs(CmdArgs, options::OPT_T_Group); 3372 Args.AddAllArgs(CmdArgs, options::OPT_e); 3373 Args.AddAllArgs(CmdArgs, options::OPT_s); 3374 Args.AddAllArgs(CmdArgs, options::OPT_t); 3375 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag); 3376 Args.AddAllArgs(CmdArgs, options::OPT_r); 3377 3378 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs); 3379 3380 if (!Args.hasArg(options::OPT_nostdlib) && 3381 !Args.hasArg(options::OPT_nodefaultlibs)) { 3382 if (D.CCCIsCXX) { 3383 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs); 3384 CmdArgs.push_back("-lm"); 3385 } 3386 // FIXME: For some reason GCC passes -lgcc and -lgcc_s before adding 3387 // the default system libraries. Just mimic this for now. 3388 CmdArgs.push_back("-lgcc"); 3389 if (Args.hasArg(options::OPT_static)) { 3390 CmdArgs.push_back("-lgcc_eh"); 3391 } else { 3392 CmdArgs.push_back("--as-needed"); 3393 CmdArgs.push_back("-lgcc_s"); 3394 CmdArgs.push_back("--no-as-needed"); 3395 } 3396 3397 if (Args.hasArg(options::OPT_pthread)) 3398 CmdArgs.push_back("-lpthread"); 3399 CmdArgs.push_back("-lc"); 3400 3401 CmdArgs.push_back("-lgcc"); 3402 if (Args.hasArg(options::OPT_static)) { 3403 CmdArgs.push_back("-lgcc_eh"); 3404 } else { 3405 CmdArgs.push_back("--as-needed"); 3406 CmdArgs.push_back("-lgcc_s"); 3407 CmdArgs.push_back("--no-as-needed"); 3408 } 3409 } 3410 3411 if (!Args.hasArg(options::OPT_nostdlib) && 3412 !Args.hasArg(options::OPT_nostartfiles)) { 3413 if (!Args.hasArg(options::OPT_shared)) 3414 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath( 3415 "crtend.o"))); 3416 else 3417 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath( 3418 "crtendS.o"))); 3419 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath( 3420 "crtn.o"))); 3421 } 3422 3423 const char *Exec = 3424 Args.MakeArgString(getToolChain().GetProgramPath("ld")); 3425 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 3426} 3427 3428void linuxtools::Assemble::ConstructJob(Compilation &C, const JobAction &JA, 3429 const InputInfo &Output, 3430 const InputInfoList &Inputs, 3431 const ArgList &Args, 3432 const char *LinkingOutput) const { 3433 ArgStringList CmdArgs; 3434 3435 // Add --32/--64 to make sure we get the format we want. 3436 // This is incomplete 3437 if (getToolChain().getArch() == llvm::Triple::x86) { 3438 CmdArgs.push_back("--32"); 3439 } else if (getToolChain().getArch() == llvm::Triple::x86_64) { 3440 CmdArgs.push_back("--64"); 3441 } else if (getToolChain().getArch() == llvm::Triple::arm) { 3442 llvm::StringRef MArch = getToolChain().getArchName(); 3443 if (MArch == "armv7" || MArch == "armv7a" || MArch == "armv7-a") 3444 CmdArgs.push_back("-mfpu=neon"); 3445 } 3446 3447 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, 3448 options::OPT_Xassembler); 3449 3450 CmdArgs.push_back("-o"); 3451 CmdArgs.push_back(Output.getFilename()); 3452 3453 for (InputInfoList::const_iterator 3454 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 3455 const InputInfo &II = *it; 3456 CmdArgs.push_back(II.getFilename()); 3457 } 3458 3459 const char *Exec = 3460 Args.MakeArgString(getToolChain().GetProgramPath("as")); 3461 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 3462} 3463 3464void linuxtools::Link::ConstructJob(Compilation &C, const JobAction &JA, 3465 const InputInfo &Output, 3466 const InputInfoList &Inputs, 3467 const ArgList &Args, 3468 const char *LinkingOutput) const { 3469 const toolchains::Linux& ToolChain = 3470 static_cast<const toolchains::Linux&>(getToolChain()); 3471 const Driver &D = ToolChain.getDriver(); 3472 ArgStringList CmdArgs; 3473 3474 // Silence warning for "clang -g foo.o -o foo" 3475 Args.ClaimAllArgs(options::OPT_g_Group); 3476 // and for "clang -g foo.o -o foo". Other warning options are already 3477 // handled somewhere else. 3478 Args.ClaimAllArgs(options::OPT_w); 3479 3480 if (Arg *A = Args.getLastArg(options::OPT__sysroot_EQ)) { 3481 CmdArgs.push_back("--sysroot"); 3482 CmdArgs.push_back(A->getValue(Args)); 3483 } 3484 3485 if (Args.hasArg(options::OPT_pie)) 3486 CmdArgs.push_back("-pie"); 3487 3488 if (Args.hasArg(options::OPT_rdynamic)) 3489 CmdArgs.push_back("-export-dynamic"); 3490 3491 if (Args.hasArg(options::OPT_s)) 3492 CmdArgs.push_back("-s"); 3493 3494 for (std::vector<std::string>::const_iterator i = ToolChain.ExtraOpts.begin(), 3495 e = ToolChain.ExtraOpts.end(); 3496 i != e; ++i) 3497 CmdArgs.push_back(i->c_str()); 3498 3499 if (!Args.hasArg(options::OPT_static)) { 3500 CmdArgs.push_back("--eh-frame-hdr"); 3501 } 3502 3503 CmdArgs.push_back("-m"); 3504 if (ToolChain.getArch() == llvm::Triple::x86) 3505 CmdArgs.push_back("elf_i386"); 3506 else if (ToolChain.getArch() == llvm::Triple::arm) 3507 CmdArgs.push_back("armelf_linux_eabi"); 3508 else 3509 CmdArgs.push_back("elf_x86_64"); 3510 3511 if (Args.hasArg(options::OPT_static)) { 3512 if (ToolChain.getArch() == llvm::Triple::arm) 3513 CmdArgs.push_back("-Bstatic"); 3514 else 3515 CmdArgs.push_back("-static"); 3516 } else if (Args.hasArg(options::OPT_shared)) { 3517 CmdArgs.push_back("-shared"); 3518 } 3519 3520 if (ToolChain.getArch() == llvm::Triple::arm || 3521 (!Args.hasArg(options::OPT_static) && 3522 !Args.hasArg(options::OPT_shared))) { 3523 CmdArgs.push_back("-dynamic-linker"); 3524 if (ToolChain.getArch() == llvm::Triple::x86) 3525 CmdArgs.push_back("/lib/ld-linux.so.2"); 3526 else if (ToolChain.getArch() == llvm::Triple::arm) 3527 CmdArgs.push_back("/lib/ld-linux.so.3"); 3528 else 3529 CmdArgs.push_back("/lib64/ld-linux-x86-64.so.2"); 3530 } 3531 3532 CmdArgs.push_back("-o"); 3533 CmdArgs.push_back(Output.getFilename()); 3534 3535 if (!Args.hasArg(options::OPT_nostdlib) && 3536 !Args.hasArg(options::OPT_nostartfiles)) { 3537 const char *crt1 = NULL; 3538 if (!Args.hasArg(options::OPT_shared)){ 3539 if (Args.hasArg(options::OPT_pie)) 3540 crt1 = "Scrt1.o"; 3541 else 3542 crt1 = "crt1.o"; 3543 } 3544 if (crt1) 3545 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1))); 3546 3547 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o"))); 3548 3549 const char *crtbegin; 3550 if (Args.hasArg(options::OPT_static)) 3551 crtbegin = "crtbeginT.o"; 3552 else if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie)) 3553 crtbegin = "crtbeginS.o"; 3554 else 3555 crtbegin = "crtbegin.o"; 3556 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin))); 3557 } 3558 3559 Args.AddAllArgs(CmdArgs, options::OPT_L); 3560 3561 const ToolChain::path_list Paths = ToolChain.getFilePaths(); 3562 3563 for (ToolChain::path_list::const_iterator i = Paths.begin(), 3564 e = Paths.end(); 3565 i != e; ++i) { 3566 const std::string &s = *i; 3567 CmdArgs.push_back(Args.MakeArgString(std::string("-L") + s)); 3568 } 3569 3570 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs); 3571 3572 if (D.CCCIsCXX && !Args.hasArg(options::OPT_nostdlib)) { 3573 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs); 3574 CmdArgs.push_back("-lm"); 3575 } 3576 3577 if (Args.hasArg(options::OPT_static)) 3578 CmdArgs.push_back("--start-group"); 3579 3580 if (!Args.hasArg(options::OPT_nostdlib)) { 3581 if (!D.CCCIsCXX) 3582 CmdArgs.push_back("-lgcc"); 3583 3584 if (Args.hasArg(options::OPT_static)) { 3585 if (D.CCCIsCXX) 3586 CmdArgs.push_back("-lgcc"); 3587 } else { 3588 if (!D.CCCIsCXX) 3589 CmdArgs.push_back("--as-needed"); 3590 CmdArgs.push_back("-lgcc_s"); 3591 if (!D.CCCIsCXX) 3592 CmdArgs.push_back("--no-as-needed"); 3593 } 3594 3595 if (Args.hasArg(options::OPT_static)) 3596 CmdArgs.push_back("-lgcc_eh"); 3597 else if (!Args.hasArg(options::OPT_shared) && D.CCCIsCXX) 3598 CmdArgs.push_back("-lgcc"); 3599 3600 if (Args.hasArg(options::OPT_pthread) || 3601 Args.hasArg(options::OPT_pthreads)) 3602 CmdArgs.push_back("-lpthread"); 3603 3604 CmdArgs.push_back("-lc"); 3605 3606 if (Args.hasArg(options::OPT_static)) 3607 CmdArgs.push_back("--end-group"); 3608 else { 3609 if (!D.CCCIsCXX) 3610 CmdArgs.push_back("-lgcc"); 3611 3612 if (!D.CCCIsCXX) 3613 CmdArgs.push_back("--as-needed"); 3614 CmdArgs.push_back("-lgcc_s"); 3615 if (!D.CCCIsCXX) 3616 CmdArgs.push_back("--no-as-needed"); 3617 3618 if (!Args.hasArg(options::OPT_shared) && D.CCCIsCXX) 3619 CmdArgs.push_back("-lgcc"); 3620 } 3621 3622 3623 if (!Args.hasArg(options::OPT_nostartfiles)) { 3624 const char *crtend; 3625 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie)) 3626 crtend = "crtendS.o"; 3627 else 3628 crtend = "crtend.o"; 3629 3630 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtend))); 3631 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o"))); 3632 } 3633 } 3634 3635 if (Args.hasArg(options::OPT_use_gold_plugin)) { 3636 CmdArgs.push_back("-plugin"); 3637 std::string Plugin = ToolChain.getDriver().Dir + "/../lib/LLVMgold.so"; 3638 CmdArgs.push_back(Args.MakeArgString(Plugin)); 3639 } 3640 3641 C.addCommand(new Command(JA, *this, ToolChain.Linker.c_str(), CmdArgs)); 3642} 3643 3644void minix::Assemble::ConstructJob(Compilation &C, const JobAction &JA, 3645 const InputInfo &Output, 3646 const InputInfoList &Inputs, 3647 const ArgList &Args, 3648 const char *LinkingOutput) const { 3649 ArgStringList CmdArgs; 3650 3651 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, 3652 options::OPT_Xassembler); 3653 3654 CmdArgs.push_back("-o"); 3655 CmdArgs.push_back(Output.getFilename()); 3656 3657 for (InputInfoList::const_iterator 3658 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 3659 const InputInfo &II = *it; 3660 CmdArgs.push_back(II.getFilename()); 3661 } 3662 3663 const char *Exec = 3664 Args.MakeArgString(getToolChain().GetProgramPath("gas")); 3665 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 3666} 3667 3668void minix::Link::ConstructJob(Compilation &C, const JobAction &JA, 3669 const InputInfo &Output, 3670 const InputInfoList &Inputs, 3671 const ArgList &Args, 3672 const char *LinkingOutput) const { 3673 const Driver &D = getToolChain().getDriver(); 3674 ArgStringList CmdArgs; 3675 3676 if (Output.isFilename()) { 3677 CmdArgs.push_back("-o"); 3678 CmdArgs.push_back(Output.getFilename()); 3679 } else { 3680 assert(Output.isNothing() && "Invalid output."); 3681 } 3682 3683 if (!Args.hasArg(options::OPT_nostdlib) && 3684 !Args.hasArg(options::OPT_nostartfiles)) 3685 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath( 3686 "/usr/gnu/lib/crtso.o"))); 3687 3688 Args.AddAllArgs(CmdArgs, options::OPT_L); 3689 Args.AddAllArgs(CmdArgs, options::OPT_T_Group); 3690 Args.AddAllArgs(CmdArgs, options::OPT_e); 3691 3692 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs); 3693 3694 if (!Args.hasArg(options::OPT_nostdlib) && 3695 !Args.hasArg(options::OPT_nodefaultlibs)) { 3696 if (D.CCCIsCXX) { 3697 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs); 3698 CmdArgs.push_back("-lm"); 3699 } 3700 3701 if (Args.hasArg(options::OPT_pthread)) 3702 CmdArgs.push_back("-lpthread"); 3703 CmdArgs.push_back("-lc"); 3704 CmdArgs.push_back("-lgcc"); 3705 CmdArgs.push_back("-L/usr/gnu/lib"); 3706 // FIXME: fill in the correct search path for the final 3707 // support libraries. 3708 CmdArgs.push_back("-L/usr/gnu/lib/gcc/i686-pc-minix/4.4.3"); 3709 } 3710 3711 if (!Args.hasArg(options::OPT_nostdlib) && 3712 !Args.hasArg(options::OPT_nostartfiles)) { 3713 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath( 3714 "/usr/gnu/lib/libend.a"))); 3715 } 3716 3717 const char *Exec = 3718 Args.MakeArgString(getToolChain().GetProgramPath("/usr/gnu/bin/gld")); 3719 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 3720} 3721 3722/// DragonFly Tools 3723 3724// For now, DragonFly Assemble does just about the same as for 3725// FreeBSD, but this may change soon. 3726void dragonfly::Assemble::ConstructJob(Compilation &C, const JobAction &JA, 3727 const InputInfo &Output, 3728 const InputInfoList &Inputs, 3729 const ArgList &Args, 3730 const char *LinkingOutput) const { 3731 ArgStringList CmdArgs; 3732 3733 // When building 32-bit code on DragonFly/pc64, we have to explicitly 3734 // instruct as in the base system to assemble 32-bit code. 3735 if (getToolChain().getArchName() == "i386") 3736 CmdArgs.push_back("--32"); 3737 3738 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, 3739 options::OPT_Xassembler); 3740 3741 CmdArgs.push_back("-o"); 3742 CmdArgs.push_back(Output.getFilename()); 3743 3744 for (InputInfoList::const_iterator 3745 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 3746 const InputInfo &II = *it; 3747 CmdArgs.push_back(II.getFilename()); 3748 } 3749 3750 const char *Exec = 3751 Args.MakeArgString(getToolChain().GetProgramPath("as")); 3752 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 3753} 3754 3755void dragonfly::Link::ConstructJob(Compilation &C, const JobAction &JA, 3756 const InputInfo &Output, 3757 const InputInfoList &Inputs, 3758 const ArgList &Args, 3759 const char *LinkingOutput) const { 3760 const Driver &D = getToolChain().getDriver(); 3761 ArgStringList CmdArgs; 3762 3763 if (Args.hasArg(options::OPT_static)) { 3764 CmdArgs.push_back("-Bstatic"); 3765 } else { 3766 if (Args.hasArg(options::OPT_shared)) 3767 CmdArgs.push_back("-Bshareable"); 3768 else { 3769 CmdArgs.push_back("-dynamic-linker"); 3770 CmdArgs.push_back("/usr/libexec/ld-elf.so.2"); 3771 } 3772 } 3773 3774 // When building 32-bit code on DragonFly/pc64, we have to explicitly 3775 // instruct ld in the base system to link 32-bit code. 3776 if (getToolChain().getArchName() == "i386") { 3777 CmdArgs.push_back("-m"); 3778 CmdArgs.push_back("elf_i386"); 3779 } 3780 3781 if (Output.isFilename()) { 3782 CmdArgs.push_back("-o"); 3783 CmdArgs.push_back(Output.getFilename()); 3784 } else { 3785 assert(Output.isNothing() && "Invalid output."); 3786 } 3787 3788 if (!Args.hasArg(options::OPT_nostdlib) && 3789 !Args.hasArg(options::OPT_nostartfiles)) { 3790 if (!Args.hasArg(options::OPT_shared)) { 3791 CmdArgs.push_back( 3792 Args.MakeArgString(getToolChain().GetFilePath("crt1.o"))); 3793 CmdArgs.push_back( 3794 Args.MakeArgString(getToolChain().GetFilePath("crti.o"))); 3795 CmdArgs.push_back( 3796 Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o"))); 3797 } else { 3798 CmdArgs.push_back( 3799 Args.MakeArgString(getToolChain().GetFilePath("crti.o"))); 3800 CmdArgs.push_back( 3801 Args.MakeArgString(getToolChain().GetFilePath("crtbeginS.o"))); 3802 } 3803 } 3804 3805 Args.AddAllArgs(CmdArgs, options::OPT_L); 3806 Args.AddAllArgs(CmdArgs, options::OPT_T_Group); 3807 Args.AddAllArgs(CmdArgs, options::OPT_e); 3808 3809 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs); 3810 3811 if (!Args.hasArg(options::OPT_nostdlib) && 3812 !Args.hasArg(options::OPT_nodefaultlibs)) { 3813 // FIXME: GCC passes on -lgcc, -lgcc_pic and a whole lot of 3814 // rpaths 3815 CmdArgs.push_back("-L/usr/lib/gcc41"); 3816 3817 if (!Args.hasArg(options::OPT_static)) { 3818 CmdArgs.push_back("-rpath"); 3819 CmdArgs.push_back("/usr/lib/gcc41"); 3820 3821 CmdArgs.push_back("-rpath-link"); 3822 CmdArgs.push_back("/usr/lib/gcc41"); 3823 3824 CmdArgs.push_back("-rpath"); 3825 CmdArgs.push_back("/usr/lib"); 3826 3827 CmdArgs.push_back("-rpath-link"); 3828 CmdArgs.push_back("/usr/lib"); 3829 } 3830 3831 if (D.CCCIsCXX) { 3832 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs); 3833 CmdArgs.push_back("-lm"); 3834 } 3835 3836 if (Args.hasArg(options::OPT_shared)) { 3837 CmdArgs.push_back("-lgcc_pic"); 3838 } else { 3839 CmdArgs.push_back("-lgcc"); 3840 } 3841 3842 3843 if (Args.hasArg(options::OPT_pthread)) 3844 CmdArgs.push_back("-lpthread"); 3845 3846 if (!Args.hasArg(options::OPT_nolibc)) { 3847 CmdArgs.push_back("-lc"); 3848 } 3849 3850 if (Args.hasArg(options::OPT_shared)) { 3851 CmdArgs.push_back("-lgcc_pic"); 3852 } else { 3853 CmdArgs.push_back("-lgcc"); 3854 } 3855 } 3856 3857 if (!Args.hasArg(options::OPT_nostdlib) && 3858 !Args.hasArg(options::OPT_nostartfiles)) { 3859 if (!Args.hasArg(options::OPT_shared)) 3860 CmdArgs.push_back(Args.MakeArgString( 3861 getToolChain().GetFilePath("crtend.o"))); 3862 else 3863 CmdArgs.push_back(Args.MakeArgString( 3864 getToolChain().GetFilePath("crtendS.o"))); 3865 CmdArgs.push_back(Args.MakeArgString( 3866 getToolChain().GetFilePath("crtn.o"))); 3867 } 3868 3869 const char *Exec = 3870 Args.MakeArgString(getToolChain().GetProgramPath("ld")); 3871 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 3872} 3873 3874void visualstudio::Link::ConstructJob(Compilation &C, const JobAction &JA, 3875 const InputInfo &Output, 3876 const InputInfoList &Inputs, 3877 const ArgList &Args, 3878 const char *LinkingOutput) const { 3879 ArgStringList CmdArgs; 3880 3881 if (Output.isFilename()) { 3882 CmdArgs.push_back(Args.MakeArgString(std::string("-out:") + 3883 Output.getFilename())); 3884 } else { 3885 assert(Output.isNothing() && "Invalid output."); 3886 } 3887 3888 if (!Args.hasArg(options::OPT_nostdlib) && 3889 !Args.hasArg(options::OPT_nostartfiles)) { 3890 CmdArgs.push_back("-defaultlib:libcmt"); 3891 } 3892 3893 CmdArgs.push_back("-nologo"); 3894 3895 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs); 3896 3897 const char *Exec = 3898 Args.MakeArgString(getToolChain().GetProgramPath("link.exe")); 3899 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 3900} 3901