Tools.cpp revision 208987
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 = "i486"; 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 772 // At -O0, we use -mrelax-all by default. 773 bool IsOpt = false; 774 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) 775 IsOpt = !A->getOption().matches(options::OPT_O0); 776 if (Args.hasFlag(options::OPT_mrelax_all, 777 options::OPT_mno_relax_all, 778 !IsOpt)) 779 CmdArgs.push_back("-mrelax-all"); 780 } else if (isa<PrecompileJobAction>(JA)) { 781 // Use PCH if the user requested it, except for C++ (for now). 782 bool UsePCH = D.CCCUsePCH; 783 if (types::isCXX(Inputs[0].getType())) 784 UsePCH = false; 785 786 if (UsePCH) 787 CmdArgs.push_back("-emit-pch"); 788 else 789 CmdArgs.push_back("-emit-pth"); 790 } else { 791 assert(isa<CompileJobAction>(JA) && "Invalid action for clang tool."); 792 793 if (JA.getType() == types::TY_Nothing) { 794 CmdArgs.push_back("-fsyntax-only"); 795 } else if (JA.getType() == types::TY_LLVMAsm) { 796 CmdArgs.push_back("-emit-llvm"); 797 } else if (JA.getType() == types::TY_LLVMBC) { 798 CmdArgs.push_back("-emit-llvm-bc"); 799 } else if (JA.getType() == types::TY_PP_Asm) { 800 CmdArgs.push_back("-S"); 801 } else if (JA.getType() == types::TY_AST) { 802 CmdArgs.push_back("-emit-pch"); 803 } else if (JA.getType() == types::TY_RewrittenObjC) { 804 CmdArgs.push_back("-rewrite-objc"); 805 } else { 806 assert(JA.getType() == types::TY_PP_Asm && 807 "Unexpected output type!"); 808 } 809 } 810 811 // The make clang go fast button. 812 CmdArgs.push_back("-disable-free"); 813 814 // Disable the verification pass in -asserts builds. 815#ifdef NDEBUG 816 CmdArgs.push_back("-disable-llvm-verifier"); 817#endif 818 819 // Set the main file name, so that debug info works even with 820 // -save-temps. 821 CmdArgs.push_back("-main-file-name"); 822 CmdArgs.push_back(darwin::CC1::getBaseInputName(Args, Inputs)); 823 824 // Some flags which affect the language (via preprocessor 825 // defines). See darwin::CC1::AddCPPArgs. 826 if (Args.hasArg(options::OPT_static)) 827 CmdArgs.push_back("-static-define"); 828 829 if (isa<AnalyzeJobAction>(JA)) { 830 // Enable region store model by default. 831 CmdArgs.push_back("-analyzer-store=region"); 832 833 // Treat blocks as analysis entry points. 834 CmdArgs.push_back("-analyzer-opt-analyze-nested-blocks"); 835 836 // Add default argument set. 837 if (!Args.hasArg(options::OPT__analyzer_no_default_checks)) { 838 CmdArgs.push_back("-analyzer-check-dead-stores"); 839 // Do not enable the security-syntatic check since it 840 // it needs to be refined (known issues). 841 // CmdArgs.push_back("-analyzer-check-security-syntactic"); 842 CmdArgs.push_back("-analyzer-check-objc-mem"); 843 CmdArgs.push_back("-analyzer-eagerly-assume"); 844 CmdArgs.push_back("-analyzer-check-objc-methodsigs"); 845 // Do not enable the missing -dealloc check. 846 // '-analyzer-check-objc-missing-dealloc', 847 CmdArgs.push_back("-analyzer-check-objc-unused-ivars"); 848 } 849 850 // Set the output format. The default is plist, for (lame) historical 851 // reasons. 852 CmdArgs.push_back("-analyzer-output"); 853 if (Arg *A = Args.getLastArg(options::OPT__analyzer_output)) 854 CmdArgs.push_back(A->getValue(Args)); 855 else 856 CmdArgs.push_back("plist"); 857 858 // Disable the presentation of standard compiler warnings when 859 // using --analyze. We only want to show static analyzer diagnostics 860 // or frontend errors. 861 CmdArgs.push_back("-w"); 862 863 // Add -Xanalyzer arguments when running as analyzer. 864 Args.AddAllArgValues(CmdArgs, options::OPT_Xanalyzer); 865 } 866 867 CheckCodeGenerationOptions(D, Args); 868 869 // Perform argument translation for LLVM backend. This 870 // takes some care in reconciling with llvm-gcc. The 871 // issue is that llvm-gcc translates these options based on 872 // the values in cc1, whereas we are processing based on 873 // the driver arguments. 874 875 // This comes from the default translation the driver + cc1 876 // would do to enable flag_pic. 877 // 878 // FIXME: Centralize this code. 879 bool PICEnabled = (Args.hasArg(options::OPT_fPIC) || 880 Args.hasArg(options::OPT_fpic) || 881 Args.hasArg(options::OPT_fPIE) || 882 Args.hasArg(options::OPT_fpie)); 883 bool PICDisabled = (Args.hasArg(options::OPT_mkernel) || 884 Args.hasArg(options::OPT_static)); 885 const char *Model = getToolChain().GetForcedPicModel(); 886 if (!Model) { 887 if (Args.hasArg(options::OPT_mdynamic_no_pic)) 888 Model = "dynamic-no-pic"; 889 else if (PICDisabled) 890 Model = "static"; 891 else if (PICEnabled) 892 Model = "pic"; 893 else 894 Model = getToolChain().GetDefaultRelocationModel(); 895 } 896 if (llvm::StringRef(Model) != "pic") { 897 CmdArgs.push_back("-mrelocation-model"); 898 CmdArgs.push_back(Model); 899 } 900 901 // Infer the __PIC__ value. 902 // 903 // FIXME: This isn't quite right on Darwin, which always sets 904 // __PIC__=2. 905 if (strcmp(Model, "pic") == 0 || strcmp(Model, "dynamic-no-pic") == 0) { 906 CmdArgs.push_back("-pic-level"); 907 CmdArgs.push_back(Args.hasArg(options::OPT_fPIC) ? "2" : "1"); 908 } 909 if (!Args.hasFlag(options::OPT_fmerge_all_constants, 910 options::OPT_fno_merge_all_constants)) 911 CmdArgs.push_back("-no-merge-all-constants"); 912 913 // LLVM Code Generator Options. 914 915 // FIXME: Set --enable-unsafe-fp-math. 916 if (Args.hasFlag(options::OPT_fno_omit_frame_pointer, 917 options::OPT_fomit_frame_pointer)) 918 CmdArgs.push_back("-mdisable-fp-elim"); 919 if (!Args.hasFlag(options::OPT_fzero_initialized_in_bss, 920 options::OPT_fno_zero_initialized_in_bss)) 921 CmdArgs.push_back("-mno-zero-initialized-in-bss"); 922 923 // Decide whether to use verbose asm. Verbose assembly is the default on 924 // toolchains which have the integrated assembler on by default. 925 bool IsVerboseAsmDefault = getToolChain().IsIntegratedAssemblerDefault(); 926 if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm, 927 IsVerboseAsmDefault) || 928 Args.hasArg(options::OPT_dA)) 929 CmdArgs.push_back("-masm-verbose"); 930 931 if (Args.hasArg(options::OPT_fdebug_pass_structure)) { 932 CmdArgs.push_back("-mdebug-pass"); 933 CmdArgs.push_back("Structure"); 934 } 935 if (Args.hasArg(options::OPT_fdebug_pass_arguments)) { 936 CmdArgs.push_back("-mdebug-pass"); 937 CmdArgs.push_back("Arguments"); 938 } 939 940 // Enable -mconstructor-aliases except on darwin, where we have to 941 // work around a linker bug; see <rdar://problem/7651567>. 942 if (getToolChain().getTriple().getOS() != llvm::Triple::Darwin) 943 CmdArgs.push_back("-mconstructor-aliases"); 944 945 // This is a coarse approximation of what llvm-gcc actually does, both 946 // -fasynchronous-unwind-tables and -fnon-call-exceptions interact in more 947 // complicated ways. 948 bool AsynchronousUnwindTables = 949 Args.hasFlag(options::OPT_fasynchronous_unwind_tables, 950 options::OPT_fno_asynchronous_unwind_tables, 951 getToolChain().IsUnwindTablesDefault() && 952 !KernelOrKext); 953 if (Args.hasFlag(options::OPT_funwind_tables, options::OPT_fno_unwind_tables, 954 AsynchronousUnwindTables)) 955 CmdArgs.push_back("-munwind-tables"); 956 957 if (Arg *A = Args.getLastArg(options::OPT_flimited_precision_EQ)) { 958 CmdArgs.push_back("-mlimit-float-precision"); 959 CmdArgs.push_back(A->getValue(Args)); 960 } 961 962 // FIXME: Handle -mtune=. 963 (void) Args.hasArg(options::OPT_mtune_EQ); 964 965 if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) { 966 CmdArgs.push_back("-mcode-model"); 967 CmdArgs.push_back(A->getValue(Args)); 968 } 969 970 // Add target specific cpu and features flags. 971 switch(getToolChain().getTriple().getArch()) { 972 default: 973 break; 974 975 case llvm::Triple::arm: 976 case llvm::Triple::thumb: 977 AddARMTargetArgs(Args, CmdArgs); 978 break; 979 980 case llvm::Triple::mips: 981 case llvm::Triple::mipsel: 982 AddMIPSTargetArgs(Args, CmdArgs); 983 break; 984 985 case llvm::Triple::x86: 986 case llvm::Triple::x86_64: 987 AddX86TargetArgs(Args, CmdArgs); 988 break; 989 } 990 991 // -fno-math-errno is default. 992 if (Args.hasFlag(options::OPT_fmath_errno, 993 options::OPT_fno_math_errno, 994 false)) 995 CmdArgs.push_back("-fmath-errno"); 996 997 // Explicitly error on some things we know we don't support and can't just 998 // ignore. 999 types::ID InputType = Inputs[0].getType(); 1000 Arg *Unsupported; 1001 if ((Unsupported = Args.getLastArg(options::OPT_MG)) || 1002 (Unsupported = Args.getLastArg(options::OPT_iframework)) || 1003 (Unsupported = Args.getLastArg(options::OPT_fshort_enums))) 1004 D.Diag(clang::diag::err_drv_clang_unsupported) 1005 << Unsupported->getOption().getName(); 1006 1007 if (types::isCXX(InputType) && 1008 getToolChain().getTriple().getOS() == llvm::Triple::Darwin && 1009 getToolChain().getTriple().getArch() == llvm::Triple::x86) { 1010 if ((Unsupported = Args.getLastArg(options::OPT_fapple_kext))) 1011 D.Diag(clang::diag::err_drv_clang_unsupported_opt_cxx_darwin_i386) 1012 << Unsupported->getOption().getName(); 1013 } 1014 1015 Args.AddAllArgs(CmdArgs, options::OPT_v); 1016 Args.AddLastArg(CmdArgs, options::OPT_P); 1017 Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout); 1018 1019 // Special case debug options to only pass -g to clang. This is 1020 // wrong. 1021 Args.ClaimAllArgs(options::OPT_g_Group); 1022 if (Arg *A = Args.getLastArg(options::OPT_g_Group)) 1023 if (!A->getOption().matches(options::OPT_g0)) 1024 CmdArgs.push_back("-g"); 1025 1026 Args.AddAllArgs(CmdArgs, options::OPT_ffunction_sections); 1027 Args.AddAllArgs(CmdArgs, options::OPT_fdata_sections); 1028 1029 Args.AddLastArg(CmdArgs, options::OPT_nostdinc); 1030 Args.AddLastArg(CmdArgs, options::OPT_nostdincxx); 1031 Args.AddLastArg(CmdArgs, options::OPT_nobuiltininc); 1032 1033 // Pass the path to compiler resource files. 1034 CmdArgs.push_back("-resource-dir"); 1035 CmdArgs.push_back(D.ResourceDir.c_str()); 1036 1037 // Add preprocessing options like -I, -D, etc. if we are using the 1038 // preprocessor. 1039 // 1040 // FIXME: Support -fpreprocessed 1041 if (types::getPreprocessedType(InputType) != types::TY_INVALID) 1042 AddPreprocessingOptions(D, Args, CmdArgs, Output, Inputs); 1043 1044 // Manually translate -O to -O2 and -O4 to -O3; let clang reject 1045 // others. 1046 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) { 1047 if (A->getOption().matches(options::OPT_O4)) 1048 CmdArgs.push_back("-O3"); 1049 else if (A->getOption().matches(options::OPT_O) && 1050 A->getValue(Args)[0] == '\0') 1051 CmdArgs.push_back("-O2"); 1052 else 1053 A->render(Args, CmdArgs); 1054 } 1055 1056 Args.AddAllArgs(CmdArgs, options::OPT_W_Group); 1057 Args.AddLastArg(CmdArgs, options::OPT_pedantic); 1058 Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors); 1059 Args.AddLastArg(CmdArgs, options::OPT_w); 1060 1061 // Handle -{std, ansi, trigraphs} -- take the last of -{std, ansi} 1062 // (-ansi is equivalent to -std=c89). 1063 // 1064 // If a std is supplied, only add -trigraphs if it follows the 1065 // option. 1066 if (Arg *Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) { 1067 if (Std->getOption().matches(options::OPT_ansi)) 1068 if (types::isCXX(InputType)) 1069 CmdArgs.push_back("-std=c++98"); 1070 else 1071 CmdArgs.push_back("-std=c89"); 1072 else 1073 Std->render(Args, CmdArgs); 1074 1075 if (Arg *A = Args.getLastArg(options::OPT_trigraphs)) 1076 if (A->getIndex() > Std->getIndex()) 1077 A->render(Args, CmdArgs); 1078 } else { 1079 // Honor -std-default. 1080 // 1081 // FIXME: Clang doesn't correctly handle -std= when the input language 1082 // doesn't match. For the time being just ignore this for C++ inputs; 1083 // eventually we want to do all the standard defaulting here instead of 1084 // splitting it between the driver and clang -cc1. 1085 if (!types::isCXX(InputType)) 1086 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ, 1087 "-std=", /*Joined=*/true); 1088 Args.AddLastArg(CmdArgs, options::OPT_trigraphs); 1089 } 1090 1091 // Translate GCC's misnamer '-fasm' arguments to '-fgnu-keywords'. 1092 if (Arg *Asm = Args.getLastArg(options::OPT_fasm, options::OPT_fno_asm)) { 1093 if (Asm->getOption().matches(options::OPT_fasm)) 1094 CmdArgs.push_back("-fgnu-keywords"); 1095 else 1096 CmdArgs.push_back("-fno-gnu-keywords"); 1097 } 1098 1099 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_depth_)) { 1100 CmdArgs.push_back("-ftemplate-depth"); 1101 CmdArgs.push_back(A->getValue(Args)); 1102 } 1103 1104 if (Args.hasArg(options::OPT__relocatable_pch)) 1105 CmdArgs.push_back("-relocatable-pch"); 1106 1107 if (Arg *A = Args.getLastArg(options::OPT_fconstant_string_class_EQ)) { 1108 CmdArgs.push_back("-fconstant-string-class"); 1109 CmdArgs.push_back(A->getValue(Args)); 1110 } 1111 1112 if (Arg *A = Args.getLastArg(options::OPT_ftabstop_EQ)) { 1113 CmdArgs.push_back("-ftabstop"); 1114 CmdArgs.push_back(A->getValue(Args)); 1115 } 1116 1117 CmdArgs.push_back("-ferror-limit"); 1118 if (Arg *A = Args.getLastArg(options::OPT_ferror_limit_EQ)) 1119 CmdArgs.push_back(A->getValue(Args)); 1120 else 1121 CmdArgs.push_back("19"); 1122 1123 if (Arg *A = Args.getLastArg(options::OPT_fmacro_backtrace_limit_EQ)) { 1124 CmdArgs.push_back("-fmacro-backtrace-limit"); 1125 CmdArgs.push_back(A->getValue(Args)); 1126 } 1127 1128 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_backtrace_limit_EQ)) { 1129 CmdArgs.push_back("-ftemplate-backtrace-limit"); 1130 CmdArgs.push_back(A->getValue(Args)); 1131 } 1132 1133 // Pass -fmessage-length=. 1134 CmdArgs.push_back("-fmessage-length"); 1135 if (Arg *A = Args.getLastArg(options::OPT_fmessage_length_EQ)) { 1136 CmdArgs.push_back(A->getValue(Args)); 1137 } else { 1138 // If -fmessage-length=N was not specified, determine whether this is a 1139 // terminal and, if so, implicitly define -fmessage-length appropriately. 1140 unsigned N = llvm::sys::Process::StandardErrColumns(); 1141 CmdArgs.push_back(Args.MakeArgString(llvm::Twine(N))); 1142 } 1143 1144 if (const Arg *A = Args.getLastArg(options::OPT_fvisibility_EQ)) { 1145 CmdArgs.push_back("-fvisibility"); 1146 CmdArgs.push_back(A->getValue(Args)); 1147 } 1148 1149 // -fhosted is default. 1150 if (KernelOrKext || Args.hasFlag(options::OPT_ffreestanding, 1151 options::OPT_fhosted, 1152 false)) 1153 CmdArgs.push_back("-ffreestanding"); 1154 1155 // Forward -f (flag) options which we can pass directly. 1156 Args.AddLastArg(CmdArgs, options::OPT_fcatch_undefined_behavior); 1157 Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls); 1158 Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions); 1159 Args.AddLastArg(CmdArgs, options::OPT_fformat_extensions); 1160 1161 // -flax-vector-conversions is default. 1162 if (!Args.hasFlag(options::OPT_flax_vector_conversions, 1163 options::OPT_fno_lax_vector_conversions)) 1164 CmdArgs.push_back("-fno-lax-vector-conversions"); 1165 1166 // Handle -fobjc-gc and -fobjc-gc-only. They are exclusive, and -fobjc-gc-only 1167 // takes precedence. 1168 const Arg *GCArg = Args.getLastArg(options::OPT_fobjc_gc_only); 1169 if (!GCArg) 1170 GCArg = Args.getLastArg(options::OPT_fobjc_gc); 1171 if (GCArg) { 1172 if (getToolChain().SupportsObjCGC()) { 1173 GCArg->render(Args, CmdArgs); 1174 } else { 1175 // FIXME: We should move this to a hard error. 1176 D.Diag(clang::diag::warn_drv_objc_gc_unsupported) 1177 << GCArg->getAsString(Args); 1178 } 1179 } 1180 1181 Args.AddLastArg(CmdArgs, options::OPT_fno_caret_diagnostics); 1182 Args.AddLastArg(CmdArgs, options::OPT_fno_show_column); 1183 Args.AddLastArg(CmdArgs, options::OPT_fobjc_sender_dependent_dispatch); 1184 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_print_source_range_info); 1185 Args.AddLastArg(CmdArgs, options::OPT_ftime_report); 1186 Args.AddLastArg(CmdArgs, options::OPT_ftrapv); 1187 Args.AddLastArg(CmdArgs, options::OPT_fwritable_strings); 1188 1189 Args.AddLastArg(CmdArgs, options::OPT_pthread); 1190 1191 // -stack-protector=0 is default. 1192 unsigned StackProtectorLevel = 0; 1193 if (Arg *A = Args.getLastArg(options::OPT_fno_stack_protector, 1194 options::OPT_fstack_protector_all, 1195 options::OPT_fstack_protector)) { 1196 if (A->getOption().matches(options::OPT_fstack_protector)) 1197 StackProtectorLevel = 1; 1198 else if (A->getOption().matches(options::OPT_fstack_protector_all)) 1199 StackProtectorLevel = 2; 1200 } else 1201 StackProtectorLevel = getToolChain().GetDefaultStackProtectorLevel(); 1202 if (StackProtectorLevel) { 1203 CmdArgs.push_back("-stack-protector"); 1204 CmdArgs.push_back(Args.MakeArgString(llvm::Twine(StackProtectorLevel))); 1205 } 1206 1207 // Forward -f options with positive and negative forms; we translate 1208 // these by hand. 1209 1210 // -fbuiltin is default. 1211 if (!Args.hasFlag(options::OPT_fbuiltin, options::OPT_fno_builtin)) 1212 CmdArgs.push_back("-fno-builtin"); 1213 1214 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new, 1215 options::OPT_fno_assume_sane_operator_new)) 1216 CmdArgs.push_back("-fno-assume-sane-operator-new"); 1217 1218 // -fblocks=0 is default. 1219 if (Args.hasFlag(options::OPT_fblocks, options::OPT_fno_blocks, 1220 getToolChain().IsBlocksDefault())) { 1221 CmdArgs.push_back("-fblocks"); 1222 } 1223 1224 // -faccess-control is default. 1225 if (Args.hasFlag(options::OPT_fno_access_control, 1226 options::OPT_faccess_control, 1227 false)) 1228 CmdArgs.push_back("-fno-access-control"); 1229 1230 // -fexceptions=0 is default. 1231 if (needsExceptions(Args, InputType, getToolChain().getTriple())) 1232 CmdArgs.push_back("-fexceptions"); 1233 1234 if (getToolChain().UseSjLjExceptions()) 1235 CmdArgs.push_back("-fsjlj-exceptions"); 1236 1237 // -frtti is default. 1238 if (KernelOrKext || 1239 !Args.hasFlag(options::OPT_frtti, options::OPT_fno_rtti)) 1240 CmdArgs.push_back("-fno-rtti"); 1241 1242 // -fsigned-char is default. 1243 if (!Args.hasFlag(options::OPT_fsigned_char, options::OPT_funsigned_char, 1244 isSignedCharDefault(getToolChain().getTriple()))) 1245 CmdArgs.push_back("-fno-signed-char"); 1246 1247 // -fthreadsafe-static is default. 1248 if (!Args.hasFlag(options::OPT_fthreadsafe_statics, 1249 options::OPT_fno_threadsafe_statics)) 1250 CmdArgs.push_back("-fno-threadsafe-statics"); 1251 1252 // -fuse-cxa-atexit is default. 1253 if (KernelOrKext || !Args.hasFlag(options::OPT_fuse_cxa_atexit, 1254 options::OPT_fno_use_cxa_atexit)) 1255 CmdArgs.push_back("-fno-use-cxa-atexit"); 1256 1257 // -fms-extensions=0 is default. 1258 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions, 1259 getToolChain().getTriple().getOS() == llvm::Triple::Win32)) 1260 CmdArgs.push_back("-fms-extensions"); 1261 1262 // -fgnu-keywords default varies depending on language; only pass if 1263 // specified. 1264 if (Arg *A = Args.getLastArg(options::OPT_fgnu_keywords, 1265 options::OPT_fno_gnu_keywords)) 1266 A->render(Args, CmdArgs); 1267 1268 // -fnext-runtime is default. 1269 if (!Args.hasFlag(options::OPT_fnext_runtime, options::OPT_fgnu_runtime, 1270 getToolChain().getTriple().getOS() == llvm::Triple::Darwin)) 1271 CmdArgs.push_back("-fgnu-runtime"); 1272 1273 // -fobjc-nonfragile-abi=0 is default. 1274 if (types::isObjC(InputType)) { 1275 unsigned Version = 1; 1276 if (Args.hasArg(options::OPT_fobjc_nonfragile_abi) || 1277 getToolChain().IsObjCNonFragileABIDefault()) 1278 Version = 2; 1279 if (Arg *A = Args.getLastArg(options::OPT_fobjc_abi_version_EQ)) { 1280 if (llvm::StringRef(A->getValue(Args)) == "1") 1281 Version = 1; 1282 else if (llvm::StringRef(A->getValue(Args)) == "2") 1283 Version = 2; 1284 else 1285 D.Diag(clang::diag::err_drv_clang_unsupported) << A->getAsString(Args); 1286 } 1287 1288 if (Version == 2) { 1289 CmdArgs.push_back("-fobjc-nonfragile-abi"); 1290 1291 // -fobjc-dispatch-method is only relevant with the nonfragile-abi, and 1292 // legacy is the default. 1293 if (!Args.hasFlag(options::OPT_fobjc_legacy_dispatch, 1294 options::OPT_fno_objc_legacy_dispatch, 1295 getToolChain().IsObjCLegacyDispatchDefault())) { 1296 if (getToolChain().UseObjCMixedDispatch()) 1297 CmdArgs.push_back("-fobjc-dispatch-method=mixed"); 1298 else 1299 CmdArgs.push_back("-fobjc-dispatch-method=non-legacy"); 1300 } 1301 } 1302 1303 // FIXME: -fobjc-nonfragile-abi2 is a transient option meant to expose 1304 // features in testing. It will eventually be removed. 1305 if (Args.hasArg(options::OPT_fobjc_nonfragile_abi2)) 1306 CmdArgs.push_back("-fobjc-nonfragile-abi2"); 1307 } 1308 1309 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new, 1310 options::OPT_fno_assume_sane_operator_new)) 1311 CmdArgs.push_back("-fno-assume-sane-operator-new"); 1312 1313 // -fconstant-cfstrings is default, and may be subject to argument translation 1314 // on Darwin. 1315 if (!Args.hasFlag(options::OPT_fconstant_cfstrings, 1316 options::OPT_fno_constant_cfstrings) || 1317 !Args.hasFlag(options::OPT_mconstant_cfstrings, 1318 options::OPT_mno_constant_cfstrings)) 1319 CmdArgs.push_back("-fno-constant-cfstrings"); 1320 1321 // -fshort-wchar default varies depending on platform; only 1322 // pass if specified. 1323 if (Arg *A = Args.getLastArg(options::OPT_fshort_wchar)) 1324 A->render(Args, CmdArgs); 1325 1326 // -fno-pascal-strings is default, only pass non-default. If the tool chain 1327 // happened to translate to -mpascal-strings, we want to back translate here. 1328 // 1329 // FIXME: This is gross; that translation should be pulled from the 1330 // tool chain. 1331 if (Args.hasFlag(options::OPT_fpascal_strings, 1332 options::OPT_fno_pascal_strings, 1333 false) || 1334 Args.hasFlag(options::OPT_mpascal_strings, 1335 options::OPT_mno_pascal_strings, 1336 false)) 1337 CmdArgs.push_back("-fpascal-strings"); 1338 1339 // -fcommon is default, only pass non-default. 1340 if (!Args.hasFlag(options::OPT_fcommon, options::OPT_fno_common)) 1341 CmdArgs.push_back("-fno-common"); 1342 1343 // -fsigned-bitfields is default, and clang doesn't yet support 1344 // --funsigned-bitfields. 1345 if (!Args.hasFlag(options::OPT_fsigned_bitfields, 1346 options::OPT_funsigned_bitfields)) 1347 D.Diag(clang::diag::warn_drv_clang_unsupported) 1348 << Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args); 1349 1350 // -fdiagnostics-fixit-info is default, only pass non-default. 1351 if (!Args.hasFlag(options::OPT_fdiagnostics_fixit_info, 1352 options::OPT_fno_diagnostics_fixit_info)) 1353 CmdArgs.push_back("-fno-diagnostics-fixit-info"); 1354 1355 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_binary); 1356 1357 // Enable -fdiagnostics-show-option by default. 1358 if (Args.hasFlag(options::OPT_fdiagnostics_show_option, 1359 options::OPT_fno_diagnostics_show_option)) 1360 CmdArgs.push_back("-fdiagnostics-show-option"); 1361 1362 if (const Arg *A = 1363 Args.getLastArg(options::OPT_fdiagnostics_show_category_EQ)) { 1364 CmdArgs.push_back("-fdiagnostics-show-category"); 1365 CmdArgs.push_back(A->getValue(Args)); 1366 } 1367 1368 // Color diagnostics are the default, unless the terminal doesn't support 1369 // them. 1370 if (Args.hasFlag(options::OPT_fcolor_diagnostics, 1371 options::OPT_fno_color_diagnostics) && 1372 llvm::sys::Process::StandardErrHasColors()) 1373 CmdArgs.push_back("-fcolor-diagnostics"); 1374 1375 if (!Args.hasFlag(options::OPT_fshow_source_location, 1376 options::OPT_fno_show_source_location)) 1377 CmdArgs.push_back("-fno-show-source-location"); 1378 1379 // -fdollars-in-identifiers default varies depending on platform and 1380 // language; only pass if specified. 1381 if (Arg *A = Args.getLastArg(options::OPT_fdollars_in_identifiers, 1382 options::OPT_fno_dollars_in_identifiers)) { 1383 if (A->getOption().matches(options::OPT_fdollars_in_identifiers)) 1384 CmdArgs.push_back("-fdollars-in-identifiers"); 1385 else 1386 CmdArgs.push_back("-fno-dollars-in-identifiers"); 1387 } 1388 1389 // -funit-at-a-time is default, and we don't support -fno-unit-at-a-time for 1390 // practical purposes. 1391 if (Arg *A = Args.getLastArg(options::OPT_funit_at_a_time, 1392 options::OPT_fno_unit_at_a_time)) { 1393 if (A->getOption().matches(options::OPT_fno_unit_at_a_time)) 1394 D.Diag(clang::diag::warn_drv_clang_unsupported) << A->getAsString(Args); 1395 } 1396 1397 // Default to -fno-builtin-str{cat,cpy} on Darwin for ARM. 1398 // 1399 // FIXME: This is disabled until clang -cc1 supports -fno-builtin-foo. PR4941. 1400#if 0 1401 if (getToolChain().getTriple().getOS() == llvm::Triple::Darwin && 1402 (getToolChain().getTriple().getArch() == llvm::Triple::arm || 1403 getToolChain().getTriple().getArch() == llvm::Triple::thumb)) { 1404 if (!Args.hasArg(options::OPT_fbuiltin_strcat)) 1405 CmdArgs.push_back("-fno-builtin-strcat"); 1406 if (!Args.hasArg(options::OPT_fbuiltin_strcpy)) 1407 CmdArgs.push_back("-fno-builtin-strcpy"); 1408 } 1409#endif 1410 1411 if (Arg *A = Args.getLastArg(options::OPT_traditional, 1412 options::OPT_traditional_cpp)) 1413 D.Diag(clang::diag::err_drv_clang_unsupported) << A->getAsString(Args); 1414 1415 Args.AddLastArg(CmdArgs, options::OPT_dM); 1416 Args.AddLastArg(CmdArgs, options::OPT_dD); 1417 1418 // Forward -Xclang arguments to -cc1, and -mllvm arguments to the LLVM option 1419 // parser. 1420 Args.AddAllArgValues(CmdArgs, options::OPT_Xclang); 1421 for (arg_iterator it = Args.filtered_begin(options::OPT_mllvm), 1422 ie = Args.filtered_end(); it != ie; ++it) { 1423 it->claim(); 1424 1425 // We translate this by hand to the -cc1 argument, since nightly test uses 1426 // it and developers have been trained to spell it with -mllvm. 1427 if (llvm::StringRef(it->getValue(Args, 0)) == "-disable-llvm-optzns") 1428 CmdArgs.push_back("-disable-llvm-optzns"); 1429 else 1430 it->render(Args, CmdArgs); 1431 } 1432 1433 if (Output.getType() == types::TY_Dependencies) { 1434 // Handled with other dependency code. 1435 } else if (Output.isPipe()) { 1436 CmdArgs.push_back("-o"); 1437 CmdArgs.push_back("-"); 1438 } else if (Output.isFilename()) { 1439 CmdArgs.push_back("-o"); 1440 CmdArgs.push_back(Output.getFilename()); 1441 } else { 1442 assert(Output.isNothing() && "Invalid output."); 1443 } 1444 1445 for (InputInfoList::const_iterator 1446 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 1447 const InputInfo &II = *it; 1448 CmdArgs.push_back("-x"); 1449 CmdArgs.push_back(types::getTypeName(II.getType())); 1450 if (II.isPipe()) 1451 CmdArgs.push_back("-"); 1452 else if (II.isFilename()) 1453 CmdArgs.push_back(II.getFilename()); 1454 else 1455 II.getInputArg().renderAsInput(Args, CmdArgs); 1456 } 1457 1458 Args.AddAllArgs(CmdArgs, options::OPT_undef); 1459 1460 const char *Exec = 1461 Args.MakeArgString(getToolChain().GetProgramPath(C, "clang")); 1462 1463 // Optionally embed the -cc1 level arguments into the debug info, for build 1464 // analysis. 1465 if (getToolChain().UseDwarfDebugFlags()) { 1466 llvm::SmallString<256> Flags; 1467 Flags += Exec; 1468 for (unsigned i = 0, e = CmdArgs.size(); i != e; ++i) { 1469 Flags += " "; 1470 Flags += CmdArgs[i]; 1471 } 1472 CmdArgs.push_back("-dwarf-debug-flags"); 1473 CmdArgs.push_back(Args.MakeArgString(Flags.str())); 1474 } 1475 1476 Dest.addCommand(new Command(JA, *this, Exec, CmdArgs)); 1477 1478 // Explicitly warn that these options are unsupported, even though 1479 // we are allowing compilation to continue. 1480 for (arg_iterator it = Args.filtered_begin(options::OPT_pg), 1481 ie = Args.filtered_end(); it != ie; ++it) { 1482 it->claim(); 1483 D.Diag(clang::diag::warn_drv_clang_unsupported) << it->getAsString(Args); 1484 } 1485 1486 // Claim some arguments which clang supports automatically. 1487 1488 // -fpch-preprocess is used with gcc to add a special marker in the output to 1489 // include the PCH file. Clang's PTH solution is completely transparent, so we 1490 // do not need to deal with it at all. 1491 Args.ClaimAllArgs(options::OPT_fpch_preprocess); 1492 1493 // Claim some arguments which clang doesn't support, but we don't 1494 // care to warn the user about. 1495 Args.ClaimAllArgs(options::OPT_clang_ignored_f_Group); 1496 Args.ClaimAllArgs(options::OPT_clang_ignored_m_Group); 1497} 1498 1499void ClangAs::ConstructJob(Compilation &C, const JobAction &JA, 1500 Job &Dest, 1501 const InputInfo &Output, 1502 const InputInfoList &Inputs, 1503 const ArgList &Args, 1504 const char *LinkingOutput) const { 1505 const Driver &D = getToolChain().getDriver(); 1506 ArgStringList CmdArgs; 1507 1508 assert(Inputs.size() == 1 && "Unexpected number of inputs."); 1509 const InputInfo &Input = Inputs[0]; 1510 1511 // Invoke ourselves in -cc1as mode. 1512 // 1513 // FIXME: Implement custom jobs for internal actions. 1514 CmdArgs.push_back("-cc1as"); 1515 1516 // Add the "effective" target triple. 1517 CmdArgs.push_back("-triple"); 1518 std::string TripleStr = getEffectiveClangTriple(D, getToolChain(), Args); 1519 CmdArgs.push_back(Args.MakeArgString(TripleStr)); 1520 1521 // Set the output mode, we currently only expect to be used as a real 1522 // assembler. 1523 CmdArgs.push_back("-filetype"); 1524 CmdArgs.push_back("obj"); 1525 1526 // At -O0, we use -mrelax-all by default. 1527 bool IsOpt = false; 1528 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) 1529 IsOpt = !A->getOption().matches(options::OPT_O0); 1530 if (Args.hasFlag(options::OPT_mrelax_all, 1531 options::OPT_mno_relax_all, 1532 !IsOpt)) 1533 CmdArgs.push_back("-mrelax-all"); 1534 1535 // FIXME: Add -force_cpusubtype_ALL support, once we have it. 1536 1537 // FIXME: Add -g support, once we have it. 1538 1539 // FIXME: Add -static support, once we have it. 1540 1541 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, 1542 options::OPT_Xassembler); 1543 1544 assert(Output.isFilename() && "Unexpected lipo output."); 1545 CmdArgs.push_back("-o"); 1546 CmdArgs.push_back(Output.getFilename()); 1547 1548 if (Input.isPipe()) { 1549 CmdArgs.push_back("-"); 1550 } else { 1551 assert(Input.isFilename() && "Invalid input."); 1552 CmdArgs.push_back(Input.getFilename()); 1553 } 1554 1555 const char *Exec = 1556 Args.MakeArgString(getToolChain().GetProgramPath(C, "clang")); 1557 Dest.addCommand(new Command(JA, *this, Exec, CmdArgs)); 1558} 1559 1560void gcc::Common::ConstructJob(Compilation &C, const JobAction &JA, 1561 Job &Dest, 1562 const InputInfo &Output, 1563 const InputInfoList &Inputs, 1564 const ArgList &Args, 1565 const char *LinkingOutput) const { 1566 const Driver &D = getToolChain().getDriver(); 1567 ArgStringList CmdArgs; 1568 1569 for (ArgList::const_iterator 1570 it = Args.begin(), ie = Args.end(); it != ie; ++it) { 1571 Arg *A = *it; 1572 if (A->getOption().hasForwardToGCC()) { 1573 // It is unfortunate that we have to claim here, as this means 1574 // we will basically never report anything interesting for 1575 // platforms using a generic gcc, even if we are just using gcc 1576 // to get to the assembler. 1577 A->claim(); 1578 A->render(Args, CmdArgs); 1579 } 1580 } 1581 1582 RenderExtraToolArgs(JA, CmdArgs); 1583 1584 // If using a driver driver, force the arch. 1585 const std::string &Arch = getToolChain().getArchName(); 1586 if (getToolChain().getTriple().getOS() == llvm::Triple::Darwin) { 1587 CmdArgs.push_back("-arch"); 1588 1589 // FIXME: Remove these special cases. 1590 if (Arch == "powerpc") 1591 CmdArgs.push_back("ppc"); 1592 else if (Arch == "powerpc64") 1593 CmdArgs.push_back("ppc64"); 1594 else 1595 CmdArgs.push_back(Args.MakeArgString(Arch)); 1596 } 1597 1598 // Try to force gcc to match the tool chain we want, if we recognize 1599 // the arch. 1600 // 1601 // FIXME: The triple class should directly provide the information we want 1602 // here. 1603 if (Arch == "i386" || Arch == "powerpc") 1604 CmdArgs.push_back("-m32"); 1605 else if (Arch == "x86_64" || Arch == "powerpc64") 1606 CmdArgs.push_back("-m64"); 1607 1608 if (Output.isPipe()) { 1609 CmdArgs.push_back("-o"); 1610 CmdArgs.push_back("-"); 1611 } else if (Output.isFilename()) { 1612 CmdArgs.push_back("-o"); 1613 CmdArgs.push_back(Output.getFilename()); 1614 } else { 1615 assert(Output.isNothing() && "Unexpected output"); 1616 CmdArgs.push_back("-fsyntax-only"); 1617 } 1618 1619 1620 // Only pass -x if gcc will understand it; otherwise hope gcc 1621 // understands the suffix correctly. The main use case this would go 1622 // wrong in is for linker inputs if they happened to have an odd 1623 // suffix; really the only way to get this to happen is a command 1624 // like '-x foobar a.c' which will treat a.c like a linker input. 1625 // 1626 // FIXME: For the linker case specifically, can we safely convert 1627 // inputs into '-Wl,' options? 1628 for (InputInfoList::const_iterator 1629 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 1630 const InputInfo &II = *it; 1631 1632 // Don't try to pass LLVM or AST inputs to a generic gcc. 1633 if (II.getType() == types::TY_LLVMBC) 1634 D.Diag(clang::diag::err_drv_no_linker_llvm_support) 1635 << getToolChain().getTripleString(); 1636 else if (II.getType() == types::TY_AST) 1637 D.Diag(clang::diag::err_drv_no_ast_support) 1638 << getToolChain().getTripleString(); 1639 1640 if (types::canTypeBeUserSpecified(II.getType())) { 1641 CmdArgs.push_back("-x"); 1642 CmdArgs.push_back(types::getTypeName(II.getType())); 1643 } 1644 1645 if (II.isPipe()) 1646 CmdArgs.push_back("-"); 1647 else if (II.isFilename()) 1648 CmdArgs.push_back(II.getFilename()); 1649 else 1650 // Don't render as input, we need gcc to do the translations. 1651 II.getInputArg().render(Args, CmdArgs); 1652 } 1653 1654 const char *GCCName = getToolChain().getDriver().CCCGenericGCCName.c_str(); 1655 const char *Exec = 1656 Args.MakeArgString(getToolChain().GetProgramPath(C, GCCName)); 1657 Dest.addCommand(new Command(JA, *this, Exec, CmdArgs)); 1658} 1659 1660void gcc::Preprocess::RenderExtraToolArgs(const JobAction &JA, 1661 ArgStringList &CmdArgs) const { 1662 CmdArgs.push_back("-E"); 1663} 1664 1665void gcc::Precompile::RenderExtraToolArgs(const JobAction &JA, 1666 ArgStringList &CmdArgs) const { 1667 // The type is good enough. 1668} 1669 1670void gcc::Compile::RenderExtraToolArgs(const JobAction &JA, 1671 ArgStringList &CmdArgs) const { 1672 const Driver &D = getToolChain().getDriver(); 1673 1674 // If -flto, etc. are present then make sure not to force assembly output. 1675 if (JA.getType() == types::TY_LLVMBC) 1676 CmdArgs.push_back("-c"); 1677 else { 1678 if (JA.getType() != types::TY_PP_Asm) 1679 D.Diag(clang::diag::err_drv_invalid_gcc_output_type) 1680 << getTypeName(JA.getType()); 1681 1682 CmdArgs.push_back("-S"); 1683 } 1684} 1685 1686void gcc::Assemble::RenderExtraToolArgs(const JobAction &JA, 1687 ArgStringList &CmdArgs) const { 1688 CmdArgs.push_back("-c"); 1689} 1690 1691void gcc::Link::RenderExtraToolArgs(const JobAction &JA, 1692 ArgStringList &CmdArgs) const { 1693 // The types are (hopefully) good enough. 1694} 1695 1696const char *darwin::CC1::getCC1Name(types::ID Type) const { 1697 switch (Type) { 1698 default: 1699 assert(0 && "Unexpected type for Darwin CC1 tool."); 1700 case types::TY_Asm: 1701 case types::TY_C: case types::TY_CHeader: 1702 case types::TY_PP_C: case types::TY_PP_CHeader: 1703 return "cc1"; 1704 case types::TY_ObjC: case types::TY_ObjCHeader: 1705 case types::TY_PP_ObjC: case types::TY_PP_ObjCHeader: 1706 return "cc1obj"; 1707 case types::TY_CXX: case types::TY_CXXHeader: 1708 case types::TY_PP_CXX: case types::TY_PP_CXXHeader: 1709 return "cc1plus"; 1710 case types::TY_ObjCXX: case types::TY_ObjCXXHeader: 1711 case types::TY_PP_ObjCXX: case types::TY_PP_ObjCXXHeader: 1712 return "cc1objplus"; 1713 } 1714} 1715 1716const char *darwin::CC1::getBaseInputName(const ArgList &Args, 1717 const InputInfoList &Inputs) { 1718 llvm::sys::Path P(Inputs[0].getBaseInput()); 1719 return Args.MakeArgString(P.getLast()); 1720} 1721 1722const char *darwin::CC1::getBaseInputStem(const ArgList &Args, 1723 const InputInfoList &Inputs) { 1724 const char *Str = getBaseInputName(Args, Inputs); 1725 1726 if (const char *End = strchr(Str, '.')) 1727 return Args.MakeArgString(std::string(Str, End)); 1728 1729 return Str; 1730} 1731 1732const char * 1733darwin::CC1::getDependencyFileName(const ArgList &Args, 1734 const InputInfoList &Inputs) { 1735 // FIXME: Think about this more. 1736 std::string Res; 1737 1738 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) { 1739 std::string Str(OutputOpt->getValue(Args)); 1740 1741 Res = Str.substr(0, Str.rfind('.')); 1742 } else 1743 Res = darwin::CC1::getBaseInputStem(Args, Inputs); 1744 1745 return Args.MakeArgString(Res + ".d"); 1746} 1747 1748void darwin::CC1::AddCC1Args(const ArgList &Args, 1749 ArgStringList &CmdArgs) const { 1750 const Driver &D = getToolChain().getDriver(); 1751 1752 CheckCodeGenerationOptions(D, Args); 1753 1754 // Derived from cc1 spec. 1755 if (!Args.hasArg(options::OPT_mkernel) && !Args.hasArg(options::OPT_static) && 1756 !Args.hasArg(options::OPT_mdynamic_no_pic)) 1757 CmdArgs.push_back("-fPIC"); 1758 1759 if (getToolChain().getTriple().getArch() == llvm::Triple::arm || 1760 getToolChain().getTriple().getArch() == llvm::Triple::thumb) { 1761 if (!Args.hasArg(options::OPT_fbuiltin_strcat)) 1762 CmdArgs.push_back("-fno-builtin-strcat"); 1763 if (!Args.hasArg(options::OPT_fbuiltin_strcpy)) 1764 CmdArgs.push_back("-fno-builtin-strcpy"); 1765 } 1766 1767 // gcc has some code here to deal with when no -mmacosx-version-min 1768 // and no -miphoneos-version-min is present, but this never happens 1769 // due to tool chain specific argument translation. 1770 1771 if (Args.hasArg(options::OPT_g_Flag) && 1772 !Args.hasArg(options::OPT_fno_eliminate_unused_debug_symbols)) 1773 CmdArgs.push_back("-feliminate-unused-debug-symbols"); 1774} 1775 1776void darwin::CC1::AddCC1OptionsArgs(const ArgList &Args, ArgStringList &CmdArgs, 1777 const InputInfoList &Inputs, 1778 const ArgStringList &OutputArgs) const { 1779 const Driver &D = getToolChain().getDriver(); 1780 1781 // Derived from cc1_options spec. 1782 if (Args.hasArg(options::OPT_fast) || 1783 Args.hasArg(options::OPT_fastf) || 1784 Args.hasArg(options::OPT_fastcp)) 1785 CmdArgs.push_back("-O3"); 1786 1787 if (Arg *A = Args.getLastArg(options::OPT_pg)) 1788 if (Args.hasArg(options::OPT_fomit_frame_pointer)) 1789 D.Diag(clang::diag::err_drv_argument_not_allowed_with) 1790 << A->getAsString(Args) << "-fomit-frame-pointer"; 1791 1792 AddCC1Args(Args, CmdArgs); 1793 1794 if (!Args.hasArg(options::OPT_Q)) 1795 CmdArgs.push_back("-quiet"); 1796 1797 CmdArgs.push_back("-dumpbase"); 1798 CmdArgs.push_back(darwin::CC1::getBaseInputName(Args, Inputs)); 1799 1800 Args.AddAllArgs(CmdArgs, options::OPT_d_Group); 1801 1802 Args.AddAllArgs(CmdArgs, options::OPT_m_Group); 1803 Args.AddAllArgs(CmdArgs, options::OPT_a_Group); 1804 1805 // FIXME: The goal is to use the user provided -o if that is our 1806 // final output, otherwise to drive from the original input 1807 // name. Find a clean way to go about this. 1808 if ((Args.hasArg(options::OPT_c) || Args.hasArg(options::OPT_S)) && 1809 Args.hasArg(options::OPT_o)) { 1810 Arg *OutputOpt = Args.getLastArg(options::OPT_o); 1811 CmdArgs.push_back("-auxbase-strip"); 1812 CmdArgs.push_back(OutputOpt->getValue(Args)); 1813 } else { 1814 CmdArgs.push_back("-auxbase"); 1815 CmdArgs.push_back(darwin::CC1::getBaseInputStem(Args, Inputs)); 1816 } 1817 1818 Args.AddAllArgs(CmdArgs, options::OPT_g_Group); 1819 1820 Args.AddAllArgs(CmdArgs, options::OPT_O); 1821 // FIXME: -Wall is getting some special treatment. Investigate. 1822 Args.AddAllArgs(CmdArgs, options::OPT_W_Group, options::OPT_pedantic_Group); 1823 Args.AddLastArg(CmdArgs, options::OPT_w); 1824 Args.AddAllArgs(CmdArgs, options::OPT_std_EQ, options::OPT_ansi, 1825 options::OPT_trigraphs); 1826 if (!Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) { 1827 // Honor -std-default. 1828 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ, 1829 "-std=", /*Joined=*/true); 1830 } 1831 1832 if (Args.hasArg(options::OPT_v)) 1833 CmdArgs.push_back("-version"); 1834 if (Args.hasArg(options::OPT_pg)) 1835 CmdArgs.push_back("-p"); 1836 Args.AddLastArg(CmdArgs, options::OPT_p); 1837 1838 // The driver treats -fsyntax-only specially. 1839 if (getToolChain().getTriple().getArch() == llvm::Triple::arm || 1840 getToolChain().getTriple().getArch() == llvm::Triple::thumb) { 1841 // Removes -fbuiltin-str{cat,cpy}; these aren't recognized by cc1 but are 1842 // used to inhibit the default -fno-builtin-str{cat,cpy}. 1843 // 1844 // FIXME: Should we grow a better way to deal with "removing" args? 1845 for (arg_iterator it = Args.filtered_begin(options::OPT_f_Group, 1846 options::OPT_fsyntax_only), 1847 ie = Args.filtered_end(); it != ie; ++it) { 1848 if (!it->getOption().matches(options::OPT_fbuiltin_strcat) && 1849 !it->getOption().matches(options::OPT_fbuiltin_strcpy)) { 1850 it->claim(); 1851 it->render(Args, CmdArgs); 1852 } 1853 } 1854 } else 1855 Args.AddAllArgs(CmdArgs, options::OPT_f_Group, options::OPT_fsyntax_only); 1856 1857 Args.AddAllArgs(CmdArgs, options::OPT_undef); 1858 if (Args.hasArg(options::OPT_Qn)) 1859 CmdArgs.push_back("-fno-ident"); 1860 1861 // FIXME: This isn't correct. 1862 //Args.AddLastArg(CmdArgs, options::OPT__help) 1863 //Args.AddLastArg(CmdArgs, options::OPT__targetHelp) 1864 1865 CmdArgs.append(OutputArgs.begin(), OutputArgs.end()); 1866 1867 // FIXME: Still don't get what is happening here. Investigate. 1868 Args.AddAllArgs(CmdArgs, options::OPT__param); 1869 1870 if (Args.hasArg(options::OPT_fmudflap) || 1871 Args.hasArg(options::OPT_fmudflapth)) { 1872 CmdArgs.push_back("-fno-builtin"); 1873 CmdArgs.push_back("-fno-merge-constants"); 1874 } 1875 1876 if (Args.hasArg(options::OPT_coverage)) { 1877 CmdArgs.push_back("-fprofile-arcs"); 1878 CmdArgs.push_back("-ftest-coverage"); 1879 } 1880 1881 if (types::isCXX(Inputs[0].getType())) 1882 CmdArgs.push_back("-D__private_extern__=extern"); 1883} 1884 1885void darwin::CC1::AddCPPOptionsArgs(const ArgList &Args, ArgStringList &CmdArgs, 1886 const InputInfoList &Inputs, 1887 const ArgStringList &OutputArgs) const { 1888 // Derived from cpp_options 1889 AddCPPUniqueOptionsArgs(Args, CmdArgs, Inputs); 1890 1891 CmdArgs.append(OutputArgs.begin(), OutputArgs.end()); 1892 1893 AddCC1Args(Args, CmdArgs); 1894 1895 // NOTE: The code below has some commonality with cpp_options, but 1896 // in classic gcc style ends up sending things in different 1897 // orders. This may be a good merge candidate once we drop pedantic 1898 // compatibility. 1899 1900 Args.AddAllArgs(CmdArgs, options::OPT_m_Group); 1901 Args.AddAllArgs(CmdArgs, options::OPT_std_EQ, options::OPT_ansi, 1902 options::OPT_trigraphs); 1903 if (!Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) { 1904 // Honor -std-default. 1905 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ, 1906 "-std=", /*Joined=*/true); 1907 } 1908 Args.AddAllArgs(CmdArgs, options::OPT_W_Group, options::OPT_pedantic_Group); 1909 Args.AddLastArg(CmdArgs, options::OPT_w); 1910 1911 // The driver treats -fsyntax-only specially. 1912 Args.AddAllArgs(CmdArgs, options::OPT_f_Group, options::OPT_fsyntax_only); 1913 1914 if (Args.hasArg(options::OPT_g_Group) && !Args.hasArg(options::OPT_g0) && 1915 !Args.hasArg(options::OPT_fno_working_directory)) 1916 CmdArgs.push_back("-fworking-directory"); 1917 1918 Args.AddAllArgs(CmdArgs, options::OPT_O); 1919 Args.AddAllArgs(CmdArgs, options::OPT_undef); 1920 if (Args.hasArg(options::OPT_save_temps)) 1921 CmdArgs.push_back("-fpch-preprocess"); 1922} 1923 1924void darwin::CC1::AddCPPUniqueOptionsArgs(const ArgList &Args, 1925 ArgStringList &CmdArgs, 1926 const InputInfoList &Inputs) const { 1927 const Driver &D = getToolChain().getDriver(); 1928 1929 CheckPreprocessingOptions(D, Args); 1930 1931 // Derived from cpp_unique_options. 1932 // -{C,CC} only with -E is checked in CheckPreprocessingOptions(). 1933 Args.AddLastArg(CmdArgs, options::OPT_C); 1934 Args.AddLastArg(CmdArgs, options::OPT_CC); 1935 if (!Args.hasArg(options::OPT_Q)) 1936 CmdArgs.push_back("-quiet"); 1937 Args.AddAllArgs(CmdArgs, options::OPT_nostdinc); 1938 Args.AddAllArgs(CmdArgs, options::OPT_nostdincxx); 1939 Args.AddLastArg(CmdArgs, options::OPT_v); 1940 Args.AddAllArgs(CmdArgs, options::OPT_I_Group, options::OPT_F); 1941 Args.AddLastArg(CmdArgs, options::OPT_P); 1942 1943 // FIXME: Handle %I properly. 1944 if (getToolChain().getArchName() == "x86_64") { 1945 CmdArgs.push_back("-imultilib"); 1946 CmdArgs.push_back("x86_64"); 1947 } 1948 1949 if (Args.hasArg(options::OPT_MD)) { 1950 CmdArgs.push_back("-MD"); 1951 CmdArgs.push_back(darwin::CC1::getDependencyFileName(Args, Inputs)); 1952 } 1953 1954 if (Args.hasArg(options::OPT_MMD)) { 1955 CmdArgs.push_back("-MMD"); 1956 CmdArgs.push_back(darwin::CC1::getDependencyFileName(Args, Inputs)); 1957 } 1958 1959 Args.AddLastArg(CmdArgs, options::OPT_M); 1960 Args.AddLastArg(CmdArgs, options::OPT_MM); 1961 Args.AddAllArgs(CmdArgs, options::OPT_MF); 1962 Args.AddLastArg(CmdArgs, options::OPT_MG); 1963 Args.AddLastArg(CmdArgs, options::OPT_MP); 1964 Args.AddAllArgs(CmdArgs, options::OPT_MQ); 1965 Args.AddAllArgs(CmdArgs, options::OPT_MT); 1966 if (!Args.hasArg(options::OPT_M) && !Args.hasArg(options::OPT_MM) && 1967 (Args.hasArg(options::OPT_MD) || Args.hasArg(options::OPT_MMD))) { 1968 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) { 1969 CmdArgs.push_back("-MQ"); 1970 CmdArgs.push_back(OutputOpt->getValue(Args)); 1971 } 1972 } 1973 1974 Args.AddLastArg(CmdArgs, options::OPT_remap); 1975 if (Args.hasArg(options::OPT_g3)) 1976 CmdArgs.push_back("-dD"); 1977 Args.AddLastArg(CmdArgs, options::OPT_H); 1978 1979 AddCPPArgs(Args, CmdArgs); 1980 1981 Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U, options::OPT_A); 1982 Args.AddAllArgs(CmdArgs, options::OPT_i_Group); 1983 1984 for (InputInfoList::const_iterator 1985 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 1986 const InputInfo &II = *it; 1987 1988 if (II.isPipe()) 1989 CmdArgs.push_back("-"); 1990 else 1991 CmdArgs.push_back(II.getFilename()); 1992 } 1993 1994 Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA, 1995 options::OPT_Xpreprocessor); 1996 1997 if (Args.hasArg(options::OPT_fmudflap)) { 1998 CmdArgs.push_back("-D_MUDFLAP"); 1999 CmdArgs.push_back("-include"); 2000 CmdArgs.push_back("mf-runtime.h"); 2001 } 2002 2003 if (Args.hasArg(options::OPT_fmudflapth)) { 2004 CmdArgs.push_back("-D_MUDFLAP"); 2005 CmdArgs.push_back("-D_MUDFLAPTH"); 2006 CmdArgs.push_back("-include"); 2007 CmdArgs.push_back("mf-runtime.h"); 2008 } 2009} 2010 2011void darwin::CC1::AddCPPArgs(const ArgList &Args, 2012 ArgStringList &CmdArgs) const { 2013 // Derived from cpp spec. 2014 2015 if (Args.hasArg(options::OPT_static)) { 2016 // The gcc spec is broken here, it refers to dynamic but 2017 // that has been translated. Start by being bug compatible. 2018 2019 // if (!Args.hasArg(arglist.parser.dynamicOption)) 2020 CmdArgs.push_back("-D__STATIC__"); 2021 } else 2022 CmdArgs.push_back("-D__DYNAMIC__"); 2023 2024 if (Args.hasArg(options::OPT_pthread)) 2025 CmdArgs.push_back("-D_REENTRANT"); 2026} 2027 2028void darwin::Preprocess::ConstructJob(Compilation &C, const JobAction &JA, 2029 Job &Dest, const InputInfo &Output, 2030 const InputInfoList &Inputs, 2031 const ArgList &Args, 2032 const char *LinkingOutput) const { 2033 ArgStringList CmdArgs; 2034 2035 assert(Inputs.size() == 1 && "Unexpected number of inputs!"); 2036 2037 CmdArgs.push_back("-E"); 2038 2039 if (Args.hasArg(options::OPT_traditional) || 2040 Args.hasArg(options::OPT_traditional_cpp)) 2041 CmdArgs.push_back("-traditional-cpp"); 2042 2043 ArgStringList OutputArgs; 2044 if (Output.isFilename()) { 2045 OutputArgs.push_back("-o"); 2046 OutputArgs.push_back(Output.getFilename()); 2047 } else { 2048 assert(Output.isPipe() && "Unexpected CC1 output."); 2049 } 2050 2051 if (Args.hasArg(options::OPT_E)) { 2052 AddCPPOptionsArgs(Args, CmdArgs, Inputs, OutputArgs); 2053 } else { 2054 AddCPPOptionsArgs(Args, CmdArgs, Inputs, ArgStringList()); 2055 CmdArgs.append(OutputArgs.begin(), OutputArgs.end()); 2056 } 2057 2058 Args.AddAllArgs(CmdArgs, options::OPT_d_Group); 2059 2060 const char *CC1Name = getCC1Name(Inputs[0].getType()); 2061 const char *Exec = 2062 Args.MakeArgString(getToolChain().GetProgramPath(C, CC1Name)); 2063 Dest.addCommand(new Command(JA, *this, Exec, CmdArgs)); 2064} 2065 2066void darwin::Compile::ConstructJob(Compilation &C, const JobAction &JA, 2067 Job &Dest, const InputInfo &Output, 2068 const InputInfoList &Inputs, 2069 const ArgList &Args, 2070 const char *LinkingOutput) const { 2071 const Driver &D = getToolChain().getDriver(); 2072 ArgStringList CmdArgs; 2073 2074 assert(Inputs.size() == 1 && "Unexpected number of inputs!"); 2075 2076 types::ID InputType = Inputs[0].getType(); 2077 const Arg *A; 2078 if ((A = Args.getLastArg(options::OPT_traditional))) 2079 D.Diag(clang::diag::err_drv_argument_only_allowed_with) 2080 << A->getAsString(Args) << "-E"; 2081 2082 if (Output.getType() == types::TY_LLVMAsm) 2083 CmdArgs.push_back("-emit-llvm"); 2084 else if (Output.getType() == types::TY_LLVMBC) 2085 CmdArgs.push_back("-emit-llvm-bc"); 2086 else if (Output.getType() == types::TY_AST) 2087 D.Diag(clang::diag::err_drv_no_ast_support) 2088 << getToolChain().getTripleString(); 2089 else if (JA.getType() != types::TY_PP_Asm && 2090 JA.getType() != types::TY_PCH) 2091 D.Diag(clang::diag::err_drv_invalid_gcc_output_type) 2092 << getTypeName(JA.getType()); 2093 2094 ArgStringList OutputArgs; 2095 if (Output.getType() != types::TY_PCH) { 2096 OutputArgs.push_back("-o"); 2097 if (Output.isPipe()) 2098 OutputArgs.push_back("-"); 2099 else if (Output.isNothing()) 2100 OutputArgs.push_back("/dev/null"); 2101 else 2102 OutputArgs.push_back(Output.getFilename()); 2103 } 2104 2105 // There is no need for this level of compatibility, but it makes 2106 // diffing easier. 2107 bool OutputArgsEarly = (Args.hasArg(options::OPT_fsyntax_only) || 2108 Args.hasArg(options::OPT_S)); 2109 2110 if (types::getPreprocessedType(InputType) != types::TY_INVALID) { 2111 AddCPPUniqueOptionsArgs(Args, CmdArgs, Inputs); 2112 if (OutputArgsEarly) { 2113 AddCC1OptionsArgs(Args, CmdArgs, Inputs, OutputArgs); 2114 } else { 2115 AddCC1OptionsArgs(Args, CmdArgs, Inputs, ArgStringList()); 2116 CmdArgs.append(OutputArgs.begin(), OutputArgs.end()); 2117 } 2118 } else { 2119 CmdArgs.push_back("-fpreprocessed"); 2120 2121 for (InputInfoList::const_iterator 2122 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 2123 const InputInfo &II = *it; 2124 2125 // Reject AST inputs. 2126 if (II.getType() == types::TY_AST) { 2127 D.Diag(clang::diag::err_drv_no_ast_support) 2128 << getToolChain().getTripleString(); 2129 return; 2130 } 2131 2132 if (II.isPipe()) 2133 CmdArgs.push_back("-"); 2134 else 2135 CmdArgs.push_back(II.getFilename()); 2136 } 2137 2138 if (OutputArgsEarly) { 2139 AddCC1OptionsArgs(Args, CmdArgs, Inputs, OutputArgs); 2140 } else { 2141 AddCC1OptionsArgs(Args, CmdArgs, Inputs, ArgStringList()); 2142 CmdArgs.append(OutputArgs.begin(), OutputArgs.end()); 2143 } 2144 } 2145 2146 if (Output.getType() == types::TY_PCH) { 2147 assert(Output.isFilename() && "Invalid PCH output."); 2148 2149 CmdArgs.push_back("-o"); 2150 // NOTE: gcc uses a temp .s file for this, but there doesn't seem 2151 // to be a good reason. 2152 CmdArgs.push_back("/dev/null"); 2153 2154 CmdArgs.push_back("--output-pch="); 2155 CmdArgs.push_back(Output.getFilename()); 2156 } 2157 2158 const char *CC1Name = getCC1Name(Inputs[0].getType()); 2159 const char *Exec = 2160 Args.MakeArgString(getToolChain().GetProgramPath(C, CC1Name)); 2161 Dest.addCommand(new Command(JA, *this, Exec, CmdArgs)); 2162} 2163 2164void darwin::Assemble::ConstructJob(Compilation &C, const JobAction &JA, 2165 Job &Dest, const InputInfo &Output, 2166 const InputInfoList &Inputs, 2167 const ArgList &Args, 2168 const char *LinkingOutput) const { 2169 ArgStringList CmdArgs; 2170 2171 assert(Inputs.size() == 1 && "Unexpected number of inputs."); 2172 const InputInfo &Input = Inputs[0]; 2173 2174 // Bit of a hack, this is only used for original inputs. 2175 // 2176 // FIXME: This is broken for preprocessed .s inputs. 2177 if (Input.isFilename() && 2178 strcmp(Input.getFilename(), Input.getBaseInput()) == 0) { 2179 if (Args.hasArg(options::OPT_gstabs)) 2180 CmdArgs.push_back("--gstabs"); 2181 else if (Args.hasArg(options::OPT_g_Group)) 2182 CmdArgs.push_back("--gdwarf2"); 2183 } 2184 2185 // Derived from asm spec. 2186 AddDarwinArch(Args, CmdArgs); 2187 2188 if (!getDarwinToolChain().isTargetIPhoneOS() || 2189 Args.hasArg(options::OPT_force__cpusubtype__ALL)) 2190 CmdArgs.push_back("-force_cpusubtype_ALL"); 2191 2192 if (getToolChain().getTriple().getArch() != llvm::Triple::x86_64 && 2193 (Args.hasArg(options::OPT_mkernel) || 2194 Args.hasArg(options::OPT_static) || 2195 Args.hasArg(options::OPT_fapple_kext))) 2196 CmdArgs.push_back("-static"); 2197 2198 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, 2199 options::OPT_Xassembler); 2200 2201 assert(Output.isFilename() && "Unexpected lipo output."); 2202 CmdArgs.push_back("-o"); 2203 CmdArgs.push_back(Output.getFilename()); 2204 2205 if (Input.isPipe()) { 2206 CmdArgs.push_back("-"); 2207 } else { 2208 assert(Input.isFilename() && "Invalid input."); 2209 CmdArgs.push_back(Input.getFilename()); 2210 } 2211 2212 // asm_final spec is empty. 2213 2214 const char *Exec = 2215 Args.MakeArgString(getToolChain().GetProgramPath(C, "as")); 2216 Dest.addCommand(new Command(JA, *this, Exec, CmdArgs)); 2217} 2218 2219/// Helper routine for seeing if we should use dsymutil; this is a 2220/// gcc compatible hack, we should remove it and use the input 2221/// type information. 2222static bool isSourceSuffix(const char *Str) { 2223 // match: 'C', 'CPP', 'c', 'cc', 'cp', 'c++', 'cpp', 'cxx', 'm', 2224 // 'mm'. 2225 return llvm::StringSwitch<bool>(Str) 2226 .Case("C", true) 2227 .Case("c", true) 2228 .Case("m", true) 2229 .Case("cc", true) 2230 .Case("cp", true) 2231 .Case("mm", true) 2232 .Case("CPP", true) 2233 .Case("c++", true) 2234 .Case("cpp", true) 2235 .Case("cxx", true) 2236 .Default(false); 2237} 2238 2239void darwin::DarwinTool::AddDarwinArch(const ArgList &Args, 2240 ArgStringList &CmdArgs) const { 2241 llvm::StringRef ArchName = getDarwinToolChain().getDarwinArchName(Args); 2242 2243 // Derived from darwin_arch spec. 2244 CmdArgs.push_back("-arch"); 2245 CmdArgs.push_back(Args.MakeArgString(ArchName)); 2246 2247 // FIXME: Is this needed anymore? 2248 if (ArchName == "arm") 2249 CmdArgs.push_back("-force_cpusubtype_ALL"); 2250} 2251 2252void darwin::Link::AddLinkArgs(const ArgList &Args, 2253 ArgStringList &CmdArgs) const { 2254 const Driver &D = getToolChain().getDriver(); 2255 2256 // Derived from the "link" spec. 2257 Args.AddAllArgs(CmdArgs, options::OPT_static); 2258 if (!Args.hasArg(options::OPT_static)) 2259 CmdArgs.push_back("-dynamic"); 2260 if (Args.hasArg(options::OPT_fgnu_runtime)) { 2261 // FIXME: gcc replaces -lobjc in forward args with -lobjc-gnu 2262 // here. How do we wish to handle such things? 2263 } 2264 2265 if (!Args.hasArg(options::OPT_dynamiclib)) { 2266 AddDarwinArch(Args, CmdArgs); 2267 // FIXME: Why do this only on this path? 2268 Args.AddLastArg(CmdArgs, options::OPT_force__cpusubtype__ALL); 2269 2270 Args.AddLastArg(CmdArgs, options::OPT_bundle); 2271 Args.AddAllArgs(CmdArgs, options::OPT_bundle__loader); 2272 Args.AddAllArgs(CmdArgs, options::OPT_client__name); 2273 2274 Arg *A; 2275 if ((A = Args.getLastArg(options::OPT_compatibility__version)) || 2276 (A = Args.getLastArg(options::OPT_current__version)) || 2277 (A = Args.getLastArg(options::OPT_install__name))) 2278 D.Diag(clang::diag::err_drv_argument_only_allowed_with) 2279 << A->getAsString(Args) << "-dynamiclib"; 2280 2281 Args.AddLastArg(CmdArgs, options::OPT_force__flat__namespace); 2282 Args.AddLastArg(CmdArgs, options::OPT_keep__private__externs); 2283 Args.AddLastArg(CmdArgs, options::OPT_private__bundle); 2284 } else { 2285 CmdArgs.push_back("-dylib"); 2286 2287 Arg *A; 2288 if ((A = Args.getLastArg(options::OPT_bundle)) || 2289 (A = Args.getLastArg(options::OPT_bundle__loader)) || 2290 (A = Args.getLastArg(options::OPT_client__name)) || 2291 (A = Args.getLastArg(options::OPT_force__flat__namespace)) || 2292 (A = Args.getLastArg(options::OPT_keep__private__externs)) || 2293 (A = Args.getLastArg(options::OPT_private__bundle))) 2294 D.Diag(clang::diag::err_drv_argument_not_allowed_with) 2295 << A->getAsString(Args) << "-dynamiclib"; 2296 2297 Args.AddAllArgsTranslated(CmdArgs, options::OPT_compatibility__version, 2298 "-dylib_compatibility_version"); 2299 Args.AddAllArgsTranslated(CmdArgs, options::OPT_current__version, 2300 "-dylib_current_version"); 2301 2302 AddDarwinArch(Args, CmdArgs); 2303 2304 Args.AddAllArgsTranslated(CmdArgs, options::OPT_install__name, 2305 "-dylib_install_name"); 2306 } 2307 2308 Args.AddLastArg(CmdArgs, options::OPT_all__load); 2309 Args.AddAllArgs(CmdArgs, options::OPT_allowable__client); 2310 Args.AddLastArg(CmdArgs, options::OPT_bind__at__load); 2311 if (getDarwinToolChain().isTargetIPhoneOS()) 2312 Args.AddLastArg(CmdArgs, options::OPT_arch__errors__fatal); 2313 Args.AddLastArg(CmdArgs, options::OPT_dead__strip); 2314 Args.AddLastArg(CmdArgs, options::OPT_no__dead__strip__inits__and__terms); 2315 Args.AddAllArgs(CmdArgs, options::OPT_dylib__file); 2316 Args.AddLastArg(CmdArgs, options::OPT_dynamic); 2317 Args.AddAllArgs(CmdArgs, options::OPT_exported__symbols__list); 2318 Args.AddLastArg(CmdArgs, options::OPT_flat__namespace); 2319 Args.AddAllArgs(CmdArgs, options::OPT_headerpad__max__install__names); 2320 Args.AddAllArgs(CmdArgs, options::OPT_image__base); 2321 Args.AddAllArgs(CmdArgs, options::OPT_init); 2322 2323 // Adding all arguments doesn't make sense here but this is what gcc does. One 2324 // of this should always be present thanks to argument translation. 2325 assert((Args.hasArg(options::OPT_mmacosx_version_min_EQ) || 2326 Args.hasArg(options::OPT_miphoneos_version_min_EQ)) && 2327 "Missing version argument (lost in translation)?"); 2328 Args.AddAllArgsTranslated(CmdArgs, options::OPT_mmacosx_version_min_EQ, 2329 "-macosx_version_min"); 2330 Args.AddAllArgsTranslated(CmdArgs, options::OPT_miphoneos_version_min_EQ, 2331 "-iphoneos_version_min"); 2332 Args.AddLastArg(CmdArgs, options::OPT_nomultidefs); 2333 Args.AddLastArg(CmdArgs, options::OPT_multi__module); 2334 Args.AddLastArg(CmdArgs, options::OPT_single__module); 2335 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined); 2336 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined__unused); 2337 2338 if (Args.hasArg(options::OPT_fpie)) 2339 CmdArgs.push_back("-pie"); 2340 2341 Args.AddLastArg(CmdArgs, options::OPT_prebind); 2342 Args.AddLastArg(CmdArgs, options::OPT_noprebind); 2343 Args.AddLastArg(CmdArgs, options::OPT_nofixprebinding); 2344 Args.AddLastArg(CmdArgs, options::OPT_prebind__all__twolevel__modules); 2345 Args.AddLastArg(CmdArgs, options::OPT_read__only__relocs); 2346 Args.AddAllArgs(CmdArgs, options::OPT_sectcreate); 2347 Args.AddAllArgs(CmdArgs, options::OPT_sectorder); 2348 Args.AddAllArgs(CmdArgs, options::OPT_seg1addr); 2349 Args.AddAllArgs(CmdArgs, options::OPT_segprot); 2350 Args.AddAllArgs(CmdArgs, options::OPT_segaddr); 2351 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__only__addr); 2352 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__write__addr); 2353 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table); 2354 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table__filename); 2355 Args.AddAllArgs(CmdArgs, options::OPT_sub__library); 2356 Args.AddAllArgs(CmdArgs, options::OPT_sub__umbrella); 2357 2358 Args.AddAllArgsTranslated(CmdArgs, options::OPT_isysroot, "-syslibroot"); 2359 if (getDarwinToolChain().isTargetIPhoneOS()) { 2360 if (!Args.hasArg(options::OPT_isysroot)) { 2361 CmdArgs.push_back("-syslibroot"); 2362 CmdArgs.push_back("/Developer/SDKs/Extra"); 2363 } 2364 } 2365 2366 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace); 2367 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace__hints); 2368 Args.AddAllArgs(CmdArgs, options::OPT_umbrella); 2369 Args.AddAllArgs(CmdArgs, options::OPT_undefined); 2370 Args.AddAllArgs(CmdArgs, options::OPT_unexported__symbols__list); 2371 Args.AddAllArgs(CmdArgs, options::OPT_weak__reference__mismatches); 2372 Args.AddLastArg(CmdArgs, options::OPT_X_Flag); 2373 Args.AddAllArgs(CmdArgs, options::OPT_y); 2374 Args.AddLastArg(CmdArgs, options::OPT_w); 2375 Args.AddAllArgs(CmdArgs, options::OPT_pagezero__size); 2376 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__); 2377 Args.AddLastArg(CmdArgs, options::OPT_seglinkedit); 2378 Args.AddLastArg(CmdArgs, options::OPT_noseglinkedit); 2379 Args.AddAllArgs(CmdArgs, options::OPT_sectalign); 2380 Args.AddAllArgs(CmdArgs, options::OPT_sectobjectsymbols); 2381 Args.AddAllArgs(CmdArgs, options::OPT_segcreate); 2382 Args.AddLastArg(CmdArgs, options::OPT_whyload); 2383 Args.AddLastArg(CmdArgs, options::OPT_whatsloaded); 2384 Args.AddAllArgs(CmdArgs, options::OPT_dylinker__install__name); 2385 Args.AddLastArg(CmdArgs, options::OPT_dylinker); 2386 Args.AddLastArg(CmdArgs, options::OPT_Mach); 2387} 2388 2389void darwin::Link::ConstructJob(Compilation &C, const JobAction &JA, 2390 Job &Dest, const InputInfo &Output, 2391 const InputInfoList &Inputs, 2392 const ArgList &Args, 2393 const char *LinkingOutput) const { 2394 assert(Output.getType() == types::TY_Image && "Invalid linker output type."); 2395 2396 // The logic here is derived from gcc's behavior; most of which 2397 // comes from specs (starting with link_command). Consult gcc for 2398 // more information. 2399 ArgStringList CmdArgs; 2400 2401 // I'm not sure why this particular decomposition exists in gcc, but 2402 // we follow suite for ease of comparison. 2403 AddLinkArgs(Args, CmdArgs); 2404 2405 Args.AddAllArgs(CmdArgs, options::OPT_d_Flag); 2406 Args.AddAllArgs(CmdArgs, options::OPT_s); 2407 Args.AddAllArgs(CmdArgs, options::OPT_t); 2408 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag); 2409 Args.AddAllArgs(CmdArgs, options::OPT_u_Group); 2410 Args.AddAllArgs(CmdArgs, options::OPT_A); 2411 Args.AddLastArg(CmdArgs, options::OPT_e); 2412 Args.AddAllArgs(CmdArgs, options::OPT_m_Separate); 2413 Args.AddAllArgs(CmdArgs, options::OPT_r); 2414 2415 CmdArgs.push_back("-o"); 2416 CmdArgs.push_back(Output.getFilename()); 2417 2418 if (!Args.hasArg(options::OPT_A) && 2419 !Args.hasArg(options::OPT_nostdlib) && 2420 !Args.hasArg(options::OPT_nostartfiles)) { 2421 // Derived from startfile spec. 2422 if (Args.hasArg(options::OPT_dynamiclib)) { 2423 // Derived from darwin_dylib1 spec. 2424 if (getDarwinToolChain().isTargetIPhoneOS()) { 2425 if (getDarwinToolChain().isIPhoneOSVersionLT(3, 1)) 2426 CmdArgs.push_back("-ldylib1.o"); 2427 } else { 2428 if (getDarwinToolChain().isMacosxVersionLT(10, 5)) 2429 CmdArgs.push_back("-ldylib1.o"); 2430 else if (getDarwinToolChain().isMacosxVersionLT(10, 6)) 2431 CmdArgs.push_back("-ldylib1.10.5.o"); 2432 } 2433 } else { 2434 if (Args.hasArg(options::OPT_bundle)) { 2435 if (!Args.hasArg(options::OPT_static)) { 2436 // Derived from darwin_bundle1 spec. 2437 if (getDarwinToolChain().isTargetIPhoneOS()) { 2438 if (getDarwinToolChain().isIPhoneOSVersionLT(3, 1)) 2439 CmdArgs.push_back("-lbundle1.o"); 2440 } else { 2441 if (getDarwinToolChain().isMacosxVersionLT(10, 6)) 2442 CmdArgs.push_back("-lbundle1.o"); 2443 } 2444 } 2445 } else { 2446 if (Args.hasArg(options::OPT_pg)) { 2447 if (Args.hasArg(options::OPT_static) || 2448 Args.hasArg(options::OPT_object) || 2449 Args.hasArg(options::OPT_preload)) { 2450 CmdArgs.push_back("-lgcrt0.o"); 2451 } else { 2452 CmdArgs.push_back("-lgcrt1.o"); 2453 2454 // darwin_crt2 spec is empty. 2455 } 2456 } else { 2457 if (Args.hasArg(options::OPT_static) || 2458 Args.hasArg(options::OPT_object) || 2459 Args.hasArg(options::OPT_preload)) { 2460 CmdArgs.push_back("-lcrt0.o"); 2461 } else { 2462 // Derived from darwin_crt1 spec. 2463 if (getDarwinToolChain().isTargetIPhoneOS()) { 2464 if (getDarwinToolChain().isIPhoneOSVersionLT(3, 1)) 2465 CmdArgs.push_back("-lcrt1.o"); 2466 else 2467 CmdArgs.push_back("-lcrt1.3.1.o"); 2468 } else { 2469 if (getDarwinToolChain().isMacosxVersionLT(10, 5)) 2470 CmdArgs.push_back("-lcrt1.o"); 2471 else if (getDarwinToolChain().isMacosxVersionLT(10, 6)) 2472 CmdArgs.push_back("-lcrt1.10.5.o"); 2473 else 2474 CmdArgs.push_back("-lcrt1.10.6.o"); 2475 2476 // darwin_crt2 spec is empty. 2477 } 2478 } 2479 } 2480 } 2481 } 2482 2483 if (!getDarwinToolChain().isTargetIPhoneOS() && 2484 Args.hasArg(options::OPT_shared_libgcc) && 2485 getDarwinToolChain().isMacosxVersionLT(10, 5)) { 2486 const char *Str = 2487 Args.MakeArgString(getToolChain().GetFilePath(C, "crt3.o")); 2488 CmdArgs.push_back(Str); 2489 } 2490 } 2491 2492 Args.AddAllArgs(CmdArgs, options::OPT_L); 2493 2494 if (Args.hasArg(options::OPT_fopenmp)) 2495 // This is more complicated in gcc... 2496 CmdArgs.push_back("-lgomp"); 2497 2498 getDarwinToolChain().AddLinkSearchPathArgs(Args, CmdArgs); 2499 2500 for (InputInfoList::const_iterator 2501 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 2502 const InputInfo &II = *it; 2503 if (II.isFilename()) 2504 CmdArgs.push_back(II.getFilename()); 2505 else 2506 II.getInputArg().renderAsInput(Args, CmdArgs); 2507 } 2508 2509 if (LinkingOutput) { 2510 CmdArgs.push_back("-arch_multiple"); 2511 CmdArgs.push_back("-final_output"); 2512 CmdArgs.push_back(LinkingOutput); 2513 } 2514 2515 if (Args.hasArg(options::OPT_fprofile_arcs) || 2516 Args.hasArg(options::OPT_fprofile_generate) || 2517 Args.hasArg(options::OPT_fcreate_profile) || 2518 Args.hasArg(options::OPT_coverage)) 2519 CmdArgs.push_back("-lgcov"); 2520 2521 if (Args.hasArg(options::OPT_fnested_functions)) 2522 CmdArgs.push_back("-allow_stack_execute"); 2523 2524 if (!Args.hasArg(options::OPT_nostdlib) && 2525 !Args.hasArg(options::OPT_nodefaultlibs)) { 2526 // FIXME: g++ is more complicated here, it tries to put -lstdc++ 2527 // before -lm, for example. 2528 if (getToolChain().getDriver().CCCIsCXX) 2529 CmdArgs.push_back("-lstdc++"); 2530 2531 // link_ssp spec is empty. 2532 2533 // Let the tool chain choose which runtime library to link. 2534 getDarwinToolChain().AddLinkRuntimeLibArgs(Args, CmdArgs); 2535 } 2536 2537 if (!Args.hasArg(options::OPT_A) && 2538 !Args.hasArg(options::OPT_nostdlib) && 2539 !Args.hasArg(options::OPT_nostartfiles)) { 2540 // endfile_spec is empty. 2541 } 2542 2543 Args.AddAllArgs(CmdArgs, options::OPT_T_Group); 2544 Args.AddAllArgs(CmdArgs, options::OPT_F); 2545 2546 const char *Exec = 2547 Args.MakeArgString(getToolChain().GetProgramPath(C, "ld")); 2548 Dest.addCommand(new Command(JA, *this, Exec, CmdArgs)); 2549 2550 // Find the first non-empty base input (we want to ignore linker 2551 // inputs). 2552 const char *BaseInput = ""; 2553 for (unsigned i = 0, e = Inputs.size(); i != e; ++i) { 2554 if (Inputs[i].getBaseInput()[0] != '\0') { 2555 BaseInput = Inputs[i].getBaseInput(); 2556 break; 2557 } 2558 } 2559 2560 // Run dsymutil if we are making an executable in a single step. 2561 // 2562 // FIXME: Currently we don't want to do this when we are part of a 2563 // universal build step, as this would end up creating stray temp 2564 // files. 2565 if (!LinkingOutput && 2566 Args.getLastArg(options::OPT_g_Group) && 2567 !Args.getLastArg(options::OPT_gstabs) && 2568 !Args.getLastArg(options::OPT_g0)) { 2569 // FIXME: This is gross, but matches gcc. The test only considers 2570 // the suffix (not the -x type), and then only of the first 2571 // source input. Awesome. 2572 const char *Suffix = strrchr(BaseInput, '.'); 2573 if (Suffix && isSourceSuffix(Suffix + 1)) { 2574 const char *Exec = 2575 Args.MakeArgString(getToolChain().GetProgramPath(C, "dsymutil")); 2576 ArgStringList CmdArgs; 2577 CmdArgs.push_back(Output.getFilename()); 2578 C.getJobs().addCommand(new Command(JA, *this, Exec, CmdArgs)); 2579 } 2580 } 2581} 2582 2583void darwin::Lipo::ConstructJob(Compilation &C, const JobAction &JA, 2584 Job &Dest, const InputInfo &Output, 2585 const InputInfoList &Inputs, 2586 const ArgList &Args, 2587 const char *LinkingOutput) const { 2588 ArgStringList CmdArgs; 2589 2590 CmdArgs.push_back("-create"); 2591 assert(Output.isFilename() && "Unexpected lipo output."); 2592 2593 CmdArgs.push_back("-output"); 2594 CmdArgs.push_back(Output.getFilename()); 2595 2596 for (InputInfoList::const_iterator 2597 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 2598 const InputInfo &II = *it; 2599 assert(II.isFilename() && "Unexpected lipo input."); 2600 CmdArgs.push_back(II.getFilename()); 2601 } 2602 const char *Exec = 2603 Args.MakeArgString(getToolChain().GetProgramPath(C, "lipo")); 2604 Dest.addCommand(new Command(JA, *this, Exec, CmdArgs)); 2605} 2606 2607void auroraux::Assemble::ConstructJob(Compilation &C, const JobAction &JA, 2608 Job &Dest, const InputInfo &Output, 2609 const InputInfoList &Inputs, 2610 const ArgList &Args, 2611 const char *LinkingOutput) const { 2612 ArgStringList CmdArgs; 2613 2614 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, 2615 options::OPT_Xassembler); 2616 2617 CmdArgs.push_back("-o"); 2618 if (Output.isPipe()) 2619 CmdArgs.push_back("-"); 2620 else 2621 CmdArgs.push_back(Output.getFilename()); 2622 2623 for (InputInfoList::const_iterator 2624 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 2625 const InputInfo &II = *it; 2626 if (II.isPipe()) 2627 CmdArgs.push_back("-"); 2628 else 2629 CmdArgs.push_back(II.getFilename()); 2630 } 2631 2632 const char *Exec = 2633 Args.MakeArgString(getToolChain().GetProgramPath(C, "gas")); 2634 Dest.addCommand(new Command(JA, *this, Exec, CmdArgs)); 2635} 2636 2637void auroraux::Link::ConstructJob(Compilation &C, const JobAction &JA, 2638 Job &Dest, const InputInfo &Output, 2639 const InputInfoList &Inputs, 2640 const ArgList &Args, 2641 const char *LinkingOutput) const { 2642 const Driver &D = getToolChain().getDriver(); 2643 ArgStringList CmdArgs; 2644 2645 if ((!Args.hasArg(options::OPT_nostdlib)) && 2646 (!Args.hasArg(options::OPT_shared))) { 2647 CmdArgs.push_back("-e"); 2648 CmdArgs.push_back("_start"); 2649 } 2650 2651 if (Args.hasArg(options::OPT_static)) { 2652 CmdArgs.push_back("-Bstatic"); 2653 CmdArgs.push_back("-dn"); 2654 } else { 2655// CmdArgs.push_back("--eh-frame-hdr"); 2656 CmdArgs.push_back("-Bdynamic"); 2657 if (Args.hasArg(options::OPT_shared)) { 2658 CmdArgs.push_back("-shared"); 2659 } else { 2660 CmdArgs.push_back("--dynamic-linker"); 2661 CmdArgs.push_back("/lib/ld.so.1"); // 64Bit Path /lib/amd64/ld.so.1 2662 } 2663 } 2664 2665 if (Output.isPipe()) { 2666 CmdArgs.push_back("-o"); 2667 CmdArgs.push_back("-"); 2668 } else if (Output.isFilename()) { 2669 CmdArgs.push_back("-o"); 2670 CmdArgs.push_back(Output.getFilename()); 2671 } else { 2672 assert(Output.isNothing() && "Invalid output."); 2673 } 2674 2675 if (!Args.hasArg(options::OPT_nostdlib) && 2676 !Args.hasArg(options::OPT_nostartfiles)) { 2677 if (!Args.hasArg(options::OPT_shared)) { 2678 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crt1.o"))); 2679 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crti.o"))); 2680 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crtbegin.o"))); 2681 } else { 2682 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crti.o"))); 2683 } 2684 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crtn.o"))); 2685 } 2686 2687 CmdArgs.push_back(Args.MakeArgString("-L/opt/gcc4/lib/gcc/" 2688 + getToolChain().getTripleString() 2689 + "/4.2.4")); 2690 2691 Args.AddAllArgs(CmdArgs, options::OPT_L); 2692 Args.AddAllArgs(CmdArgs, options::OPT_T_Group); 2693 Args.AddAllArgs(CmdArgs, options::OPT_e); 2694 2695 for (InputInfoList::const_iterator 2696 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 2697 const InputInfo &II = *it; 2698 2699 // Don't try to pass LLVM inputs to a generic gcc. 2700 if (II.getType() == types::TY_LLVMBC) 2701 D.Diag(clang::diag::err_drv_no_linker_llvm_support) 2702 << getToolChain().getTripleString(); 2703 2704 if (II.isPipe()) 2705 CmdArgs.push_back("-"); 2706 else if (II.isFilename()) 2707 CmdArgs.push_back(II.getFilename()); 2708 else 2709 II.getInputArg().renderAsInput(Args, CmdArgs); 2710 } 2711 2712 if (!Args.hasArg(options::OPT_nostdlib) && 2713 !Args.hasArg(options::OPT_nodefaultlibs)) { 2714 // FIXME: For some reason GCC passes -lgcc before adding 2715 // the default system libraries. Just mimic this for now. 2716 CmdArgs.push_back("-lgcc"); 2717 2718 if (Args.hasArg(options::OPT_pthread)) 2719 CmdArgs.push_back("-pthread"); 2720 if (!Args.hasArg(options::OPT_shared)) 2721 CmdArgs.push_back("-lc"); 2722 CmdArgs.push_back("-lgcc"); 2723 } 2724 2725 if (!Args.hasArg(options::OPT_nostdlib) && 2726 !Args.hasArg(options::OPT_nostartfiles)) { 2727 if (!Args.hasArg(options::OPT_shared)) 2728 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crtend.o"))); 2729// else 2730// CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crtendS.o"))); 2731 } 2732 2733 const char *Exec = 2734 Args.MakeArgString(getToolChain().GetProgramPath(C, "ld")); 2735 Dest.addCommand(new Command(JA, *this, Exec, CmdArgs)); 2736} 2737 2738void openbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA, 2739 Job &Dest, const InputInfo &Output, 2740 const InputInfoList &Inputs, 2741 const ArgList &Args, 2742 const char *LinkingOutput) const { 2743 ArgStringList CmdArgs; 2744 2745 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, 2746 options::OPT_Xassembler); 2747 2748 CmdArgs.push_back("-o"); 2749 if (Output.isPipe()) 2750 CmdArgs.push_back("-"); 2751 else 2752 CmdArgs.push_back(Output.getFilename()); 2753 2754 for (InputInfoList::const_iterator 2755 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 2756 const InputInfo &II = *it; 2757 if (II.isPipe()) 2758 CmdArgs.push_back("-"); 2759 else 2760 CmdArgs.push_back(II.getFilename()); 2761 } 2762 2763 const char *Exec = 2764 Args.MakeArgString(getToolChain().GetProgramPath(C, "as")); 2765 Dest.addCommand(new Command(JA, *this, Exec, CmdArgs)); 2766} 2767 2768void openbsd::Link::ConstructJob(Compilation &C, const JobAction &JA, 2769 Job &Dest, const InputInfo &Output, 2770 const InputInfoList &Inputs, 2771 const ArgList &Args, 2772 const char *LinkingOutput) const { 2773 const Driver &D = getToolChain().getDriver(); 2774 ArgStringList CmdArgs; 2775 2776 if ((!Args.hasArg(options::OPT_nostdlib)) && 2777 (!Args.hasArg(options::OPT_shared))) { 2778 CmdArgs.push_back("-e"); 2779 CmdArgs.push_back("__start"); 2780 } 2781 2782 if (Args.hasArg(options::OPT_static)) { 2783 CmdArgs.push_back("-Bstatic"); 2784 } else { 2785 CmdArgs.push_back("--eh-frame-hdr"); 2786 CmdArgs.push_back("-Bdynamic"); 2787 if (Args.hasArg(options::OPT_shared)) { 2788 CmdArgs.push_back("-shared"); 2789 } else { 2790 CmdArgs.push_back("-dynamic-linker"); 2791 CmdArgs.push_back("/usr/libexec/ld.so"); 2792 } 2793 } 2794 2795 if (Output.isPipe()) { 2796 CmdArgs.push_back("-o"); 2797 CmdArgs.push_back("-"); 2798 } else if (Output.isFilename()) { 2799 CmdArgs.push_back("-o"); 2800 CmdArgs.push_back(Output.getFilename()); 2801 } else { 2802 assert(Output.isNothing() && "Invalid output."); 2803 } 2804 2805 if (!Args.hasArg(options::OPT_nostdlib) && 2806 !Args.hasArg(options::OPT_nostartfiles)) { 2807 if (!Args.hasArg(options::OPT_shared)) { 2808 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crt0.o"))); 2809 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crtbegin.o"))); 2810 } else { 2811 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crtbeginS.o"))); 2812 } 2813 } 2814 2815 std::string Triple = getToolChain().getTripleString(); 2816 if (Triple.substr(0, 6) == "x86_64") 2817 Triple.replace(0, 6, "amd64"); 2818 CmdArgs.push_back(Args.MakeArgString("-L/usr/lib/gcc-lib/" + Triple + 2819 "/3.3.5")); 2820 2821 Args.AddAllArgs(CmdArgs, options::OPT_L); 2822 Args.AddAllArgs(CmdArgs, options::OPT_T_Group); 2823 Args.AddAllArgs(CmdArgs, options::OPT_e); 2824 2825 for (InputInfoList::const_iterator 2826 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 2827 const InputInfo &II = *it; 2828 2829 // Don't try to pass LLVM inputs to a generic gcc. 2830 if (II.getType() == types::TY_LLVMBC) 2831 D.Diag(clang::diag::err_drv_no_linker_llvm_support) 2832 << getToolChain().getTripleString(); 2833 2834 if (II.isPipe()) 2835 CmdArgs.push_back("-"); 2836 else if (II.isFilename()) 2837 CmdArgs.push_back(II.getFilename()); 2838 else 2839 II.getInputArg().renderAsInput(Args, CmdArgs); 2840 } 2841 2842 if (!Args.hasArg(options::OPT_nostdlib) && 2843 !Args.hasArg(options::OPT_nodefaultlibs)) { 2844 // FIXME: For some reason GCC passes -lgcc before adding 2845 // the default system libraries. Just mimic this for now. 2846 CmdArgs.push_back("-lgcc"); 2847 2848 if (Args.hasArg(options::OPT_pthread)) 2849 CmdArgs.push_back("-pthread"); 2850 if (!Args.hasArg(options::OPT_shared)) 2851 CmdArgs.push_back("-lc"); 2852 CmdArgs.push_back("-lgcc"); 2853 } 2854 2855 if (!Args.hasArg(options::OPT_nostdlib) && 2856 !Args.hasArg(options::OPT_nostartfiles)) { 2857 if (!Args.hasArg(options::OPT_shared)) 2858 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crtend.o"))); 2859 else 2860 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crtendS.o"))); 2861 } 2862 2863 const char *Exec = 2864 Args.MakeArgString(getToolChain().GetProgramPath(C, "ld")); 2865 Dest.addCommand(new Command(JA, *this, Exec, CmdArgs)); 2866} 2867 2868void freebsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA, 2869 Job &Dest, const InputInfo &Output, 2870 const InputInfoList &Inputs, 2871 const ArgList &Args, 2872 const char *LinkingOutput) const { 2873 ArgStringList CmdArgs; 2874 2875 // When building 32-bit code on FreeBSD/amd64, we have to explicitly 2876 // instruct as in the base system to assemble 32-bit code. 2877 if (getToolChain().getArchName() == "i386") 2878 CmdArgs.push_back("--32"); 2879 2880 2881 // Set byte order explicitly 2882 if (getToolChain().getArchName() == "mips") 2883 CmdArgs.push_back("-EB"); 2884 else if (getToolChain().getArchName() == "mipsel") 2885 CmdArgs.push_back("-EL"); 2886 2887 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, 2888 options::OPT_Xassembler); 2889 2890 CmdArgs.push_back("-o"); 2891 if (Output.isPipe()) 2892 CmdArgs.push_back("-"); 2893 else 2894 CmdArgs.push_back(Output.getFilename()); 2895 2896 for (InputInfoList::const_iterator 2897 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 2898 const InputInfo &II = *it; 2899 if (II.isPipe()) 2900 CmdArgs.push_back("-"); 2901 else 2902 CmdArgs.push_back(II.getFilename()); 2903 } 2904 2905 const char *Exec = 2906 Args.MakeArgString(getToolChain().GetProgramPath(C, "as")); 2907 Dest.addCommand(new Command(JA, *this, Exec, CmdArgs)); 2908} 2909 2910void freebsd::Link::ConstructJob(Compilation &C, const JobAction &JA, 2911 Job &Dest, const InputInfo &Output, 2912 const InputInfoList &Inputs, 2913 const ArgList &Args, 2914 const char *LinkingOutput) const { 2915 const Driver &D = getToolChain().getDriver(); 2916 ArgStringList CmdArgs; 2917 2918 if (Args.hasArg(options::OPT_static)) { 2919 CmdArgs.push_back("-Bstatic"); 2920 } else { 2921 CmdArgs.push_back("--eh-frame-hdr"); 2922 if (Args.hasArg(options::OPT_shared)) { 2923 CmdArgs.push_back("-Bshareable"); 2924 } else { 2925 CmdArgs.push_back("-dynamic-linker"); 2926 CmdArgs.push_back("/libexec/ld-elf.so.1"); 2927 } 2928 } 2929 2930 // When building 32-bit code on FreeBSD/amd64, we have to explicitly 2931 // instruct ld in the base system to link 32-bit code. 2932 if (getToolChain().getArchName() == "i386") { 2933 CmdArgs.push_back("-m"); 2934 CmdArgs.push_back("elf_i386_fbsd"); 2935 } 2936 2937 if (Output.isPipe()) { 2938 CmdArgs.push_back("-o"); 2939 CmdArgs.push_back("-"); 2940 } else if (Output.isFilename()) { 2941 CmdArgs.push_back("-o"); 2942 CmdArgs.push_back(Output.getFilename()); 2943 } else { 2944 assert(Output.isNothing() && "Invalid output."); 2945 } 2946 2947 if (!Args.hasArg(options::OPT_nostdlib) && 2948 !Args.hasArg(options::OPT_nostartfiles)) { 2949 if (!Args.hasArg(options::OPT_shared)) { 2950 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crt1.o"))); 2951 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crti.o"))); 2952 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crtbegin.o"))); 2953 } else { 2954 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crti.o"))); 2955 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crtbeginS.o"))); 2956 } 2957 } 2958 2959 Args.AddAllArgs(CmdArgs, options::OPT_L); 2960 Args.AddAllArgs(CmdArgs, options::OPT_T_Group); 2961 Args.AddAllArgs(CmdArgs, options::OPT_e); 2962 2963 for (InputInfoList::const_iterator 2964 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 2965 const InputInfo &II = *it; 2966 2967 // Don't try to pass LLVM inputs to a generic gcc. 2968 if (II.getType() == types::TY_LLVMBC) 2969 D.Diag(clang::diag::err_drv_no_linker_llvm_support) 2970 << getToolChain().getTripleString(); 2971 2972 if (II.isPipe()) 2973 CmdArgs.push_back("-"); 2974 else if (II.isFilename()) 2975 CmdArgs.push_back(II.getFilename()); 2976 else 2977 II.getInputArg().renderAsInput(Args, CmdArgs); 2978 } 2979 2980 if (!Args.hasArg(options::OPT_nostdlib) && 2981 !Args.hasArg(options::OPT_nodefaultlibs)) { 2982 if (D.CCCIsCXX) { 2983 CmdArgs.push_back("-lstdc++"); 2984 CmdArgs.push_back("-lm"); 2985 } 2986 // FIXME: For some reason GCC passes -lgcc and -lgcc_s before adding 2987 // the default system libraries. Just mimic this for now. 2988 CmdArgs.push_back("-lgcc"); 2989 if (Args.hasArg(options::OPT_static)) { 2990 CmdArgs.push_back("-lgcc_eh"); 2991 } else { 2992 CmdArgs.push_back("--as-needed"); 2993 CmdArgs.push_back("-lgcc_s"); 2994 CmdArgs.push_back("--no-as-needed"); 2995 } 2996 2997 if (Args.hasArg(options::OPT_pthread)) 2998 CmdArgs.push_back("-lpthread"); 2999 CmdArgs.push_back("-lc"); 3000 3001 CmdArgs.push_back("-lgcc"); 3002 if (Args.hasArg(options::OPT_static)) { 3003 CmdArgs.push_back("-lgcc_eh"); 3004 } else { 3005 CmdArgs.push_back("--as-needed"); 3006 CmdArgs.push_back("-lgcc_s"); 3007 CmdArgs.push_back("--no-as-needed"); 3008 } 3009 } 3010 3011 if (!Args.hasArg(options::OPT_nostdlib) && 3012 !Args.hasArg(options::OPT_nostartfiles)) { 3013 if (!Args.hasArg(options::OPT_shared)) 3014 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crtend.o"))); 3015 else 3016 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crtendS.o"))); 3017 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crtn.o"))); 3018 } 3019 3020 const char *Exec = 3021 Args.MakeArgString(getToolChain().GetProgramPath(C, "ld")); 3022 Dest.addCommand(new Command(JA, *this, Exec, CmdArgs)); 3023} 3024 3025/// DragonFly Tools 3026 3027// For now, DragonFly Assemble does just about the same as for 3028// FreeBSD, but this may change soon. 3029void dragonfly::Assemble::ConstructJob(Compilation &C, const JobAction &JA, 3030 Job &Dest, const InputInfo &Output, 3031 const InputInfoList &Inputs, 3032 const ArgList &Args, 3033 const char *LinkingOutput) const { 3034 ArgStringList CmdArgs; 3035 3036 // When building 32-bit code on DragonFly/pc64, we have to explicitly 3037 // instruct as in the base system to assemble 32-bit code. 3038 if (getToolChain().getArchName() == "i386") 3039 CmdArgs.push_back("--32"); 3040 3041 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, 3042 options::OPT_Xassembler); 3043 3044 CmdArgs.push_back("-o"); 3045 if (Output.isPipe()) 3046 CmdArgs.push_back("-"); 3047 else 3048 CmdArgs.push_back(Output.getFilename()); 3049 3050 for (InputInfoList::const_iterator 3051 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 3052 const InputInfo &II = *it; 3053 if (II.isPipe()) 3054 CmdArgs.push_back("-"); 3055 else 3056 CmdArgs.push_back(II.getFilename()); 3057 } 3058 3059 const char *Exec = 3060 Args.MakeArgString(getToolChain().GetProgramPath(C, "as")); 3061 Dest.addCommand(new Command(JA, *this, Exec, CmdArgs)); 3062} 3063 3064void dragonfly::Link::ConstructJob(Compilation &C, const JobAction &JA, 3065 Job &Dest, const InputInfo &Output, 3066 const InputInfoList &Inputs, 3067 const ArgList &Args, 3068 const char *LinkingOutput) const { 3069 const Driver &D = getToolChain().getDriver(); 3070 ArgStringList CmdArgs; 3071 3072 if (Args.hasArg(options::OPT_static)) { 3073 CmdArgs.push_back("-Bstatic"); 3074 } else { 3075 if (Args.hasArg(options::OPT_shared)) 3076 CmdArgs.push_back("-Bshareable"); 3077 else { 3078 CmdArgs.push_back("-dynamic-linker"); 3079 CmdArgs.push_back("/usr/libexec/ld-elf.so.2"); 3080 } 3081 } 3082 3083 // When building 32-bit code on DragonFly/pc64, we have to explicitly 3084 // instruct ld in the base system to link 32-bit code. 3085 if (getToolChain().getArchName() == "i386") { 3086 CmdArgs.push_back("-m"); 3087 CmdArgs.push_back("elf_i386"); 3088 } 3089 3090 if (Output.isPipe()) { 3091 CmdArgs.push_back("-o"); 3092 CmdArgs.push_back("-"); 3093 } else if (Output.isFilename()) { 3094 CmdArgs.push_back("-o"); 3095 CmdArgs.push_back(Output.getFilename()); 3096 } else { 3097 assert(Output.isNothing() && "Invalid output."); 3098 } 3099 3100 if (!Args.hasArg(options::OPT_nostdlib) && 3101 !Args.hasArg(options::OPT_nostartfiles)) { 3102 if (!Args.hasArg(options::OPT_shared)) { 3103 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crt1.o"))); 3104 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crti.o"))); 3105 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crtbegin.o"))); 3106 } else { 3107 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crti.o"))); 3108 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crtbeginS.o"))); 3109 } 3110 } 3111 3112 Args.AddAllArgs(CmdArgs, options::OPT_L); 3113 Args.AddAllArgs(CmdArgs, options::OPT_T_Group); 3114 Args.AddAllArgs(CmdArgs, options::OPT_e); 3115 3116 for (InputInfoList::const_iterator 3117 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 3118 const InputInfo &II = *it; 3119 3120 // Don't try to pass LLVM inputs to a generic gcc. 3121 if (II.getType() == types::TY_LLVMBC) 3122 D.Diag(clang::diag::err_drv_no_linker_llvm_support) 3123 << getToolChain().getTripleString(); 3124 3125 if (II.isPipe()) 3126 CmdArgs.push_back("-"); 3127 else if (II.isFilename()) 3128 CmdArgs.push_back(II.getFilename()); 3129 else 3130 II.getInputArg().renderAsInput(Args, CmdArgs); 3131 } 3132 3133 if (!Args.hasArg(options::OPT_nostdlib) && 3134 !Args.hasArg(options::OPT_nodefaultlibs)) { 3135 // FIXME: GCC passes on -lgcc, -lgcc_pic and a whole lot of 3136 // rpaths 3137 CmdArgs.push_back("-L/usr/lib/gcc41"); 3138 3139 if (!Args.hasArg(options::OPT_static)) { 3140 CmdArgs.push_back("-rpath"); 3141 CmdArgs.push_back("/usr/lib/gcc41"); 3142 3143 CmdArgs.push_back("-rpath-link"); 3144 CmdArgs.push_back("/usr/lib/gcc41"); 3145 3146 CmdArgs.push_back("-rpath"); 3147 CmdArgs.push_back("/usr/lib"); 3148 3149 CmdArgs.push_back("-rpath-link"); 3150 CmdArgs.push_back("/usr/lib"); 3151 } 3152 3153 if (Args.hasArg(options::OPT_shared)) { 3154 CmdArgs.push_back("-lgcc_pic"); 3155 } else { 3156 CmdArgs.push_back("-lgcc"); 3157 } 3158 3159 3160 if (Args.hasArg(options::OPT_pthread)) 3161 CmdArgs.push_back("-lpthread"); 3162 3163 if (!Args.hasArg(options::OPT_nolibc)) { 3164 CmdArgs.push_back("-lc"); 3165 } 3166 3167 if (Args.hasArg(options::OPT_shared)) { 3168 CmdArgs.push_back("-lgcc_pic"); 3169 } else { 3170 CmdArgs.push_back("-lgcc"); 3171 } 3172 } 3173 3174 if (!Args.hasArg(options::OPT_nostdlib) && 3175 !Args.hasArg(options::OPT_nostartfiles)) { 3176 if (!Args.hasArg(options::OPT_shared)) 3177 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crtend.o"))); 3178 else 3179 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crtendS.o"))); 3180 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath(C, "crtn.o"))); 3181 } 3182 3183 const char *Exec = 3184 Args.MakeArgString(getToolChain().GetProgramPath(C, "ld")); 3185 Dest.addCommand(new Command(JA, *this, Exec, CmdArgs)); 3186} 3187