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