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