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