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