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