Tools.cpp revision 43f7e62442f17a2527f6eed387c86b38ffd5dc2a
1//===--- Tools.cpp - Tools Implementations --------------------------------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9 10#include "Tools.h" 11 12#include "clang/Driver/Action.h" 13#include "clang/Driver/Arg.h" 14#include "clang/Driver/ArgList.h" 15#include "clang/Driver/Driver.h" 16#include "clang/Driver/DriverDiagnostic.h" 17#include "clang/Driver/Compilation.h" 18#include "clang/Driver/Job.h" 19#include "clang/Driver/HostInfo.h" 20#include "clang/Driver/ObjCRuntime.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/FileSystem.h" 30#include "llvm/Support/Format.h" 31#include "llvm/Support/raw_ostream.h" 32#include "llvm/Support/Host.h" 33#include "llvm/Support/Process.h" 34#include "llvm/Support/ErrorHandling.h" 35 36#include "InputInfo.h" 37#include "ToolChains.h" 38 39#ifdef __CYGWIN__ 40#include <cygwin/version.h> 41#if defined(CYGWIN_VERSION_DLL_MAJOR) && CYGWIN_VERSION_DLL_MAJOR<1007 42#define IS_CYGWIN15 1 43#endif 44#endif 45 46using namespace clang::driver; 47using namespace clang::driver::tools; 48using namespace clang; 49 50/// CheckPreprocessingOptions - Perform some validation of preprocessing 51/// arguments that is shared with gcc. 52static void CheckPreprocessingOptions(const Driver &D, const ArgList &Args) { 53 if (Arg *A = Args.getLastArg(options::OPT_C, options::OPT_CC)) 54 if (!Args.hasArg(options::OPT_E) && !D.CCCIsCPP) 55 D.Diag(diag::err_drv_argument_only_allowed_with) 56 << A->getAsString(Args) << "-E"; 57} 58 59/// CheckCodeGenerationOptions - Perform some validation of code generation 60/// arguments that is shared with gcc. 61static void CheckCodeGenerationOptions(const Driver &D, const ArgList &Args) { 62 // In gcc, only ARM checks this, but it seems reasonable to check universally. 63 if (Args.hasArg(options::OPT_static)) 64 if (const Arg *A = Args.getLastArg(options::OPT_dynamic, 65 options::OPT_mdynamic_no_pic)) 66 D.Diag(diag::err_drv_argument_not_allowed_with) 67 << A->getAsString(Args) << "-static"; 68} 69 70// Quote target names for inclusion in GNU Make dependency files. 71// Only the characters '$', '#', ' ', '\t' are quoted. 72static void QuoteTarget(StringRef Target, 73 SmallVectorImpl<char> &Res) { 74 for (unsigned i = 0, e = Target.size(); i != e; ++i) { 75 switch (Target[i]) { 76 case ' ': 77 case '\t': 78 // Escape the preceding backslashes 79 for (int j = i - 1; j >= 0 && Target[j] == '\\'; --j) 80 Res.push_back('\\'); 81 82 // Escape the space/tab 83 Res.push_back('\\'); 84 break; 85 case '$': 86 Res.push_back('$'); 87 break; 88 case '#': 89 Res.push_back('\\'); 90 break; 91 default: 92 break; 93 } 94 95 Res.push_back(Target[i]); 96 } 97} 98 99static void AddLinkerInputs(const ToolChain &TC, 100 const InputInfoList &Inputs, const ArgList &Args, 101 ArgStringList &CmdArgs) { 102 const Driver &D = TC.getDriver(); 103 104 // Add extra linker input arguments which are not treated as inputs 105 // (constructed via -Xarch_). 106 Args.AddAllArgValues(CmdArgs, options::OPT_Zlinker_input); 107 108 for (InputInfoList::const_iterator 109 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 110 const InputInfo &II = *it; 111 112 if (!TC.HasNativeLLVMSupport()) { 113 // Don't try to pass LLVM inputs unless we have native support. 114 if (II.getType() == types::TY_LLVM_IR || 115 II.getType() == types::TY_LTO_IR || 116 II.getType() == types::TY_LLVM_BC || 117 II.getType() == types::TY_LTO_BC) 118 D.Diag(diag::err_drv_no_linker_llvm_support) 119 << TC.getTripleString(); 120 } 121 122 // Add filenames immediately. 123 if (II.isFilename()) { 124 CmdArgs.push_back(II.getFilename()); 125 continue; 126 } 127 128 // Otherwise, this is a linker input argument. 129 const Arg &A = II.getInputArg(); 130 131 // Handle reserved library options. 132 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) { 133 TC.AddCXXStdlibLibArgs(Args, CmdArgs); 134 } else if (A.getOption().matches(options::OPT_Z_reserved_lib_cckext)) { 135 TC.AddCCKextLibArgs(Args, CmdArgs); 136 } else 137 A.renderAsInput(Args, CmdArgs); 138 } 139} 140 141/// \brief Determine whether Objective-C automated reference counting is 142/// enabled. 143static bool isObjCAutoRefCount(const ArgList &Args) { 144 return Args.hasFlag(options::OPT_fobjc_arc, options::OPT_fno_objc_arc, false); 145} 146 147static void addProfileRT(const ToolChain &TC, const ArgList &Args, 148 ArgStringList &CmdArgs, 149 llvm::Triple Triple) { 150 if (!(Args.hasArg(options::OPT_fprofile_arcs) || 151 Args.hasArg(options::OPT_fprofile_generate) || 152 Args.hasArg(options::OPT_fcreate_profile) || 153 Args.hasArg(options::OPT_coverage))) 154 return; 155 156 // GCC links libgcov.a by adding -L<inst>/gcc/lib/gcc/<triple>/<ver> -lgcov to 157 // the link line. We cannot do the same thing because unlike gcov there is a 158 // libprofile_rt.so. We used to use the -l:libprofile_rt.a syntax, but that is 159 // not supported by old linkers. 160 Twine ProfileRT = 161 Twine(TC.getDriver().Dir) + "/../lib/" + "libprofile_rt.a"; 162 163 if (Triple.getOS() == llvm::Triple::Darwin) { 164 // On Darwin, if the static library doesn't exist try the dylib. 165 bool Exists; 166 if (llvm::sys::fs::exists(ProfileRT.str(), Exists) || !Exists) 167 ProfileRT = 168 Twine(TC.getDriver().Dir) + "/../lib/" + "libprofile_rt.dylib"; 169 } 170 171 CmdArgs.push_back(Args.MakeArgString(ProfileRT)); 172} 173 174static void AddIncludeDirectoryList(const ArgList &Args, 175 ArgStringList &CmdArgs, 176 const char *ArgName, 177 const char *DirList) { 178 if (!DirList) 179 return; // Nothing to do. 180 181 StringRef Dirs(DirList); 182 if (Dirs.empty()) // Empty string should not add '.'. 183 return; 184 185 StringRef::size_type Delim; 186 while ((Delim = Dirs.find(llvm::sys::PathSeparator)) != StringRef::npos) { 187 if (Delim == 0) { // Leading colon. 188 CmdArgs.push_back(ArgName); 189 CmdArgs.push_back("."); 190 } else { 191 CmdArgs.push_back(ArgName); 192 CmdArgs.push_back(Args.MakeArgString(Dirs.substr(0, Delim))); 193 } 194 Dirs = Dirs.substr(Delim + 1); 195 } 196 197 if (Dirs.empty()) { // Trailing colon. 198 CmdArgs.push_back(ArgName); 199 CmdArgs.push_back("."); 200 } else { // Add the last path. 201 CmdArgs.push_back(ArgName); 202 CmdArgs.push_back(Args.MakeArgString(Dirs)); 203 } 204} 205 206void Clang::AddPreprocessingOptions(const Driver &D, 207 const ArgList &Args, 208 ArgStringList &CmdArgs, 209 const InputInfo &Output, 210 const InputInfoList &Inputs) const { 211 Arg *A; 212 213 CheckPreprocessingOptions(D, Args); 214 215 Args.AddLastArg(CmdArgs, options::OPT_C); 216 Args.AddLastArg(CmdArgs, options::OPT_CC); 217 218 // Handle dependency file generation. 219 if ((A = Args.getLastArg(options::OPT_M, options::OPT_MM)) || 220 (A = Args.getLastArg(options::OPT_MD)) || 221 (A = Args.getLastArg(options::OPT_MMD))) { 222 // Determine the output location. 223 const char *DepFile; 224 if (Output.getType() == types::TY_Dependencies) { 225 DepFile = Output.getFilename(); 226 } else if (Arg *MF = Args.getLastArg(options::OPT_MF)) { 227 DepFile = MF->getValue(Args); 228 } else if (A->getOption().matches(options::OPT_M) || 229 A->getOption().matches(options::OPT_MM)) { 230 DepFile = "-"; 231 } else { 232 DepFile = darwin::CC1::getDependencyFileName(Args, Inputs); 233 } 234 CmdArgs.push_back("-dependency-file"); 235 CmdArgs.push_back(DepFile); 236 237 // Add a default target if one wasn't specified. 238 if (!Args.hasArg(options::OPT_MT) && !Args.hasArg(options::OPT_MQ)) { 239 const char *DepTarget; 240 241 // If user provided -o, that is the dependency target, except 242 // when we are only generating a dependency file. 243 Arg *OutputOpt = Args.getLastArg(options::OPT_o); 244 if (OutputOpt && Output.getType() != types::TY_Dependencies) { 245 DepTarget = OutputOpt->getValue(Args); 246 } else { 247 // Otherwise derive from the base input. 248 // 249 // FIXME: This should use the computed output file location. 250 llvm::SmallString<128> P(Inputs[0].getBaseInput()); 251 llvm::sys::path::replace_extension(P, "o"); 252 DepTarget = Args.MakeArgString(llvm::sys::path::filename(P)); 253 } 254 255 CmdArgs.push_back("-MT"); 256 llvm::SmallString<128> Quoted; 257 QuoteTarget(DepTarget, Quoted); 258 CmdArgs.push_back(Args.MakeArgString(Quoted)); 259 } 260 261 if (A->getOption().matches(options::OPT_M) || 262 A->getOption().matches(options::OPT_MD)) 263 CmdArgs.push_back("-sys-header-deps"); 264 } 265 266 if (Args.hasArg(options::OPT_MG)) { 267 if (!A || A->getOption().matches(options::OPT_MD) || 268 A->getOption().matches(options::OPT_MMD)) 269 D.Diag(diag::err_drv_mg_requires_m_or_mm); 270 CmdArgs.push_back("-MG"); 271 } 272 273 Args.AddLastArg(CmdArgs, options::OPT_MP); 274 275 // Convert all -MQ <target> args to -MT <quoted target> 276 for (arg_iterator it = Args.filtered_begin(options::OPT_MT, 277 options::OPT_MQ), 278 ie = Args.filtered_end(); it != ie; ++it) { 279 const Arg *A = *it; 280 A->claim(); 281 282 if (A->getOption().matches(options::OPT_MQ)) { 283 CmdArgs.push_back("-MT"); 284 llvm::SmallString<128> Quoted; 285 QuoteTarget(A->getValue(Args), Quoted); 286 CmdArgs.push_back(Args.MakeArgString(Quoted)); 287 288 // -MT flag - no change 289 } else { 290 A->render(Args, CmdArgs); 291 } 292 } 293 294 // Add -i* options, and automatically translate to 295 // -include-pch/-include-pth for transparent PCH support. It's 296 // wonky, but we include looking for .gch so we can support seamless 297 // replacement into a build system already set up to be generating 298 // .gch files. 299 bool RenderedImplicitInclude = false; 300 for (arg_iterator it = Args.filtered_begin(options::OPT_clang_i_Group), 301 ie = Args.filtered_end(); it != ie; ++it) { 302 const Arg *A = it; 303 304 if (A->getOption().matches(options::OPT_include)) { 305 bool IsFirstImplicitInclude = !RenderedImplicitInclude; 306 RenderedImplicitInclude = true; 307 308 // Use PCH if the user requested it. 309 bool UsePCH = D.CCCUsePCH; 310 311 bool FoundPTH = false; 312 bool FoundPCH = false; 313 llvm::sys::Path P(A->getValue(Args)); 314 bool Exists; 315 if (UsePCH) { 316 P.appendSuffix("pch"); 317 if (!llvm::sys::fs::exists(P.str(), Exists) && Exists) 318 FoundPCH = true; 319 else 320 P.eraseSuffix(); 321 } 322 323 if (!FoundPCH) { 324 P.appendSuffix("pth"); 325 if (!llvm::sys::fs::exists(P.str(), Exists) && Exists) 326 FoundPTH = true; 327 else 328 P.eraseSuffix(); 329 } 330 331 if (!FoundPCH && !FoundPTH) { 332 P.appendSuffix("gch"); 333 if (!llvm::sys::fs::exists(P.str(), Exists) && Exists) { 334 FoundPCH = UsePCH; 335 FoundPTH = !UsePCH; 336 } 337 else 338 P.eraseSuffix(); 339 } 340 341 if (FoundPCH || FoundPTH) { 342 if (IsFirstImplicitInclude) { 343 A->claim(); 344 if (UsePCH) 345 CmdArgs.push_back("-include-pch"); 346 else 347 CmdArgs.push_back("-include-pth"); 348 CmdArgs.push_back(Args.MakeArgString(P.str())); 349 continue; 350 } else { 351 // Ignore the PCH if not first on command line and emit warning. 352 D.Diag(diag::warn_drv_pch_not_first_include) 353 << P.str() << A->getAsString(Args); 354 } 355 } 356 } 357 358 // Not translated, render as usual. 359 A->claim(); 360 A->render(Args, CmdArgs); 361 } 362 363 Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U); 364 Args.AddAllArgs(CmdArgs, options::OPT_I_Group, options::OPT_F, 365 options::OPT_index_header_map); 366 367 // Add C++ include arguments, if needed. 368 types::ID InputType = Inputs[0].getType(); 369 if (types::isCXX(InputType)) { 370 bool ObjCXXAutoRefCount 371 = types::isObjC(InputType) && isObjCAutoRefCount(Args); 372 getToolChain().AddClangCXXStdlibIncludeArgs(Args, CmdArgs, 373 ObjCXXAutoRefCount); 374 Args.AddAllArgs(CmdArgs, options::OPT_stdlib_EQ); 375 } 376 377 // Add -Wp, and -Xassembler if using the preprocessor. 378 379 // FIXME: There is a very unfortunate problem here, some troubled 380 // souls abuse -Wp, to pass preprocessor options in gcc syntax. To 381 // really support that we would have to parse and then translate 382 // those options. :( 383 Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA, 384 options::OPT_Xpreprocessor); 385 386 // -I- is a deprecated GCC feature, reject it. 387 if (Arg *A = Args.getLastArg(options::OPT_I_)) 388 D.Diag(diag::err_drv_I_dash_not_supported) << A->getAsString(Args); 389 390 // If we have a --sysroot, and don't have an explicit -isysroot flag, add an 391 // -isysroot to the CC1 invocation. 392 if (Arg *A = Args.getLastArg(options::OPT__sysroot_EQ)) { 393 if (!Args.hasArg(options::OPT_isysroot)) { 394 CmdArgs.push_back("-isysroot"); 395 CmdArgs.push_back(A->getValue(Args)); 396 } 397 } 398 399 // If a module path was provided, pass it along. Otherwise, use a temporary 400 // directory. 401 if (Arg *A = Args.getLastArg(options::OPT_fmodule_cache_path)) { 402 A->claim(); 403 A->render(Args, CmdArgs); 404 } else { 405 llvm::SmallString<128> DefaultModuleCache; 406 llvm::sys::path::system_temp_directory(/*erasedOnReboot=*/false, 407 DefaultModuleCache); 408 llvm::sys::path::append(DefaultModuleCache, "clang-module-cache"); 409 CmdArgs.push_back("-fmodule-cache-path"); 410 CmdArgs.push_back(Args.MakeArgString(DefaultModuleCache)); 411 } 412 413 Args.AddAllArgs(CmdArgs, options::OPT_fauto_module_import); 414 415 // Parse additional include paths from environment variables. 416 // CPATH - included following the user specified includes (but prior to 417 // builtin and standard includes). 418 AddIncludeDirectoryList(Args, CmdArgs, "-I", ::getenv("CPATH")); 419 // C_INCLUDE_PATH - system includes enabled when compiling C. 420 AddIncludeDirectoryList(Args, CmdArgs, "-c-isystem", 421 ::getenv("C_INCLUDE_PATH")); 422 // CPLUS_INCLUDE_PATH - system includes enabled when compiling C++. 423 AddIncludeDirectoryList(Args, CmdArgs, "-cxx-isystem", 424 ::getenv("CPLUS_INCLUDE_PATH")); 425 // OBJC_INCLUDE_PATH - system includes enabled when compiling ObjC. 426 AddIncludeDirectoryList(Args, CmdArgs, "-objc-isystem", 427 ::getenv("OBJC_INCLUDE_PATH")); 428 // OBJCPLUS_INCLUDE_PATH - system includes enabled when compiling ObjC++. 429 AddIncludeDirectoryList(Args, CmdArgs, "-objcxx-isystem", 430 ::getenv("OBJCPLUS_INCLUDE_PATH")); 431} 432 433/// getARMTargetCPU - Get the (LLVM) name of the ARM cpu we are targeting. 434// 435// FIXME: tblgen this. 436static const char *getARMTargetCPU(const ArgList &Args, 437 const llvm::Triple &Triple) { 438 // FIXME: Warn on inconsistent use of -mcpu and -march. 439 440 // If we have -mcpu=, use that. 441 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) 442 return A->getValue(Args); 443 444 StringRef MArch; 445 if (Arg *A = Args.getLastArg(options::OPT_march_EQ)) { 446 // Otherwise, if we have -march= choose the base CPU for that arch. 447 MArch = A->getValue(Args); 448 } else { 449 // Otherwise, use the Arch from the triple. 450 MArch = Triple.getArchName(); 451 } 452 453 if (MArch == "armv2" || MArch == "armv2a") 454 return "arm2"; 455 if (MArch == "armv3") 456 return "arm6"; 457 if (MArch == "armv3m") 458 return "arm7m"; 459 if (MArch == "armv4" || MArch == "armv4t") 460 return "arm7tdmi"; 461 if (MArch == "armv5" || MArch == "armv5t") 462 return "arm10tdmi"; 463 if (MArch == "armv5e" || MArch == "armv5te") 464 return "arm1026ejs"; 465 if (MArch == "armv5tej") 466 return "arm926ej-s"; 467 if (MArch == "armv6" || MArch == "armv6k") 468 return "arm1136jf-s"; 469 if (MArch == "armv6j") 470 return "arm1136j-s"; 471 if (MArch == "armv6z" || MArch == "armv6zk") 472 return "arm1176jzf-s"; 473 if (MArch == "armv6t2") 474 return "arm1156t2-s"; 475 if (MArch == "armv7" || MArch == "armv7a" || MArch == "armv7-a") 476 return "cortex-a8"; 477 if (MArch == "armv7r" || MArch == "armv7-r") 478 return "cortex-r4"; 479 if (MArch == "armv7m" || MArch == "armv7-m") 480 return "cortex-m3"; 481 if (MArch == "ep9312") 482 return "ep9312"; 483 if (MArch == "iwmmxt") 484 return "iwmmxt"; 485 if (MArch == "xscale") 486 return "xscale"; 487 if (MArch == "armv6m" || MArch == "armv6-m") 488 return "cortex-m0"; 489 490 // If all else failed, return the most base CPU LLVM supports. 491 return "arm7tdmi"; 492} 493 494/// getLLVMArchSuffixForARM - Get the LLVM arch name to use for a particular 495/// CPU. 496// 497// FIXME: This is redundant with -mcpu, why does LLVM use this. 498// FIXME: tblgen this, or kill it! 499static const char *getLLVMArchSuffixForARM(StringRef CPU) { 500 if (CPU == "arm7tdmi" || CPU == "arm7tdmi-s" || CPU == "arm710t" || 501 CPU == "arm720t" || CPU == "arm9" || CPU == "arm9tdmi" || 502 CPU == "arm920" || CPU == "arm920t" || CPU == "arm922t" || 503 CPU == "arm940t" || CPU == "ep9312") 504 return "v4t"; 505 506 if (CPU == "arm10tdmi" || CPU == "arm1020t") 507 return "v5"; 508 509 if (CPU == "arm9e" || CPU == "arm926ej-s" || CPU == "arm946e-s" || 510 CPU == "arm966e-s" || CPU == "arm968e-s" || CPU == "arm10e" || 511 CPU == "arm1020e" || CPU == "arm1022e" || CPU == "xscale" || 512 CPU == "iwmmxt") 513 return "v5e"; 514 515 if (CPU == "arm1136j-s" || CPU == "arm1136jf-s" || CPU == "arm1176jz-s" || 516 CPU == "arm1176jzf-s" || CPU == "mpcorenovfp" || CPU == "mpcore") 517 return "v6"; 518 519 if (CPU == "arm1156t2-s" || CPU == "arm1156t2f-s") 520 return "v6t2"; 521 522 if (CPU == "cortex-a8" || CPU == "cortex-a9") 523 return "v7"; 524 525 return ""; 526} 527 528// FIXME: Move to target hook. 529static bool isSignedCharDefault(const llvm::Triple &Triple) { 530 switch (Triple.getArch()) { 531 default: 532 return true; 533 534 case llvm::Triple::arm: 535 case llvm::Triple::ppc: 536 case llvm::Triple::ppc64: 537 if (Triple.getOS() == llvm::Triple::Darwin) 538 return true; 539 return false; 540 541 case llvm::Triple::systemz: 542 return false; 543 } 544} 545 546void Clang::AddARMTargetArgs(const ArgList &Args, 547 ArgStringList &CmdArgs, 548 bool KernelOrKext) const { 549 const Driver &D = getToolChain().getDriver(); 550 llvm::Triple Triple = getToolChain().getTriple(); 551 552 // Disable movt generation, if requested. 553#ifdef DISABLE_ARM_DARWIN_USE_MOVT 554 CmdArgs.push_back("-backend-option"); 555 CmdArgs.push_back("-arm-darwin-use-movt=0"); 556#endif 557 558 // Select the ABI to use. 559 // 560 // FIXME: Support -meabi. 561 const char *ABIName = 0; 562 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) { 563 ABIName = A->getValue(Args); 564 } else { 565 // Select the default based on the platform. 566 switch(Triple.getEnvironment()) { 567 case llvm::Triple::GNUEABI: 568 ABIName = "aapcs-linux"; 569 break; 570 case llvm::Triple::EABI: 571 ABIName = "aapcs"; 572 break; 573 default: 574 ABIName = "apcs-gnu"; 575 } 576 } 577 CmdArgs.push_back("-target-abi"); 578 CmdArgs.push_back(ABIName); 579 580 // Set the CPU based on -march= and -mcpu=. 581 CmdArgs.push_back("-target-cpu"); 582 CmdArgs.push_back(getARMTargetCPU(Args, Triple)); 583 584 // Select the float ABI as determined by -msoft-float, -mhard-float, and 585 // -mfloat-abi=. 586 StringRef FloatABI; 587 if (Arg *A = Args.getLastArg(options::OPT_msoft_float, 588 options::OPT_mhard_float, 589 options::OPT_mfloat_abi_EQ)) { 590 if (A->getOption().matches(options::OPT_msoft_float)) 591 FloatABI = "soft"; 592 else if (A->getOption().matches(options::OPT_mhard_float)) 593 FloatABI = "hard"; 594 else { 595 FloatABI = A->getValue(Args); 596 if (FloatABI != "soft" && FloatABI != "softfp" && FloatABI != "hard") { 597 D.Diag(diag::err_drv_invalid_mfloat_abi) 598 << A->getAsString(Args); 599 FloatABI = "soft"; 600 } 601 } 602 } 603 604 // If unspecified, choose the default based on the platform. 605 if (FloatABI.empty()) { 606 const llvm::Triple &Triple = getToolChain().getTriple(); 607 switch (Triple.getOS()) { 608 case llvm::Triple::Darwin: { 609 // Darwin defaults to "softfp" for v6 and v7. 610 // 611 // FIXME: Factor out an ARM class so we can cache the arch somewhere. 612 StringRef ArchName = 613 getLLVMArchSuffixForARM(getARMTargetCPU(Args, Triple)); 614 if (ArchName.startswith("v6") || ArchName.startswith("v7")) 615 FloatABI = "softfp"; 616 else 617 FloatABI = "soft"; 618 break; 619 } 620 621 case llvm::Triple::Linux: { 622 if (getToolChain().getTriple().getEnvironment() == llvm::Triple::GNUEABI) { 623 FloatABI = "softfp"; 624 break; 625 } 626 } 627 // fall through 628 629 default: 630 switch(Triple.getEnvironment()) { 631 case llvm::Triple::GNUEABI: 632 FloatABI = "softfp"; 633 break; 634 case llvm::Triple::EABI: 635 // EABI is always AAPCS, and if it was not marked 'hard', it's softfp 636 FloatABI = "softfp"; 637 break; 638 default: 639 // Assume "soft", but warn the user we are guessing. 640 FloatABI = "soft"; 641 D.Diag(diag::warn_drv_assuming_mfloat_abi_is) << "soft"; 642 break; 643 } 644 } 645 } 646 647 if (FloatABI == "soft") { 648 // Floating point operations and argument passing are soft. 649 // 650 // FIXME: This changes CPP defines, we need -target-soft-float. 651 CmdArgs.push_back("-msoft-float"); 652 CmdArgs.push_back("-mfloat-abi"); 653 CmdArgs.push_back("soft"); 654 } else if (FloatABI == "softfp") { 655 // Floating point operations are hard, but argument passing is soft. 656 CmdArgs.push_back("-mfloat-abi"); 657 CmdArgs.push_back("soft"); 658 } else { 659 // Floating point operations and argument passing are hard. 660 assert(FloatABI == "hard" && "Invalid float abi!"); 661 CmdArgs.push_back("-mfloat-abi"); 662 CmdArgs.push_back("hard"); 663 } 664 665 // Set appropriate target features for floating point mode. 666 // 667 // FIXME: Note, this is a hack, the LLVM backend doesn't actually use these 668 // yet (it uses the -mfloat-abi and -msoft-float options above), and it is 669 // stripped out by the ARM target. 670 671 // Use software floating point operations? 672 if (FloatABI == "soft") { 673 CmdArgs.push_back("-target-feature"); 674 CmdArgs.push_back("+soft-float"); 675 } 676 677 // Use software floating point argument passing? 678 if (FloatABI != "hard") { 679 CmdArgs.push_back("-target-feature"); 680 CmdArgs.push_back("+soft-float-abi"); 681 } 682 683 // Honor -mfpu=. 684 // 685 // FIXME: Centralize feature selection, defaulting shouldn't be also in the 686 // frontend target. 687 if (const Arg *A = Args.getLastArg(options::OPT_mfpu_EQ)) { 688 StringRef FPU = A->getValue(Args); 689 690 // Set the target features based on the FPU. 691 if (FPU == "fpa" || FPU == "fpe2" || FPU == "fpe3" || FPU == "maverick") { 692 // Disable any default FPU support. 693 CmdArgs.push_back("-target-feature"); 694 CmdArgs.push_back("-vfp2"); 695 CmdArgs.push_back("-target-feature"); 696 CmdArgs.push_back("-vfp3"); 697 CmdArgs.push_back("-target-feature"); 698 CmdArgs.push_back("-neon"); 699 } else if (FPU == "vfp") { 700 CmdArgs.push_back("-target-feature"); 701 CmdArgs.push_back("+vfp2"); 702 } else if (FPU == "vfp3") { 703 CmdArgs.push_back("-target-feature"); 704 CmdArgs.push_back("+vfp3"); 705 } else if (FPU == "neon") { 706 CmdArgs.push_back("-target-feature"); 707 CmdArgs.push_back("+neon"); 708 } else 709 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args); 710 } 711 712 // Setting -msoft-float effectively disables NEON because of the GCC 713 // implementation, although the same isn't true of VFP or VFP3. 714 if (FloatABI == "soft") { 715 CmdArgs.push_back("-target-feature"); 716 CmdArgs.push_back("-neon"); 717 } 718 719 // Kernel code has more strict alignment requirements. 720 if (KernelOrKext) { 721 CmdArgs.push_back("-backend-option"); 722 CmdArgs.push_back("-arm-long-calls"); 723 724 CmdArgs.push_back("-backend-option"); 725 CmdArgs.push_back("-arm-strict-align"); 726 727 // The kext linker doesn't know how to deal with movw/movt. 728#ifndef DISABLE_ARM_DARWIN_USE_MOVT 729 CmdArgs.push_back("-backend-option"); 730 CmdArgs.push_back("-arm-darwin-use-movt=0"); 731#endif 732 } 733 734 // Setting -mno-global-merge disables the codegen global merge pass. Setting 735 // -mglobal-merge has no effect as the pass is enabled by default. 736 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge, 737 options::OPT_mno_global_merge)) { 738 if (A->getOption().matches(options::OPT_mno_global_merge)) 739 CmdArgs.push_back("-mno-global-merge"); 740 } 741} 742 743// Get default architecture. 744static const char* getMipsArchFromCPU(StringRef CPUName) { 745 if (CPUName == "mips32r1" || CPUName == "4ke") 746 return "mips"; 747 748 assert((CPUName == "mips64r1" || CPUName == "mips64r2") && 749 "Unexpected cpu name."); 750 751 return "mips64"; 752} 753 754// Get default target cpu. 755static const char* getMipsCPUFromArch(StringRef ArchName, const Driver &D) { 756 if (ArchName == "mips" || ArchName == "mipsel") 757 return "mips32r1"; 758 else if (ArchName == "mips64" || ArchName == "mips64el") 759 return "mips64r1"; 760 else 761 D.Diag(diag::err_drv_invalid_arch_name) << ArchName; 762 763 return 0; 764} 765 766// Get default ABI. 767static const char* getMipsABIFromArch(StringRef ArchName) { 768 if (ArchName == "mips" || ArchName == "mipsel") 769 return "o32"; 770 771 assert((ArchName == "mips64" || ArchName == "mips64el") && 772 "Unexpected arch name."); 773 return "n64"; 774} 775 776void Clang::AddMIPSTargetArgs(const ArgList &Args, 777 ArgStringList &CmdArgs) const { 778 const Driver &D = getToolChain().getDriver(); 779 780 StringRef ArchName; 781 const char *CPUName; 782 783 // Set target cpu and architecture. 784 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) { 785 CPUName = A->getValue(Args); 786 ArchName = getMipsArchFromCPU(CPUName); 787 } 788 else { 789 ArchName = Args.MakeArgString(getToolChain().getArchName()); 790 CPUName = getMipsCPUFromArch(ArchName, D); 791 } 792 793 CmdArgs.push_back("-target-cpu"); 794 CmdArgs.push_back(CPUName); 795 796 // Select the ABI to use. 797 const char *ABIName = 0; 798 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) 799 ABIName = A->getValue(Args); 800 else 801 ABIName = getMipsABIFromArch(ArchName); 802 803 CmdArgs.push_back("-target-abi"); 804 CmdArgs.push_back(ABIName); 805 806 // Select the float ABI as determined by -msoft-float, -mhard-float, and 807 StringRef FloatABI; 808 if (Arg *A = Args.getLastArg(options::OPT_msoft_float, 809 options::OPT_mhard_float)) { 810 if (A->getOption().matches(options::OPT_msoft_float)) 811 FloatABI = "soft"; 812 else if (A->getOption().matches(options::OPT_mhard_float)) 813 FloatABI = "hard"; 814 } 815 816 // If unspecified, choose the default based on the platform. 817 if (FloatABI.empty()) { 818 // Assume "soft", but warn the user we are guessing. 819 FloatABI = "soft"; 820 D.Diag(diag::warn_drv_assuming_mfloat_abi_is) << "soft"; 821 } 822 823 if (FloatABI == "soft") { 824 // Floating point operations and argument passing are soft. 825 // 826 // FIXME: This changes CPP defines, we need -target-soft-float. 827 CmdArgs.push_back("-msoft-float"); 828 } else { 829 assert(FloatABI == "hard" && "Invalid float abi!"); 830 CmdArgs.push_back("-mhard-float"); 831 } 832} 833 834void Clang::AddSparcTargetArgs(const ArgList &Args, 835 ArgStringList &CmdArgs) const { 836 const Driver &D = getToolChain().getDriver(); 837 838 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) { 839 StringRef MArch = A->getValue(Args); 840 CmdArgs.push_back("-target-cpu"); 841 CmdArgs.push_back(MArch.str().c_str()); 842 } 843 844 // Select the float ABI as determined by -msoft-float, -mhard-float, and 845 StringRef FloatABI; 846 if (Arg *A = Args.getLastArg(options::OPT_msoft_float, 847 options::OPT_mhard_float)) { 848 if (A->getOption().matches(options::OPT_msoft_float)) 849 FloatABI = "soft"; 850 else if (A->getOption().matches(options::OPT_mhard_float)) 851 FloatABI = "hard"; 852 } 853 854 // If unspecified, choose the default based on the platform. 855 if (FloatABI.empty()) { 856 switch (getToolChain().getTriple().getOS()) { 857 default: 858 // Assume "soft", but warn the user we are guessing. 859 FloatABI = "soft"; 860 D.Diag(diag::warn_drv_assuming_mfloat_abi_is) << "soft"; 861 break; 862 } 863 } 864 865 if (FloatABI == "soft") { 866 // Floating point operations and argument passing are soft. 867 // 868 // FIXME: This changes CPP defines, we need -target-soft-float. 869 CmdArgs.push_back("-msoft-float"); 870 CmdArgs.push_back("-target-feature"); 871 CmdArgs.push_back("+soft-float"); 872 } else { 873 assert(FloatABI == "hard" && "Invalid float abi!"); 874 CmdArgs.push_back("-mhard-float"); 875 } 876} 877 878void Clang::AddX86TargetArgs(const ArgList &Args, 879 ArgStringList &CmdArgs) const { 880 if (!Args.hasFlag(options::OPT_mred_zone, 881 options::OPT_mno_red_zone, 882 true) || 883 Args.hasArg(options::OPT_mkernel) || 884 Args.hasArg(options::OPT_fapple_kext)) 885 CmdArgs.push_back("-disable-red-zone"); 886 887 if (Args.hasFlag(options::OPT_msoft_float, 888 options::OPT_mno_soft_float, 889 false)) 890 CmdArgs.push_back("-no-implicit-float"); 891 892 const char *CPUName = 0; 893 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) { 894 if (StringRef(A->getValue(Args)) == "native") { 895 // FIXME: Reject attempts to use -march=native unless the target matches 896 // the host. 897 // 898 // FIXME: We should also incorporate the detected target features for use 899 // with -native. 900 std::string CPU = llvm::sys::getHostCPUName(); 901 if (!CPU.empty()) 902 CPUName = Args.MakeArgString(CPU); 903 } else 904 CPUName = A->getValue(Args); 905 } 906 907 // Select the default CPU if none was given (or detection failed). 908 if (!CPUName) { 909 // FIXME: Need target hooks. 910 if (getToolChain().getOS().startswith("darwin")) { 911 if (getToolChain().getArch() == llvm::Triple::x86_64) 912 CPUName = "core2"; 913 else if (getToolChain().getArch() == llvm::Triple::x86) 914 CPUName = "yonah"; 915 } else if (getToolChain().getOS().startswith("haiku")) { 916 if (getToolChain().getArch() == llvm::Triple::x86_64) 917 CPUName = "x86-64"; 918 else if (getToolChain().getArch() == llvm::Triple::x86) 919 CPUName = "i586"; 920 } else if (getToolChain().getOS().startswith("openbsd")) { 921 if (getToolChain().getArch() == llvm::Triple::x86_64) 922 CPUName = "x86-64"; 923 else if (getToolChain().getArch() == llvm::Triple::x86) 924 CPUName = "i486"; 925 } else if (getToolChain().getOS().startswith("freebsd")) { 926 if (getToolChain().getArch() == llvm::Triple::x86_64) 927 CPUName = "x86-64"; 928 else if (getToolChain().getArch() == llvm::Triple::x86) 929 CPUName = "i486"; 930 } else if (getToolChain().getOS().startswith("netbsd")) { 931 if (getToolChain().getArch() == llvm::Triple::x86_64) 932 CPUName = "x86-64"; 933 else if (getToolChain().getArch() == llvm::Triple::x86) 934 CPUName = "i486"; 935 } else { 936 if (getToolChain().getArch() == llvm::Triple::x86_64) 937 CPUName = "x86-64"; 938 else if (getToolChain().getArch() == llvm::Triple::x86) 939 CPUName = "pentium4"; 940 } 941 } 942 943 if (CPUName) { 944 CmdArgs.push_back("-target-cpu"); 945 CmdArgs.push_back(CPUName); 946 } 947 948 // The required algorithm here is slightly strange: the options are applied 949 // in order (so -mno-sse -msse2 disables SSE3), but any option that gets 950 // directly overridden later is ignored (so "-mno-sse -msse2 -mno-sse2 -msse" 951 // is equivalent to "-mno-sse2 -msse"). The -cc1 handling deals with the 952 // former correctly, but not the latter; handle directly-overridden 953 // attributes here. 954 llvm::StringMap<unsigned> PrevFeature; 955 std::vector<const char*> Features; 956 for (arg_iterator it = Args.filtered_begin(options::OPT_m_x86_Features_Group), 957 ie = Args.filtered_end(); it != ie; ++it) { 958 StringRef Name = (*it)->getOption().getName(); 959 (*it)->claim(); 960 961 // Skip over "-m". 962 assert(Name.startswith("-m") && "Invalid feature name."); 963 Name = Name.substr(2); 964 965 bool IsNegative = Name.startswith("no-"); 966 if (IsNegative) 967 Name = Name.substr(3); 968 969 unsigned& Prev = PrevFeature[Name]; 970 if (Prev) 971 Features[Prev - 1] = 0; 972 Prev = Features.size() + 1; 973 Features.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name)); 974 } 975 for (unsigned i = 0; i < Features.size(); i++) { 976 if (Features[i]) { 977 CmdArgs.push_back("-target-feature"); 978 CmdArgs.push_back(Features[i]); 979 } 980 } 981} 982 983static bool 984shouldUseExceptionTablesForObjCExceptions(unsigned objcABIVersion, 985 const llvm::Triple &Triple) { 986 // We use the zero-cost exception tables for Objective-C if the non-fragile 987 // ABI is enabled or when compiling for x86_64 and ARM on Snow Leopard and 988 // later. 989 990 if (objcABIVersion >= 2) 991 return true; 992 993 if (Triple.getOS() != llvm::Triple::Darwin) 994 return false; 995 996 return (!Triple.isMacOSXVersionLT(10,5) && 997 (Triple.getArch() == llvm::Triple::x86_64 || 998 Triple.getArch() == llvm::Triple::arm)); 999} 1000 1001/// addExceptionArgs - Adds exception related arguments to the driver command 1002/// arguments. There's a master flag, -fexceptions and also language specific 1003/// flags to enable/disable C++ and Objective-C exceptions. 1004/// This makes it possible to for example disable C++ exceptions but enable 1005/// Objective-C exceptions. 1006static void addExceptionArgs(const ArgList &Args, types::ID InputType, 1007 const llvm::Triple &Triple, 1008 bool KernelOrKext, bool IsRewriter, 1009 unsigned objcABIVersion, 1010 ArgStringList &CmdArgs) { 1011 if (KernelOrKext) 1012 return; 1013 1014 // Exceptions are enabled by default. 1015 bool ExceptionsEnabled = true; 1016 1017 // This keeps track of whether exceptions were explicitly turned on or off. 1018 bool DidHaveExplicitExceptionFlag = false; 1019 1020 if (Arg *A = Args.getLastArg(options::OPT_fexceptions, 1021 options::OPT_fno_exceptions)) { 1022 if (A->getOption().matches(options::OPT_fexceptions)) 1023 ExceptionsEnabled = true; 1024 else 1025 ExceptionsEnabled = false; 1026 1027 DidHaveExplicitExceptionFlag = true; 1028 } 1029 1030 bool ShouldUseExceptionTables = false; 1031 1032 // Exception tables and cleanups can be enabled with -fexceptions even if the 1033 // language itself doesn't support exceptions. 1034 if (ExceptionsEnabled && DidHaveExplicitExceptionFlag) 1035 ShouldUseExceptionTables = true; 1036 1037 // Obj-C exceptions are enabled by default, regardless of -fexceptions. This 1038 // is not necessarily sensible, but follows GCC. 1039 if (types::isObjC(InputType) && 1040 Args.hasFlag(options::OPT_fobjc_exceptions, 1041 options::OPT_fno_objc_exceptions, 1042 true)) { 1043 CmdArgs.push_back("-fobjc-exceptions"); 1044 1045 ShouldUseExceptionTables |= 1046 shouldUseExceptionTablesForObjCExceptions(objcABIVersion, Triple); 1047 } 1048 1049 if (types::isCXX(InputType)) { 1050 bool CXXExceptionsEnabled = ExceptionsEnabled; 1051 1052 if (Arg *A = Args.getLastArg(options::OPT_fcxx_exceptions, 1053 options::OPT_fno_cxx_exceptions, 1054 options::OPT_fexceptions, 1055 options::OPT_fno_exceptions)) { 1056 if (A->getOption().matches(options::OPT_fcxx_exceptions)) 1057 CXXExceptionsEnabled = true; 1058 else if (A->getOption().matches(options::OPT_fno_cxx_exceptions)) 1059 CXXExceptionsEnabled = false; 1060 } 1061 1062 if (CXXExceptionsEnabled) { 1063 CmdArgs.push_back("-fcxx-exceptions"); 1064 1065 ShouldUseExceptionTables = true; 1066 } 1067 } 1068 1069 if (ShouldUseExceptionTables) 1070 CmdArgs.push_back("-fexceptions"); 1071} 1072 1073static bool ShouldDisableCFI(const ArgList &Args, 1074 const ToolChain &TC) { 1075 if (TC.getTriple().getOS() == llvm::Triple::Darwin) { 1076 // The native darwin assembler doesn't support cfi directives, so 1077 // we disable them if we think the .s file will be passed to it. 1078 1079 // FIXME: Duplicated code with ToolChains.cpp 1080 // FIXME: This doesn't belong here, but ideally we will support static soon 1081 // anyway. 1082 bool HasStatic = (Args.hasArg(options::OPT_mkernel) || 1083 Args.hasArg(options::OPT_static) || 1084 Args.hasArg(options::OPT_fapple_kext)); 1085 bool IsIADefault = TC.IsIntegratedAssemblerDefault() && !HasStatic; 1086 bool UseIntegratedAs = Args.hasFlag(options::OPT_integrated_as, 1087 options::OPT_no_integrated_as, 1088 IsIADefault); 1089 bool UseCFI = Args.hasFlag(options::OPT_fdwarf2_cfi_asm, 1090 options::OPT_fno_dwarf2_cfi_asm, 1091 UseIntegratedAs); 1092 return !UseCFI; 1093 } 1094 1095 // For now we assume that every other assembler support CFI. 1096 return false; 1097} 1098 1099/// \brief Check whether the given input tree contains any compilation actions. 1100static bool ContainsCompileAction(const Action *A) { 1101 if (isa<CompileJobAction>(A)) 1102 return true; 1103 1104 for (Action::const_iterator it = A->begin(), ie = A->end(); it != ie; ++it) 1105 if (ContainsCompileAction(*it)) 1106 return true; 1107 1108 return false; 1109} 1110 1111/// \brief Check if -relax-all should be passed to the internal assembler. 1112/// This is done by default when compiling non-assembler source with -O0. 1113static bool UseRelaxAll(Compilation &C, const ArgList &Args) { 1114 bool RelaxDefault = true; 1115 1116 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) 1117 RelaxDefault = A->getOption().matches(options::OPT_O0); 1118 1119 if (RelaxDefault) { 1120 RelaxDefault = false; 1121 for (ActionList::const_iterator it = C.getActions().begin(), 1122 ie = C.getActions().end(); it != ie; ++it) { 1123 if (ContainsCompileAction(*it)) { 1124 RelaxDefault = true; 1125 break; 1126 } 1127 } 1128 } 1129 1130 return Args.hasFlag(options::OPT_mrelax_all, options::OPT_mno_relax_all, 1131 RelaxDefault); 1132} 1133 1134void Clang::ConstructJob(Compilation &C, const JobAction &JA, 1135 const InputInfo &Output, 1136 const InputInfoList &Inputs, 1137 const ArgList &Args, 1138 const char *LinkingOutput) const { 1139 bool KernelOrKext = Args.hasArg(options::OPT_mkernel, 1140 options::OPT_fapple_kext); 1141 const Driver &D = getToolChain().getDriver(); 1142 ArgStringList CmdArgs; 1143 1144 assert(Inputs.size() == 1 && "Unable to handle multiple inputs."); 1145 1146 // Invoke ourselves in -cc1 mode. 1147 // 1148 // FIXME: Implement custom jobs for internal actions. 1149 CmdArgs.push_back("-cc1"); 1150 1151 // Add the "effective" target triple. 1152 CmdArgs.push_back("-triple"); 1153 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args); 1154 CmdArgs.push_back(Args.MakeArgString(TripleStr)); 1155 1156 // Select the appropriate action. 1157 bool IsRewriter = false; 1158 if (isa<AnalyzeJobAction>(JA)) { 1159 assert(JA.getType() == types::TY_Plist && "Invalid output type."); 1160 CmdArgs.push_back("-analyze"); 1161 } else if (isa<PreprocessJobAction>(JA)) { 1162 if (Output.getType() == types::TY_Dependencies) 1163 CmdArgs.push_back("-Eonly"); 1164 else 1165 CmdArgs.push_back("-E"); 1166 } else if (isa<AssembleJobAction>(JA)) { 1167 CmdArgs.push_back("-emit-obj"); 1168 1169 if (UseRelaxAll(C, Args)) 1170 CmdArgs.push_back("-mrelax-all"); 1171 1172 // When using an integrated assembler, translate -Wa, and -Xassembler 1173 // options. 1174 for (arg_iterator it = Args.filtered_begin(options::OPT_Wa_COMMA, 1175 options::OPT_Xassembler), 1176 ie = Args.filtered_end(); it != ie; ++it) { 1177 const Arg *A = *it; 1178 A->claim(); 1179 1180 for (unsigned i = 0, e = A->getNumValues(); i != e; ++i) { 1181 StringRef Value = A->getValue(Args, i); 1182 1183 if (Value == "-force_cpusubtype_ALL") { 1184 // Do nothing, this is the default and we don't support anything else. 1185 } else if (Value == "-L") { 1186 CmdArgs.push_back("-msave-temp-labels"); 1187 } else if (Value == "--fatal-warnings") { 1188 CmdArgs.push_back("-mllvm"); 1189 CmdArgs.push_back("-fatal-assembler-warnings"); 1190 } else if (Value == "--noexecstack") { 1191 CmdArgs.push_back("-mnoexecstack"); 1192 } else { 1193 D.Diag(diag::err_drv_unsupported_option_argument) 1194 << A->getOption().getName() << Value; 1195 } 1196 } 1197 } 1198 1199 // Also ignore explicit -force_cpusubtype_ALL option. 1200 (void) Args.hasArg(options::OPT_force__cpusubtype__ALL); 1201 } else if (isa<PrecompileJobAction>(JA)) { 1202 // Use PCH if the user requested it. 1203 bool UsePCH = D.CCCUsePCH; 1204 1205 if (UsePCH) 1206 CmdArgs.push_back("-emit-pch"); 1207 else 1208 CmdArgs.push_back("-emit-pth"); 1209 } else { 1210 assert(isa<CompileJobAction>(JA) && "Invalid action for clang tool."); 1211 1212 if (JA.getType() == types::TY_Nothing) { 1213 CmdArgs.push_back("-fsyntax-only"); 1214 } else if (JA.getType() == types::TY_LLVM_IR || 1215 JA.getType() == types::TY_LTO_IR) { 1216 CmdArgs.push_back("-emit-llvm"); 1217 } else if (JA.getType() == types::TY_LLVM_BC || 1218 JA.getType() == types::TY_LTO_BC) { 1219 CmdArgs.push_back("-emit-llvm-bc"); 1220 } else if (JA.getType() == types::TY_PP_Asm) { 1221 CmdArgs.push_back("-S"); 1222 } else if (JA.getType() == types::TY_AST) { 1223 CmdArgs.push_back("-emit-pch"); 1224 } else if (JA.getType() == types::TY_RewrittenObjC) { 1225 CmdArgs.push_back("-rewrite-objc"); 1226 IsRewriter = true; 1227 } else { 1228 assert(JA.getType() == types::TY_PP_Asm && 1229 "Unexpected output type!"); 1230 } 1231 } 1232 1233 // The make clang go fast button. 1234 CmdArgs.push_back("-disable-free"); 1235 1236 // Disable the verification pass in -asserts builds. 1237#ifdef NDEBUG 1238 CmdArgs.push_back("-disable-llvm-verifier"); 1239#endif 1240 1241 // Set the main file name, so that debug info works even with 1242 // -save-temps. 1243 CmdArgs.push_back("-main-file-name"); 1244 CmdArgs.push_back(darwin::CC1::getBaseInputName(Args, Inputs)); 1245 1246 // Some flags which affect the language (via preprocessor 1247 // defines). See darwin::CC1::AddCPPArgs. 1248 if (Args.hasArg(options::OPT_static)) 1249 CmdArgs.push_back("-static-define"); 1250 1251 if (isa<AnalyzeJobAction>(JA)) { 1252 // Enable region store model by default. 1253 CmdArgs.push_back("-analyzer-store=region"); 1254 1255 // Treat blocks as analysis entry points. 1256 CmdArgs.push_back("-analyzer-opt-analyze-nested-blocks"); 1257 1258 CmdArgs.push_back("-analyzer-eagerly-assume"); 1259 1260 // Add default argument set. 1261 if (!Args.hasArg(options::OPT__analyzer_no_default_checks)) { 1262 CmdArgs.push_back("-analyzer-checker=core"); 1263 CmdArgs.push_back("-analyzer-checker=deadcode"); 1264 CmdArgs.push_back("-analyzer-checker=security"); 1265 1266 if (getToolChain().getTriple().getOS() != llvm::Triple::Win32) 1267 CmdArgs.push_back("-analyzer-checker=unix"); 1268 1269 if (getToolChain().getTriple().getVendor() == llvm::Triple::Apple) 1270 CmdArgs.push_back("-analyzer-checker=osx"); 1271 } 1272 1273 // Set the output format. The default is plist, for (lame) historical 1274 // reasons. 1275 CmdArgs.push_back("-analyzer-output"); 1276 if (Arg *A = Args.getLastArg(options::OPT__analyzer_output)) 1277 CmdArgs.push_back(A->getValue(Args)); 1278 else 1279 CmdArgs.push_back("plist"); 1280 1281 // Disable the presentation of standard compiler warnings when 1282 // using --analyze. We only want to show static analyzer diagnostics 1283 // or frontend errors. 1284 CmdArgs.push_back("-w"); 1285 1286 // Add -Xanalyzer arguments when running as analyzer. 1287 Args.AddAllArgValues(CmdArgs, options::OPT_Xanalyzer); 1288 } 1289 1290 CheckCodeGenerationOptions(D, Args); 1291 1292 // Perform argument translation for LLVM backend. This 1293 // takes some care in reconciling with llvm-gcc. The 1294 // issue is that llvm-gcc translates these options based on 1295 // the values in cc1, whereas we are processing based on 1296 // the driver arguments. 1297 1298 // This comes from the default translation the driver + cc1 1299 // would do to enable flag_pic. 1300 // 1301 // FIXME: Centralize this code. 1302 bool PICEnabled = (Args.hasArg(options::OPT_fPIC) || 1303 Args.hasArg(options::OPT_fpic) || 1304 Args.hasArg(options::OPT_fPIE) || 1305 Args.hasArg(options::OPT_fpie)); 1306 bool PICDisabled = (Args.hasArg(options::OPT_mkernel) || 1307 Args.hasArg(options::OPT_static)); 1308 const char *Model = getToolChain().GetForcedPicModel(); 1309 if (!Model) { 1310 if (Args.hasArg(options::OPT_mdynamic_no_pic)) 1311 Model = "dynamic-no-pic"; 1312 else if (PICDisabled) 1313 Model = "static"; 1314 else if (PICEnabled) 1315 Model = "pic"; 1316 else 1317 Model = getToolChain().GetDefaultRelocationModel(); 1318 } 1319 if (StringRef(Model) != "pic") { 1320 CmdArgs.push_back("-mrelocation-model"); 1321 CmdArgs.push_back(Model); 1322 } 1323 1324 // Infer the __PIC__ value. 1325 // 1326 // FIXME: This isn't quite right on Darwin, which always sets 1327 // __PIC__=2. 1328 if (strcmp(Model, "pic") == 0 || strcmp(Model, "dynamic-no-pic") == 0) { 1329 CmdArgs.push_back("-pic-level"); 1330 CmdArgs.push_back(Args.hasArg(options::OPT_fPIC) ? "2" : "1"); 1331 } 1332 if (!Args.hasFlag(options::OPT_fmerge_all_constants, 1333 options::OPT_fno_merge_all_constants)) 1334 CmdArgs.push_back("-fno-merge-all-constants"); 1335 1336 // LLVM Code Generator Options. 1337 1338 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) { 1339 CmdArgs.push_back("-mregparm"); 1340 CmdArgs.push_back(A->getValue(Args)); 1341 } 1342 1343 if (Args.hasFlag(options::OPT_mrtd, options::OPT_mno_rtd, false)) 1344 CmdArgs.push_back("-mrtd"); 1345 1346 // FIXME: Set --enable-unsafe-fp-math. 1347 if (Args.hasFlag(options::OPT_fno_omit_frame_pointer, 1348 options::OPT_fomit_frame_pointer)) 1349 CmdArgs.push_back("-mdisable-fp-elim"); 1350 if (!Args.hasFlag(options::OPT_fzero_initialized_in_bss, 1351 options::OPT_fno_zero_initialized_in_bss)) 1352 CmdArgs.push_back("-mno-zero-initialized-in-bss"); 1353 if (!Args.hasFlag(options::OPT_fstrict_aliasing, 1354 options::OPT_fno_strict_aliasing, 1355 getToolChain().IsStrictAliasingDefault())) 1356 CmdArgs.push_back("-relaxed-aliasing"); 1357 1358 // Decide whether to use verbose asm. Verbose assembly is the default on 1359 // toolchains which have the integrated assembler on by default. 1360 bool IsVerboseAsmDefault = getToolChain().IsIntegratedAssemblerDefault(); 1361 if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm, 1362 IsVerboseAsmDefault) || 1363 Args.hasArg(options::OPT_dA)) 1364 CmdArgs.push_back("-masm-verbose"); 1365 1366 if (Args.hasArg(options::OPT_fdebug_pass_structure)) { 1367 CmdArgs.push_back("-mdebug-pass"); 1368 CmdArgs.push_back("Structure"); 1369 } 1370 if (Args.hasArg(options::OPT_fdebug_pass_arguments)) { 1371 CmdArgs.push_back("-mdebug-pass"); 1372 CmdArgs.push_back("Arguments"); 1373 } 1374 1375 // Enable -mconstructor-aliases except on darwin, where we have to 1376 // work around a linker bug; see <rdar://problem/7651567>. 1377 if (getToolChain().getTriple().getOS() != llvm::Triple::Darwin) 1378 CmdArgs.push_back("-mconstructor-aliases"); 1379 1380 // Darwin's kernel doesn't support guard variables; just die if we 1381 // try to use them. 1382 if (KernelOrKext && 1383 getToolChain().getTriple().getOS() == llvm::Triple::Darwin) 1384 CmdArgs.push_back("-fforbid-guard-variables"); 1385 1386 if (Args.hasArg(options::OPT_mms_bitfields)) { 1387 CmdArgs.push_back("-mms-bitfields"); 1388 } 1389 1390 // This is a coarse approximation of what llvm-gcc actually does, both 1391 // -fasynchronous-unwind-tables and -fnon-call-exceptions interact in more 1392 // complicated ways. 1393 bool AsynchronousUnwindTables = 1394 Args.hasFlag(options::OPT_fasynchronous_unwind_tables, 1395 options::OPT_fno_asynchronous_unwind_tables, 1396 getToolChain().IsUnwindTablesDefault() && 1397 !KernelOrKext); 1398 if (Args.hasFlag(options::OPT_funwind_tables, options::OPT_fno_unwind_tables, 1399 AsynchronousUnwindTables)) 1400 CmdArgs.push_back("-munwind-tables"); 1401 1402 if (Arg *A = Args.getLastArg(options::OPT_flimited_precision_EQ)) { 1403 CmdArgs.push_back("-mlimit-float-precision"); 1404 CmdArgs.push_back(A->getValue(Args)); 1405 } 1406 1407 // FIXME: Handle -mtune=. 1408 (void) Args.hasArg(options::OPT_mtune_EQ); 1409 1410 if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) { 1411 CmdArgs.push_back("-mcode-model"); 1412 CmdArgs.push_back(A->getValue(Args)); 1413 } 1414 1415 // Add target specific cpu and features flags. 1416 switch(getToolChain().getTriple().getArch()) { 1417 default: 1418 break; 1419 1420 case llvm::Triple::arm: 1421 case llvm::Triple::thumb: 1422 AddARMTargetArgs(Args, CmdArgs, KernelOrKext); 1423 break; 1424 1425 case llvm::Triple::mips: 1426 case llvm::Triple::mipsel: 1427 case llvm::Triple::mips64: 1428 case llvm::Triple::mips64el: 1429 AddMIPSTargetArgs(Args, CmdArgs); 1430 break; 1431 1432 case llvm::Triple::sparc: 1433 AddSparcTargetArgs(Args, CmdArgs); 1434 break; 1435 1436 case llvm::Triple::x86: 1437 case llvm::Triple::x86_64: 1438 AddX86TargetArgs(Args, CmdArgs); 1439 break; 1440 } 1441 1442 // Pass the linker version in use. 1443 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) { 1444 CmdArgs.push_back("-target-linker-version"); 1445 CmdArgs.push_back(A->getValue(Args)); 1446 } 1447 1448 // -mno-omit-leaf-frame-pointer is the default on Darwin. 1449 if (Args.hasFlag(options::OPT_momit_leaf_frame_pointer, 1450 options::OPT_mno_omit_leaf_frame_pointer, 1451 getToolChain().getTriple().getOS() != llvm::Triple::Darwin)) 1452 CmdArgs.push_back("-momit-leaf-frame-pointer"); 1453 1454 // -fno-math-errno is default. 1455 if (Args.hasFlag(options::OPT_fmath_errno, 1456 options::OPT_fno_math_errno, 1457 false)) 1458 CmdArgs.push_back("-fmath-errno"); 1459 1460 // Explicitly error on some things we know we don't support and can't just 1461 // ignore. 1462 types::ID InputType = Inputs[0].getType(); 1463 if (!Args.hasArg(options::OPT_fallow_unsupported)) { 1464 Arg *Unsupported; 1465 if ((Unsupported = Args.getLastArg(options::OPT_iframework))) 1466 D.Diag(diag::err_drv_clang_unsupported) 1467 << Unsupported->getOption().getName(); 1468 1469 if (types::isCXX(InputType) && 1470 getToolChain().getTriple().getOS() == llvm::Triple::Darwin && 1471 getToolChain().getTriple().getArch() == llvm::Triple::x86) { 1472 if ((Unsupported = Args.getLastArg(options::OPT_fapple_kext)) || 1473 (Unsupported = Args.getLastArg(options::OPT_mkernel))) 1474 D.Diag(diag::err_drv_clang_unsupported_opt_cxx_darwin_i386) 1475 << Unsupported->getOption().getName(); 1476 } 1477 } 1478 1479 Args.AddAllArgs(CmdArgs, options::OPT_v); 1480 Args.AddLastArg(CmdArgs, options::OPT_H); 1481 if (D.CCPrintHeaders && !D.CCGenDiagnostics) { 1482 CmdArgs.push_back("-header-include-file"); 1483 CmdArgs.push_back(D.CCPrintHeadersFilename ? 1484 D.CCPrintHeadersFilename : "-"); 1485 } 1486 Args.AddLastArg(CmdArgs, options::OPT_P); 1487 Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout); 1488 1489 if (D.CCLogDiagnostics && !D.CCGenDiagnostics) { 1490 CmdArgs.push_back("-diagnostic-log-file"); 1491 CmdArgs.push_back(D.CCLogDiagnosticsFilename ? 1492 D.CCLogDiagnosticsFilename : "-"); 1493 } 1494 1495 // Special case debug options to only pass -g to clang. This is 1496 // wrong. 1497 Args.ClaimAllArgs(options::OPT_g_Group); 1498 if (Arg *A = Args.getLastArg(options::OPT_g_Group)) 1499 if (!A->getOption().matches(options::OPT_g0)) 1500 CmdArgs.push_back("-g"); 1501 1502 Args.AddAllArgs(CmdArgs, options::OPT_ffunction_sections); 1503 Args.AddAllArgs(CmdArgs, options::OPT_fdata_sections); 1504 1505 Args.AddAllArgs(CmdArgs, options::OPT_finstrument_functions); 1506 1507 if (Args.hasArg(options::OPT_ftest_coverage) || 1508 Args.hasArg(options::OPT_coverage)) 1509 CmdArgs.push_back("-femit-coverage-notes"); 1510 if (Args.hasArg(options::OPT_fprofile_arcs) || 1511 Args.hasArg(options::OPT_coverage)) 1512 CmdArgs.push_back("-femit-coverage-data"); 1513 1514 if (C.getArgs().hasArg(options::OPT_c) || 1515 C.getArgs().hasArg(options::OPT_S)) { 1516 if (Output.isFilename()) { 1517 CmdArgs.push_back("-coverage-file"); 1518 CmdArgs.push_back(Args.MakeArgString(Output.getFilename())); 1519 } 1520 } 1521 1522 Args.AddLastArg(CmdArgs, options::OPT_nostdinc); 1523 Args.AddLastArg(CmdArgs, options::OPT_nostdincxx); 1524 Args.AddLastArg(CmdArgs, options::OPT_nobuiltininc); 1525 1526 // Pass the path to compiler resource files. 1527 CmdArgs.push_back("-resource-dir"); 1528 CmdArgs.push_back(D.ResourceDir.c_str()); 1529 1530 Args.AddLastArg(CmdArgs, options::OPT_working_directory); 1531 1532 if (!Args.hasArg(options::OPT_fno_objc_arc)) { 1533 if (const Arg *A = Args.getLastArg(options::OPT_ccc_arcmt_check, 1534 options::OPT_ccc_arcmt_modify, 1535 options::OPT_ccc_arcmt_migrate)) { 1536 switch (A->getOption().getID()) { 1537 default: 1538 llvm_unreachable("missed a case"); 1539 case options::OPT_ccc_arcmt_check: 1540 CmdArgs.push_back("-arcmt-check"); 1541 break; 1542 case options::OPT_ccc_arcmt_modify: 1543 CmdArgs.push_back("-arcmt-modify"); 1544 break; 1545 case options::OPT_ccc_arcmt_migrate: 1546 CmdArgs.push_back("-arcmt-migrate"); 1547 CmdArgs.push_back("-arcmt-migrate-directory"); 1548 CmdArgs.push_back(A->getValue(Args)); 1549 1550 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_report_output); 1551 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_emit_arc_errors); 1552 break; 1553 } 1554 } 1555 } 1556 1557 // Add preprocessing options like -I, -D, etc. if we are using the 1558 // preprocessor. 1559 // 1560 // FIXME: Support -fpreprocessed 1561 if (types::getPreprocessedType(InputType) != types::TY_INVALID) 1562 AddPreprocessingOptions(D, Args, CmdArgs, Output, Inputs); 1563 1564 // Don't warn about "clang -c -DPIC -fPIC test.i" because libtool.m4 assumes 1565 // that "The compiler can only warn and ignore the option if not recognized". 1566 // When building with ccache, it will pass -D options to clang even on 1567 // preprocessed inputs and configure concludes that -fPIC is not supported. 1568 Args.ClaimAllArgs(options::OPT_D); 1569 1570 // Manually translate -O to -O2 and -O4 to -O3; let clang reject 1571 // others. 1572 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) { 1573 if (A->getOption().matches(options::OPT_O4)) 1574 CmdArgs.push_back("-O3"); 1575 else if (A->getOption().matches(options::OPT_O) && 1576 A->getValue(Args)[0] == '\0') 1577 CmdArgs.push_back("-O2"); 1578 else 1579 A->render(Args, CmdArgs); 1580 } 1581 1582 Args.AddAllArgs(CmdArgs, options::OPT_W_Group); 1583 Args.AddLastArg(CmdArgs, options::OPT_pedantic); 1584 Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors); 1585 Args.AddLastArg(CmdArgs, options::OPT_w); 1586 1587 // Handle -{std, ansi, trigraphs} -- take the last of -{std, ansi} 1588 // (-ansi is equivalent to -std=c89). 1589 // 1590 // If a std is supplied, only add -trigraphs if it follows the 1591 // option. 1592 if (Arg *Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) { 1593 if (Std->getOption().matches(options::OPT_ansi)) 1594 if (types::isCXX(InputType)) 1595 CmdArgs.push_back("-std=c++98"); 1596 else 1597 CmdArgs.push_back("-std=c89"); 1598 else 1599 Std->render(Args, CmdArgs); 1600 1601 if (Arg *A = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi, 1602 options::OPT_trigraphs)) 1603 if (A != Std) 1604 A->render(Args, CmdArgs); 1605 } else { 1606 // Honor -std-default. 1607 // 1608 // FIXME: Clang doesn't correctly handle -std= when the input language 1609 // doesn't match. For the time being just ignore this for C++ inputs; 1610 // eventually we want to do all the standard defaulting here instead of 1611 // splitting it between the driver and clang -cc1. 1612 if (!types::isCXX(InputType)) 1613 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ, 1614 "-std=", /*Joined=*/true); 1615 Args.AddLastArg(CmdArgs, options::OPT_trigraphs); 1616 } 1617 1618 // Map the bizarre '-Wwrite-strings' flag to a more sensible 1619 // '-fconst-strings'; this better indicates its actual behavior. 1620 if (Args.hasFlag(options::OPT_Wwrite_strings, options::OPT_Wno_write_strings, 1621 false)) { 1622 // For perfect compatibility with GCC, we do this even in the presence of 1623 // '-w'. This flag names something other than a warning for GCC. 1624 CmdArgs.push_back("-fconst-strings"); 1625 } 1626 1627 // GCC provides a macro definition '__DEPRECATED' when -Wdeprecated is active 1628 // during C++ compilation, which it is by default. GCC keeps this define even 1629 // in the presence of '-w', match this behavior bug-for-bug. 1630 if (types::isCXX(InputType) && 1631 Args.hasFlag(options::OPT_Wdeprecated, options::OPT_Wno_deprecated, 1632 true)) { 1633 CmdArgs.push_back("-fdeprecated-macro"); 1634 } 1635 1636 // Translate GCC's misnamer '-fasm' arguments to '-fgnu-keywords'. 1637 if (Arg *Asm = Args.getLastArg(options::OPT_fasm, options::OPT_fno_asm)) { 1638 if (Asm->getOption().matches(options::OPT_fasm)) 1639 CmdArgs.push_back("-fgnu-keywords"); 1640 else 1641 CmdArgs.push_back("-fno-gnu-keywords"); 1642 } 1643 1644 if (ShouldDisableCFI(Args, getToolChain())) 1645 CmdArgs.push_back("-fno-dwarf2-cfi-asm"); 1646 1647 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_depth_)) { 1648 CmdArgs.push_back("-ftemplate-depth"); 1649 CmdArgs.push_back(A->getValue(Args)); 1650 } 1651 1652 if (Arg *A = Args.getLastArg(options::OPT_Wlarge_by_value_copy_EQ, 1653 options::OPT_Wlarge_by_value_copy_def)) { 1654 CmdArgs.push_back("-Wlarge-by-value-copy"); 1655 if (A->getNumValues()) 1656 CmdArgs.push_back(A->getValue(Args)); 1657 else 1658 CmdArgs.push_back("64"); // default value for -Wlarge-by-value-copy. 1659 } 1660 1661 if (Args.hasArg(options::OPT__relocatable_pch)) 1662 CmdArgs.push_back("-relocatable-pch"); 1663 1664 if (Arg *A = Args.getLastArg(options::OPT_fconstant_string_class_EQ)) { 1665 CmdArgs.push_back("-fconstant-string-class"); 1666 CmdArgs.push_back(A->getValue(Args)); 1667 } 1668 1669 if (Arg *A = Args.getLastArg(options::OPT_ftabstop_EQ)) { 1670 CmdArgs.push_back("-ftabstop"); 1671 CmdArgs.push_back(A->getValue(Args)); 1672 } 1673 1674 CmdArgs.push_back("-ferror-limit"); 1675 if (Arg *A = Args.getLastArg(options::OPT_ferror_limit_EQ)) 1676 CmdArgs.push_back(A->getValue(Args)); 1677 else 1678 CmdArgs.push_back("19"); 1679 1680 if (Arg *A = Args.getLastArg(options::OPT_fmacro_backtrace_limit_EQ)) { 1681 CmdArgs.push_back("-fmacro-backtrace-limit"); 1682 CmdArgs.push_back(A->getValue(Args)); 1683 } 1684 1685 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_backtrace_limit_EQ)) { 1686 CmdArgs.push_back("-ftemplate-backtrace-limit"); 1687 CmdArgs.push_back(A->getValue(Args)); 1688 } 1689 1690 // Pass -fmessage-length=. 1691 CmdArgs.push_back("-fmessage-length"); 1692 if (Arg *A = Args.getLastArg(options::OPT_fmessage_length_EQ)) { 1693 CmdArgs.push_back(A->getValue(Args)); 1694 } else { 1695 // If -fmessage-length=N was not specified, determine whether this is a 1696 // terminal and, if so, implicitly define -fmessage-length appropriately. 1697 unsigned N = llvm::sys::Process::StandardErrColumns(); 1698 CmdArgs.push_back(Args.MakeArgString(Twine(N))); 1699 } 1700 1701 if (const Arg *A = Args.getLastArg(options::OPT_fvisibility_EQ)) { 1702 CmdArgs.push_back("-fvisibility"); 1703 CmdArgs.push_back(A->getValue(Args)); 1704 } 1705 1706 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden); 1707 1708 // -fhosted is default. 1709 if (KernelOrKext || Args.hasFlag(options::OPT_ffreestanding, 1710 options::OPT_fhosted, 1711 false)) 1712 CmdArgs.push_back("-ffreestanding"); 1713 1714 // Forward -f (flag) options which we can pass directly. 1715 Args.AddLastArg(CmdArgs, options::OPT_fcatch_undefined_behavior); 1716 Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls); 1717 Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions); 1718 Args.AddLastArg(CmdArgs, options::OPT_flimit_debug_info); 1719 if (getToolChain().SupportsProfiling()) 1720 Args.AddLastArg(CmdArgs, options::OPT_pg); 1721 1722 // -flax-vector-conversions is default. 1723 if (!Args.hasFlag(options::OPT_flax_vector_conversions, 1724 options::OPT_fno_lax_vector_conversions)) 1725 CmdArgs.push_back("-fno-lax-vector-conversions"); 1726 1727 if (Args.getLastArg(options::OPT_fapple_kext)) 1728 CmdArgs.push_back("-fapple-kext"); 1729 1730 Args.AddLastArg(CmdArgs, options::OPT_fobjc_sender_dependent_dispatch); 1731 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_print_source_range_info); 1732 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_parseable_fixits); 1733 Args.AddLastArg(CmdArgs, options::OPT_ftime_report); 1734 Args.AddLastArg(CmdArgs, options::OPT_ftrapv); 1735 1736 if (Arg *A = Args.getLastArg(options::OPT_ftrapv_handler_EQ)) { 1737 CmdArgs.push_back("-ftrapv-handler"); 1738 CmdArgs.push_back(A->getValue(Args)); 1739 } 1740 1741 // Forward -ftrap_function= options to the backend. 1742 if (Arg *A = Args.getLastArg(options::OPT_ftrap_function_EQ)) { 1743 StringRef FuncName = A->getValue(Args); 1744 CmdArgs.push_back("-backend-option"); 1745 CmdArgs.push_back(Args.MakeArgString("-trap-func=" + FuncName)); 1746 } 1747 1748 // -fno-strict-overflow implies -fwrapv if it isn't disabled, but 1749 // -fstrict-overflow won't turn off an explicitly enabled -fwrapv. 1750 if (Arg *A = Args.getLastArg(options::OPT_fwrapv, 1751 options::OPT_fno_wrapv)) { 1752 if (A->getOption().matches(options::OPT_fwrapv)) 1753 CmdArgs.push_back("-fwrapv"); 1754 } else if (Arg *A = Args.getLastArg(options::OPT_fstrict_overflow, 1755 options::OPT_fno_strict_overflow)) { 1756 if (A->getOption().matches(options::OPT_fno_strict_overflow)) 1757 CmdArgs.push_back("-fwrapv"); 1758 } 1759 Args.AddLastArg(CmdArgs, options::OPT_fwritable_strings); 1760 Args.AddLastArg(CmdArgs, options::OPT_funroll_loops); 1761 1762 Args.AddLastArg(CmdArgs, options::OPT_pthread); 1763 1764 // -stack-protector=0 is default. 1765 unsigned StackProtectorLevel = 0; 1766 if (Arg *A = Args.getLastArg(options::OPT_fno_stack_protector, 1767 options::OPT_fstack_protector_all, 1768 options::OPT_fstack_protector)) { 1769 if (A->getOption().matches(options::OPT_fstack_protector)) 1770 StackProtectorLevel = 1; 1771 else if (A->getOption().matches(options::OPT_fstack_protector_all)) 1772 StackProtectorLevel = 2; 1773 } else { 1774 StackProtectorLevel = 1775 getToolChain().GetDefaultStackProtectorLevel(KernelOrKext); 1776 } 1777 if (StackProtectorLevel) { 1778 CmdArgs.push_back("-stack-protector"); 1779 CmdArgs.push_back(Args.MakeArgString(Twine(StackProtectorLevel))); 1780 } 1781 1782 // Translate -mstackrealign 1783 if (Args.hasArg(options::OPT_mstackrealign)) { 1784 CmdArgs.push_back("-backend-option"); 1785 CmdArgs.push_back("-force-align-stack"); 1786 } 1787 1788 // Forward -f options with positive and negative forms; we translate 1789 // these by hand. 1790 1791 if (Args.hasArg(options::OPT_mkernel)) { 1792 if (!Args.hasArg(options::OPT_fapple_kext) && types::isCXX(InputType)) 1793 CmdArgs.push_back("-fapple-kext"); 1794 if (!Args.hasArg(options::OPT_fbuiltin)) 1795 CmdArgs.push_back("-fno-builtin"); 1796 } 1797 // -fbuiltin is default. 1798 else if (!Args.hasFlag(options::OPT_fbuiltin, options::OPT_fno_builtin)) 1799 CmdArgs.push_back("-fno-builtin"); 1800 1801 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new, 1802 options::OPT_fno_assume_sane_operator_new)) 1803 CmdArgs.push_back("-fno-assume-sane-operator-new"); 1804 1805 // -fblocks=0 is default. 1806 if (Args.hasFlag(options::OPT_fblocks, options::OPT_fno_blocks, 1807 getToolChain().IsBlocksDefault()) || 1808 (Args.hasArg(options::OPT_fgnu_runtime) && 1809 Args.hasArg(options::OPT_fobjc_nonfragile_abi) && 1810 !Args.hasArg(options::OPT_fno_blocks))) { 1811 CmdArgs.push_back("-fblocks"); 1812 1813 if (!Args.hasArg(options::OPT_fgnu_runtime) && 1814 !getToolChain().hasBlocksRuntime()) 1815 CmdArgs.push_back("-fblocks-runtime-optional"); 1816 } 1817 1818 // -faccess-control is default. 1819 if (Args.hasFlag(options::OPT_fno_access_control, 1820 options::OPT_faccess_control, 1821 false)) 1822 CmdArgs.push_back("-fno-access-control"); 1823 1824 // -felide-constructors is the default. 1825 if (Args.hasFlag(options::OPT_fno_elide_constructors, 1826 options::OPT_felide_constructors, 1827 false)) 1828 CmdArgs.push_back("-fno-elide-constructors"); 1829 1830 // -frtti is default. 1831 if (KernelOrKext || 1832 !Args.hasFlag(options::OPT_frtti, options::OPT_fno_rtti)) 1833 CmdArgs.push_back("-fno-rtti"); 1834 1835 // -fshort-enums=0 is default. 1836 // FIXME: Are there targers where -fshort-enums is on by default ? 1837 if (Args.hasFlag(options::OPT_fshort_enums, 1838 options::OPT_fno_short_enums, false)) 1839 CmdArgs.push_back("-fshort-enums"); 1840 1841 // -fsigned-char is default. 1842 if (!Args.hasFlag(options::OPT_fsigned_char, options::OPT_funsigned_char, 1843 isSignedCharDefault(getToolChain().getTriple()))) 1844 CmdArgs.push_back("-fno-signed-char"); 1845 1846 // -fthreadsafe-static is default. 1847 if (!Args.hasFlag(options::OPT_fthreadsafe_statics, 1848 options::OPT_fno_threadsafe_statics)) 1849 CmdArgs.push_back("-fno-threadsafe-statics"); 1850 1851 // -fuse-cxa-atexit is default. 1852 if (KernelOrKext || 1853 !Args.hasFlag(options::OPT_fuse_cxa_atexit, options::OPT_fno_use_cxa_atexit, 1854 getToolChain().getTriple().getOS() != llvm::Triple::Cygwin && 1855 getToolChain().getTriple().getOS() != llvm::Triple::MinGW32)) 1856 CmdArgs.push_back("-fno-use-cxa-atexit"); 1857 1858 // -fms-extensions=0 is default. 1859 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions, 1860 getToolChain().getTriple().getOS() == llvm::Triple::Win32)) 1861 CmdArgs.push_back("-fms-extensions"); 1862 1863 // -fms-compatibility=0 is default. 1864 if (Args.hasFlag(options::OPT_fms_compatibility, options::OPT_fno_ms_compatibility, 1865 getToolChain().getTriple().getOS() == llvm::Triple::Win32)) 1866 CmdArgs.push_back("-fms-compatibility"); 1867 1868 // -fmsc-version=1300 is default. 1869 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions, 1870 getToolChain().getTriple().getOS() == llvm::Triple::Win32) || 1871 Args.hasArg(options::OPT_fmsc_version)) { 1872 StringRef msc_ver = Args.getLastArgValue(options::OPT_fmsc_version); 1873 if (msc_ver.empty()) 1874 CmdArgs.push_back("-fmsc-version=1300"); 1875 else 1876 CmdArgs.push_back(Args.MakeArgString("-fmsc-version=" + msc_ver)); 1877 } 1878 1879 1880 // -fborland-extensions=0 is default. 1881 if (Args.hasFlag(options::OPT_fborland_extensions, 1882 options::OPT_fno_borland_extensions, false)) 1883 CmdArgs.push_back("-fborland-extensions"); 1884 1885 // -fno-delayed-template-parsing is default, except for Windows where MSVC STL 1886 // needs it. 1887 if (Args.hasFlag(options::OPT_fdelayed_template_parsing, 1888 options::OPT_fno_delayed_template_parsing, 1889 getToolChain().getTriple().getOS() == llvm::Triple::Win32)) 1890 CmdArgs.push_back("-fdelayed-template-parsing"); 1891 1892 // -fgnu-keywords default varies depending on language; only pass if 1893 // specified. 1894 if (Arg *A = Args.getLastArg(options::OPT_fgnu_keywords, 1895 options::OPT_fno_gnu_keywords)) 1896 A->render(Args, CmdArgs); 1897 1898 if (Args.hasFlag(options::OPT_fgnu89_inline, 1899 options::OPT_fno_gnu89_inline, 1900 false)) 1901 CmdArgs.push_back("-fgnu89-inline"); 1902 1903 // -fobjc-nonfragile-abi=0 is default. 1904 ObjCRuntime objCRuntime; 1905 unsigned objcABIVersion = 0; 1906 bool NeXTRuntimeIsDefault 1907 = (IsRewriter || getToolChain().getTriple().isOSDarwin()); 1908 if (Args.hasFlag(options::OPT_fnext_runtime, options::OPT_fgnu_runtime, 1909 NeXTRuntimeIsDefault)) { 1910 objCRuntime.setKind(ObjCRuntime::NeXT); 1911 } else { 1912 CmdArgs.push_back("-fgnu-runtime"); 1913 objCRuntime.setKind(ObjCRuntime::GNU); 1914 } 1915 getToolChain().configureObjCRuntime(objCRuntime); 1916 if (objCRuntime.HasARC) 1917 CmdArgs.push_back("-fobjc-runtime-has-arc"); 1918 if (objCRuntime.HasWeak) 1919 CmdArgs.push_back("-fobjc-runtime-has-weak"); 1920 if (objCRuntime.HasTerminate) 1921 CmdArgs.push_back("-fobjc-runtime-has-terminate"); 1922 1923 // Compute the Objective-C ABI "version" to use. Version numbers are 1924 // slightly confusing for historical reasons: 1925 // 1 - Traditional "fragile" ABI 1926 // 2 - Non-fragile ABI, version 1 1927 // 3 - Non-fragile ABI, version 2 1928 objcABIVersion = 1; 1929 // If -fobjc-abi-version= is present, use that to set the version. 1930 if (Arg *A = Args.getLastArg(options::OPT_fobjc_abi_version_EQ)) { 1931 if (StringRef(A->getValue(Args)) == "1") 1932 objcABIVersion = 1; 1933 else if (StringRef(A->getValue(Args)) == "2") 1934 objcABIVersion = 2; 1935 else if (StringRef(A->getValue(Args)) == "3") 1936 objcABIVersion = 3; 1937 else 1938 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args); 1939 } else { 1940 // Otherwise, determine if we are using the non-fragile ABI. 1941 if (Args.hasFlag(options::OPT_fobjc_nonfragile_abi, 1942 options::OPT_fno_objc_nonfragile_abi, 1943 getToolChain().IsObjCNonFragileABIDefault())) { 1944 // Determine the non-fragile ABI version to use. 1945#ifdef DISABLE_DEFAULT_NONFRAGILEABI_TWO 1946 unsigned NonFragileABIVersion = 1; 1947#else 1948 unsigned NonFragileABIVersion = 2; 1949#endif 1950 1951 if (Arg *A = Args.getLastArg( 1952 options::OPT_fobjc_nonfragile_abi_version_EQ)) { 1953 if (StringRef(A->getValue(Args)) == "1") 1954 NonFragileABIVersion = 1; 1955 else if (StringRef(A->getValue(Args)) == "2") 1956 NonFragileABIVersion = 2; 1957 else 1958 D.Diag(diag::err_drv_clang_unsupported) 1959 << A->getAsString(Args); 1960 } 1961 1962 objcABIVersion = 1 + NonFragileABIVersion; 1963 } else { 1964 objcABIVersion = 1; 1965 } 1966 } 1967 1968 if (objcABIVersion == 1) { 1969 CmdArgs.push_back("-fobjc-fragile-abi"); 1970 } else { 1971 // -fobjc-dispatch-method is only relevant with the nonfragile-abi, and 1972 // legacy is the default. 1973 if (!Args.hasFlag(options::OPT_fobjc_legacy_dispatch, 1974 options::OPT_fno_objc_legacy_dispatch, 1975 getToolChain().IsObjCLegacyDispatchDefault())) { 1976 if (getToolChain().UseObjCMixedDispatch()) 1977 CmdArgs.push_back("-fobjc-dispatch-method=mixed"); 1978 else 1979 CmdArgs.push_back("-fobjc-dispatch-method=non-legacy"); 1980 } 1981 } 1982 1983 // -fobjc-default-synthesize-properties=0 is default. 1984 if (Args.hasFlag(options::OPT_fobjc_default_synthesize_properties, 1985 options::OPT_fno_objc_default_synthesize_properties, 1986 getToolChain().IsObjCDefaultSynthPropertiesDefault())) { 1987 CmdArgs.push_back("-fobjc-default-synthesize-properties"); 1988 } 1989 1990 // Allow -fno-objc-arr to trump -fobjc-arr/-fobjc-arc. 1991 // NOTE: This logic is duplicated in ToolChains.cpp. 1992 bool ARC = isObjCAutoRefCount(Args); 1993 if (ARC) { 1994 CmdArgs.push_back("-fobjc-arc"); 1995 1996 // Allow the user to enable full exceptions code emission. 1997 // We define off for Objective-CC, on for Objective-C++. 1998 if (Args.hasFlag(options::OPT_fobjc_arc_exceptions, 1999 options::OPT_fno_objc_arc_exceptions, 2000 /*default*/ types::isCXX(InputType))) 2001 CmdArgs.push_back("-fobjc-arc-exceptions"); 2002 } 2003 2004 // -fobjc-infer-related-result-type is the default, except in the Objective-C 2005 // rewriter. 2006 if (IsRewriter) 2007 CmdArgs.push_back("-fno-objc-infer-related-result-type"); 2008 2009 // Handle -fobjc-gc and -fobjc-gc-only. They are exclusive, and -fobjc-gc-only 2010 // takes precedence. 2011 const Arg *GCArg = Args.getLastArg(options::OPT_fobjc_gc_only); 2012 if (!GCArg) 2013 GCArg = Args.getLastArg(options::OPT_fobjc_gc); 2014 if (GCArg) { 2015 if (ARC) { 2016 D.Diag(diag::err_drv_objc_gc_arr) 2017 << GCArg->getAsString(Args); 2018 } else if (getToolChain().SupportsObjCGC()) { 2019 GCArg->render(Args, CmdArgs); 2020 } else { 2021 // FIXME: We should move this to a hard error. 2022 D.Diag(diag::warn_drv_objc_gc_unsupported) 2023 << GCArg->getAsString(Args); 2024 } 2025 } 2026 2027 // Add exception args. 2028 addExceptionArgs(Args, InputType, getToolChain().getTriple(), 2029 KernelOrKext, IsRewriter, objcABIVersion, CmdArgs); 2030 2031 if (getToolChain().UseSjLjExceptions()) 2032 CmdArgs.push_back("-fsjlj-exceptions"); 2033 2034 // C++ "sane" operator new. 2035 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new, 2036 options::OPT_fno_assume_sane_operator_new)) 2037 CmdArgs.push_back("-fno-assume-sane-operator-new"); 2038 2039 // -fconstant-cfstrings is default, and may be subject to argument translation 2040 // on Darwin. 2041 if (!Args.hasFlag(options::OPT_fconstant_cfstrings, 2042 options::OPT_fno_constant_cfstrings) || 2043 !Args.hasFlag(options::OPT_mconstant_cfstrings, 2044 options::OPT_mno_constant_cfstrings)) 2045 CmdArgs.push_back("-fno-constant-cfstrings"); 2046 2047 // -fshort-wchar default varies depending on platform; only 2048 // pass if specified. 2049 if (Arg *A = Args.getLastArg(options::OPT_fshort_wchar)) 2050 A->render(Args, CmdArgs); 2051 2052 // -fno-pascal-strings is default, only pass non-default. If the tool chain 2053 // happened to translate to -mpascal-strings, we want to back translate here. 2054 // 2055 // FIXME: This is gross; that translation should be pulled from the 2056 // tool chain. 2057 if (Args.hasFlag(options::OPT_fpascal_strings, 2058 options::OPT_fno_pascal_strings, 2059 false) || 2060 Args.hasFlag(options::OPT_mpascal_strings, 2061 options::OPT_mno_pascal_strings, 2062 false)) 2063 CmdArgs.push_back("-fpascal-strings"); 2064 2065 if (Args.hasArg(options::OPT_mkernel) || 2066 Args.hasArg(options::OPT_fapple_kext)) { 2067 if (!Args.hasArg(options::OPT_fcommon)) 2068 CmdArgs.push_back("-fno-common"); 2069 } 2070 // -fcommon is default, only pass non-default. 2071 else if (!Args.hasFlag(options::OPT_fcommon, options::OPT_fno_common)) 2072 CmdArgs.push_back("-fno-common"); 2073 2074 // -fsigned-bitfields is default, and clang doesn't yet support 2075 // -funsigned-bitfields. 2076 if (!Args.hasFlag(options::OPT_fsigned_bitfields, 2077 options::OPT_funsigned_bitfields)) 2078 D.Diag(diag::warn_drv_clang_unsupported) 2079 << Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args); 2080 2081 // -fsigned-bitfields is default, and clang doesn't support -fno-for-scope. 2082 if (!Args.hasFlag(options::OPT_ffor_scope, 2083 options::OPT_fno_for_scope)) 2084 D.Diag(diag::err_drv_clang_unsupported) 2085 << Args.getLastArg(options::OPT_fno_for_scope)->getAsString(Args); 2086 2087 // -fcaret-diagnostics is default. 2088 if (!Args.hasFlag(options::OPT_fcaret_diagnostics, 2089 options::OPT_fno_caret_diagnostics, true)) 2090 CmdArgs.push_back("-fno-caret-diagnostics"); 2091 2092 // -fdiagnostics-fixit-info is default, only pass non-default. 2093 if (!Args.hasFlag(options::OPT_fdiagnostics_fixit_info, 2094 options::OPT_fno_diagnostics_fixit_info)) 2095 CmdArgs.push_back("-fno-diagnostics-fixit-info"); 2096 2097 // Enable -fdiagnostics-show-name by default. 2098 if (Args.hasFlag(options::OPT_fdiagnostics_show_name, 2099 options::OPT_fno_diagnostics_show_name, false)) 2100 CmdArgs.push_back("-fdiagnostics-show-name"); 2101 2102 // Enable -fdiagnostics-show-option by default. 2103 if (Args.hasFlag(options::OPT_fdiagnostics_show_option, 2104 options::OPT_fno_diagnostics_show_option)) 2105 CmdArgs.push_back("-fdiagnostics-show-option"); 2106 2107 if (const Arg *A = 2108 Args.getLastArg(options::OPT_fdiagnostics_show_category_EQ)) { 2109 CmdArgs.push_back("-fdiagnostics-show-category"); 2110 CmdArgs.push_back(A->getValue(Args)); 2111 } 2112 2113 if (const Arg *A = 2114 Args.getLastArg(options::OPT_fdiagnostics_format_EQ)) { 2115 CmdArgs.push_back("-fdiagnostics-format"); 2116 CmdArgs.push_back(A->getValue(Args)); 2117 } 2118 2119 if (Arg *A = Args.getLastArg( 2120 options::OPT_fdiagnostics_show_note_include_stack, 2121 options::OPT_fno_diagnostics_show_note_include_stack)) { 2122 if (A->getOption().matches( 2123 options::OPT_fdiagnostics_show_note_include_stack)) 2124 CmdArgs.push_back("-fdiagnostics-show-note-include-stack"); 2125 else 2126 CmdArgs.push_back("-fno-diagnostics-show-note-include-stack"); 2127 } 2128 2129 // Color diagnostics are the default, unless the terminal doesn't support 2130 // them. 2131 if (Args.hasFlag(options::OPT_fcolor_diagnostics, 2132 options::OPT_fno_color_diagnostics, 2133 llvm::sys::Process::StandardErrHasColors())) 2134 CmdArgs.push_back("-fcolor-diagnostics"); 2135 2136 if (!Args.hasFlag(options::OPT_fshow_source_location, 2137 options::OPT_fno_show_source_location)) 2138 CmdArgs.push_back("-fno-show-source-location"); 2139 2140 if (!Args.hasFlag(options::OPT_fshow_column, 2141 options::OPT_fno_show_column, 2142 true)) 2143 CmdArgs.push_back("-fno-show-column"); 2144 2145 if (!Args.hasFlag(options::OPT_fspell_checking, 2146 options::OPT_fno_spell_checking)) 2147 CmdArgs.push_back("-fno-spell-checking"); 2148 2149 2150 // Silently ignore -fasm-blocks for now. 2151 (void) Args.hasFlag(options::OPT_fasm_blocks, options::OPT_fno_asm_blocks, 2152 false); 2153 2154 if (Arg *A = Args.getLastArg(options::OPT_fshow_overloads_EQ)) 2155 A->render(Args, CmdArgs); 2156 2157 // -fdollars-in-identifiers default varies depending on platform and 2158 // language; only pass if specified. 2159 if (Arg *A = Args.getLastArg(options::OPT_fdollars_in_identifiers, 2160 options::OPT_fno_dollars_in_identifiers)) { 2161 if (A->getOption().matches(options::OPT_fdollars_in_identifiers)) 2162 CmdArgs.push_back("-fdollars-in-identifiers"); 2163 else 2164 CmdArgs.push_back("-fno-dollars-in-identifiers"); 2165 } 2166 2167 // -funit-at-a-time is default, and we don't support -fno-unit-at-a-time for 2168 // practical purposes. 2169 if (Arg *A = Args.getLastArg(options::OPT_funit_at_a_time, 2170 options::OPT_fno_unit_at_a_time)) { 2171 if (A->getOption().matches(options::OPT_fno_unit_at_a_time)) 2172 D.Diag(diag::warn_drv_clang_unsupported) << A->getAsString(Args); 2173 } 2174 2175 // Default to -fno-builtin-str{cat,cpy} on Darwin for ARM. 2176 // 2177 // FIXME: This is disabled until clang -cc1 supports -fno-builtin-foo. PR4941. 2178#if 0 2179 if (getToolChain().getTriple().getOS() == llvm::Triple::Darwin && 2180 (getToolChain().getTriple().getArch() == llvm::Triple::arm || 2181 getToolChain().getTriple().getArch() == llvm::Triple::thumb)) { 2182 if (!Args.hasArg(options::OPT_fbuiltin_strcat)) 2183 CmdArgs.push_back("-fno-builtin-strcat"); 2184 if (!Args.hasArg(options::OPT_fbuiltin_strcpy)) 2185 CmdArgs.push_back("-fno-builtin-strcpy"); 2186 } 2187#endif 2188 2189 // Only allow -traditional or -traditional-cpp outside in preprocessing modes. 2190 if (Arg *A = Args.getLastArg(options::OPT_traditional, 2191 options::OPT_traditional_cpp)) { 2192 if (isa<PreprocessJobAction>(JA)) 2193 CmdArgs.push_back("-traditional-cpp"); 2194 else 2195 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args); 2196 } 2197 2198 Args.AddLastArg(CmdArgs, options::OPT_dM); 2199 Args.AddLastArg(CmdArgs, options::OPT_dD); 2200 2201 // Forward -Xclang arguments to -cc1, and -mllvm arguments to the LLVM option 2202 // parser. 2203 Args.AddAllArgValues(CmdArgs, options::OPT_Xclang); 2204 for (arg_iterator it = Args.filtered_begin(options::OPT_mllvm), 2205 ie = Args.filtered_end(); it != ie; ++it) { 2206 (*it)->claim(); 2207 2208 // We translate this by hand to the -cc1 argument, since nightly test uses 2209 // it and developers have been trained to spell it with -mllvm. 2210 if (StringRef((*it)->getValue(Args, 0)) == "-disable-llvm-optzns") 2211 CmdArgs.push_back("-disable-llvm-optzns"); 2212 else 2213 (*it)->render(Args, CmdArgs); 2214 } 2215 2216 if (Output.getType() == types::TY_Dependencies) { 2217 // Handled with other dependency code. 2218 } else if (Output.isFilename()) { 2219 CmdArgs.push_back("-o"); 2220 CmdArgs.push_back(Output.getFilename()); 2221 } else { 2222 assert(Output.isNothing() && "Invalid output."); 2223 } 2224 2225 for (InputInfoList::const_iterator 2226 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 2227 const InputInfo &II = *it; 2228 CmdArgs.push_back("-x"); 2229 CmdArgs.push_back(types::getTypeName(II.getType())); 2230 if (II.isFilename()) 2231 CmdArgs.push_back(II.getFilename()); 2232 else 2233 II.getInputArg().renderAsInput(Args, CmdArgs); 2234 } 2235 2236 Args.AddAllArgs(CmdArgs, options::OPT_undef); 2237 2238 const char *Exec = getToolChain().getDriver().getClangProgramPath(); 2239 2240 // Optionally embed the -cc1 level arguments into the debug info, for build 2241 // analysis. 2242 if (getToolChain().UseDwarfDebugFlags()) { 2243 ArgStringList OriginalArgs; 2244 for (ArgList::const_iterator it = Args.begin(), 2245 ie = Args.end(); it != ie; ++it) 2246 (*it)->render(Args, OriginalArgs); 2247 2248 llvm::SmallString<256> Flags; 2249 Flags += Exec; 2250 for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) { 2251 Flags += " "; 2252 Flags += OriginalArgs[i]; 2253 } 2254 CmdArgs.push_back("-dwarf-debug-flags"); 2255 CmdArgs.push_back(Args.MakeArgString(Flags.str())); 2256 } 2257 2258 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 2259 2260 if (Arg *A = Args.getLastArg(options::OPT_pg)) 2261 if (Args.hasArg(options::OPT_fomit_frame_pointer)) 2262 D.Diag(diag::err_drv_argument_not_allowed_with) 2263 << "-fomit-frame-pointer" << A->getAsString(Args); 2264 2265 // Claim some arguments which clang supports automatically. 2266 2267 // -fpch-preprocess is used with gcc to add a special marker in the output to 2268 // include the PCH file. Clang's PTH solution is completely transparent, so we 2269 // do not need to deal with it at all. 2270 Args.ClaimAllArgs(options::OPT_fpch_preprocess); 2271 2272 // Claim some arguments which clang doesn't support, but we don't 2273 // care to warn the user about. 2274 Args.ClaimAllArgs(options::OPT_clang_ignored_f_Group); 2275 Args.ClaimAllArgs(options::OPT_clang_ignored_m_Group); 2276 2277 // Disable warnings for clang -E -use-gold-plugin -emit-llvm foo.c 2278 Args.ClaimAllArgs(options::OPT_use_gold_plugin); 2279 Args.ClaimAllArgs(options::OPT_emit_llvm); 2280} 2281 2282void ClangAs::ConstructJob(Compilation &C, const JobAction &JA, 2283 const InputInfo &Output, 2284 const InputInfoList &Inputs, 2285 const ArgList &Args, 2286 const char *LinkingOutput) const { 2287 ArgStringList CmdArgs; 2288 2289 assert(Inputs.size() == 1 && "Unexpected number of inputs."); 2290 const InputInfo &Input = Inputs[0]; 2291 2292 // Don't warn about "clang -w -c foo.s" 2293 Args.ClaimAllArgs(options::OPT_w); 2294 // and "clang -emit-llvm -c foo.s" 2295 Args.ClaimAllArgs(options::OPT_emit_llvm); 2296 // and "clang -use-gold-plugin -c foo.s" 2297 Args.ClaimAllArgs(options::OPT_use_gold_plugin); 2298 2299 // Invoke ourselves in -cc1as mode. 2300 // 2301 // FIXME: Implement custom jobs for internal actions. 2302 CmdArgs.push_back("-cc1as"); 2303 2304 // Add the "effective" target triple. 2305 CmdArgs.push_back("-triple"); 2306 std::string TripleStr = 2307 getToolChain().ComputeEffectiveClangTriple(Args, Input.getType()); 2308 CmdArgs.push_back(Args.MakeArgString(TripleStr)); 2309 2310 // Set the output mode, we currently only expect to be used as a real 2311 // assembler. 2312 CmdArgs.push_back("-filetype"); 2313 CmdArgs.push_back("obj"); 2314 2315 if (UseRelaxAll(C, Args)) 2316 CmdArgs.push_back("-relax-all"); 2317 2318 // Ignore explicit -force_cpusubtype_ALL option. 2319 (void) Args.hasArg(options::OPT_force__cpusubtype__ALL); 2320 2321 // FIXME: Add -g support, once we have it. 2322 2323 // FIXME: Add -static support, once we have it. 2324 2325 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, 2326 options::OPT_Xassembler); 2327 Args.AddAllArgs(CmdArgs, options::OPT_mllvm); 2328 2329 assert(Output.isFilename() && "Unexpected lipo output."); 2330 CmdArgs.push_back("-o"); 2331 CmdArgs.push_back(Output.getFilename()); 2332 2333 assert(Input.isFilename() && "Invalid input."); 2334 CmdArgs.push_back(Input.getFilename()); 2335 2336 const char *Exec = getToolChain().getDriver().getClangProgramPath(); 2337 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 2338} 2339 2340void gcc::Common::ConstructJob(Compilation &C, const JobAction &JA, 2341 const InputInfo &Output, 2342 const InputInfoList &Inputs, 2343 const ArgList &Args, 2344 const char *LinkingOutput) const { 2345 const Driver &D = getToolChain().getDriver(); 2346 ArgStringList CmdArgs; 2347 2348 for (ArgList::const_iterator 2349 it = Args.begin(), ie = Args.end(); it != ie; ++it) { 2350 Arg *A = *it; 2351 if (A->getOption().hasForwardToGCC()) { 2352 // Don't forward any -g arguments to assembly steps. 2353 if (isa<AssembleJobAction>(JA) && 2354 A->getOption().matches(options::OPT_g_Group)) 2355 continue; 2356 2357 // It is unfortunate that we have to claim here, as this means 2358 // we will basically never report anything interesting for 2359 // platforms using a generic gcc, even if we are just using gcc 2360 // to get to the assembler. 2361 A->claim(); 2362 A->render(Args, CmdArgs); 2363 } 2364 } 2365 2366 RenderExtraToolArgs(JA, CmdArgs); 2367 2368 // If using a driver driver, force the arch. 2369 const std::string &Arch = getToolChain().getArchName(); 2370 if (getToolChain().getTriple().getOS() == llvm::Triple::Darwin) { 2371 CmdArgs.push_back("-arch"); 2372 2373 // FIXME: Remove these special cases. 2374 if (Arch == "powerpc") 2375 CmdArgs.push_back("ppc"); 2376 else if (Arch == "powerpc64") 2377 CmdArgs.push_back("ppc64"); 2378 else 2379 CmdArgs.push_back(Args.MakeArgString(Arch)); 2380 } 2381 2382 // Try to force gcc to match the tool chain we want, if we recognize 2383 // the arch. 2384 // 2385 // FIXME: The triple class should directly provide the information we want 2386 // here. 2387 if (Arch == "i386" || Arch == "powerpc") 2388 CmdArgs.push_back("-m32"); 2389 else if (Arch == "x86_64" || Arch == "powerpc64") 2390 CmdArgs.push_back("-m64"); 2391 2392 if (Output.isFilename()) { 2393 CmdArgs.push_back("-o"); 2394 CmdArgs.push_back(Output.getFilename()); 2395 } else { 2396 assert(Output.isNothing() && "Unexpected output"); 2397 CmdArgs.push_back("-fsyntax-only"); 2398 } 2399 2400 2401 // Only pass -x if gcc will understand it; otherwise hope gcc 2402 // understands the suffix correctly. The main use case this would go 2403 // wrong in is for linker inputs if they happened to have an odd 2404 // suffix; really the only way to get this to happen is a command 2405 // like '-x foobar a.c' which will treat a.c like a linker input. 2406 // 2407 // FIXME: For the linker case specifically, can we safely convert 2408 // inputs into '-Wl,' options? 2409 for (InputInfoList::const_iterator 2410 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 2411 const InputInfo &II = *it; 2412 2413 // Don't try to pass LLVM or AST inputs to a generic gcc. 2414 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR || 2415 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC) 2416 D.Diag(diag::err_drv_no_linker_llvm_support) 2417 << getToolChain().getTripleString(); 2418 else if (II.getType() == types::TY_AST) 2419 D.Diag(diag::err_drv_no_ast_support) 2420 << getToolChain().getTripleString(); 2421 2422 if (types::canTypeBeUserSpecified(II.getType())) { 2423 CmdArgs.push_back("-x"); 2424 CmdArgs.push_back(types::getTypeName(II.getType())); 2425 } 2426 2427 if (II.isFilename()) 2428 CmdArgs.push_back(II.getFilename()); 2429 else { 2430 const Arg &A = II.getInputArg(); 2431 2432 // Reverse translate some rewritten options. 2433 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) { 2434 CmdArgs.push_back("-lstdc++"); 2435 continue; 2436 } 2437 2438 // Don't render as input, we need gcc to do the translations. 2439 A.render(Args, CmdArgs); 2440 } 2441 } 2442 2443 const std::string customGCCName = D.getCCCGenericGCCName(); 2444 const char *GCCName; 2445 if (!customGCCName.empty()) 2446 GCCName = customGCCName.c_str(); 2447 else if (D.CCCIsCXX) { 2448#ifdef IS_CYGWIN15 2449 // FIXME: Detect the version of Cygwin at runtime? 2450 GCCName = "g++-4"; 2451#else 2452 GCCName = "g++"; 2453#endif 2454 } else 2455 GCCName = "gcc"; 2456 2457 const char *Exec = 2458 Args.MakeArgString(getToolChain().GetProgramPath(GCCName)); 2459 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 2460} 2461 2462void gcc::Preprocess::RenderExtraToolArgs(const JobAction &JA, 2463 ArgStringList &CmdArgs) const { 2464 CmdArgs.push_back("-E"); 2465} 2466 2467void gcc::Precompile::RenderExtraToolArgs(const JobAction &JA, 2468 ArgStringList &CmdArgs) const { 2469 // The type is good enough. 2470} 2471 2472void gcc::Compile::RenderExtraToolArgs(const JobAction &JA, 2473 ArgStringList &CmdArgs) const { 2474 const Driver &D = getToolChain().getDriver(); 2475 2476 // If -flto, etc. are present then make sure not to force assembly output. 2477 if (JA.getType() == types::TY_LLVM_IR || JA.getType() == types::TY_LTO_IR || 2478 JA.getType() == types::TY_LLVM_BC || JA.getType() == types::TY_LTO_BC) 2479 CmdArgs.push_back("-c"); 2480 else { 2481 if (JA.getType() != types::TY_PP_Asm) 2482 D.Diag(diag::err_drv_invalid_gcc_output_type) 2483 << getTypeName(JA.getType()); 2484 2485 CmdArgs.push_back("-S"); 2486 } 2487} 2488 2489void gcc::Assemble::RenderExtraToolArgs(const JobAction &JA, 2490 ArgStringList &CmdArgs) const { 2491 CmdArgs.push_back("-c"); 2492} 2493 2494void gcc::Link::RenderExtraToolArgs(const JobAction &JA, 2495 ArgStringList &CmdArgs) const { 2496 // The types are (hopefully) good enough. 2497} 2498 2499const char *darwin::CC1::getCC1Name(types::ID Type) const { 2500 switch (Type) { 2501 default: 2502 llvm_unreachable("Unexpected type for Darwin CC1 tool."); 2503 case types::TY_Asm: 2504 case types::TY_C: case types::TY_CHeader: 2505 case types::TY_PP_C: case types::TY_PP_CHeader: 2506 return "cc1"; 2507 case types::TY_ObjC: case types::TY_ObjCHeader: 2508 case types::TY_PP_ObjC: case types::TY_PP_ObjC_Alias: 2509 case types::TY_PP_ObjCHeader: 2510 return "cc1obj"; 2511 case types::TY_CXX: case types::TY_CXXHeader: 2512 case types::TY_PP_CXX: case types::TY_PP_CXXHeader: 2513 return "cc1plus"; 2514 case types::TY_ObjCXX: case types::TY_ObjCXXHeader: 2515 case types::TY_PP_ObjCXX: case types::TY_PP_ObjCXX_Alias: 2516 case types::TY_PP_ObjCXXHeader: 2517 return "cc1objplus"; 2518 } 2519} 2520 2521const char *darwin::CC1::getBaseInputName(const ArgList &Args, 2522 const InputInfoList &Inputs) { 2523 return Args.MakeArgString( 2524 llvm::sys::path::filename(Inputs[0].getBaseInput())); 2525} 2526 2527const char *darwin::CC1::getBaseInputStem(const ArgList &Args, 2528 const InputInfoList &Inputs) { 2529 const char *Str = getBaseInputName(Args, Inputs); 2530 2531 if (const char *End = strrchr(Str, '.')) 2532 return Args.MakeArgString(std::string(Str, End)); 2533 2534 return Str; 2535} 2536 2537const char * 2538darwin::CC1::getDependencyFileName(const ArgList &Args, 2539 const InputInfoList &Inputs) { 2540 // FIXME: Think about this more. 2541 std::string Res; 2542 2543 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) { 2544 std::string Str(OutputOpt->getValue(Args)); 2545 Res = Str.substr(0, Str.rfind('.')); 2546 } else { 2547 Res = darwin::CC1::getBaseInputStem(Args, Inputs); 2548 } 2549 return Args.MakeArgString(Res + ".d"); 2550} 2551 2552void darwin::CC1::RemoveCC1UnsupportedArgs(ArgStringList &CmdArgs) const { 2553 for (ArgStringList::iterator it = CmdArgs.begin(), ie = CmdArgs.end(); 2554 it != ie;) { 2555 2556 StringRef Option = *it; 2557 bool RemoveOption = false; 2558 2559 // Remove -faltivec 2560 if (Option.equals("-faltivec")) { 2561 it = CmdArgs.erase(it); 2562 ie = CmdArgs.end(); 2563 continue; 2564 } 2565 2566 // Handle machine specific options. 2567 if (Option.startswith("-m")) { 2568 RemoveOption = llvm::StringSwitch<bool>(Option) 2569 .Case("-mthumb", true) 2570 .Case("-mno-thumb", true) 2571 .Case("-mno-fused-madd", true) 2572 .Case("-mlong-branch", true) 2573 .Case("-mlongcall", true) 2574 .Case("-mcpu=G4", true) 2575 .Case("-mcpu=G5", true) 2576 .Default(false); 2577 } 2578 2579 // Handle warning options. 2580 if (Option.startswith("-W")) { 2581 // Remove -W/-Wno- to reduce the number of cases. 2582 if (Option.startswith("-Wno-")) 2583 Option = Option.substr(5); 2584 else 2585 Option = Option.substr(2); 2586 2587 RemoveOption = llvm::StringSwitch<bool>(Option) 2588 .Case("address-of-temporary", true) 2589 .Case("ambiguous-member-template", true) 2590 .Case("analyzer-incompatible-plugin", true) 2591 .Case("array-bounds", true) 2592 .Case("array-bounds-pointer-arithmetic", true) 2593 .Case("bind-to-temporary-copy", true) 2594 .Case("bitwise-op-parentheses", true) 2595 .Case("bool-conversions", true) 2596 .Case("builtin-macro-redefined", true) 2597 .Case("c++-hex-floats", true) 2598 .Case("c++0x-compat", true) 2599 .Case("c++0x-extensions", true) 2600 .Case("c++0x-narrowing", true) 2601 .Case("c++0x-static-nonintegral-init", true) 2602 .Case("conditional-uninitialized", true) 2603 .Case("constant-conversion", true) 2604 .Case("CFString-literal", true) 2605 .Case("constant-logical-operand", true) 2606 .Case("custom-atomic-properties", true) 2607 .Case("default-arg-special-member", true) 2608 .Case("delegating-ctor-cycles", true) 2609 .Case("delete-non-virtual-dtor", true) 2610 .Case("deprecated-implementations", true) 2611 .Case("deprecated-writable-strings", true) 2612 .Case("distributed-object-modifiers", true) 2613 .Case("duplicate-method-arg", true) 2614 .Case("dynamic-class-memaccess", true) 2615 .Case("enum-compare", true) 2616 .Case("exit-time-destructors", true) 2617 .Case("gnu", true) 2618 .Case("gnu-designator", true) 2619 .Case("header-hygiene", true) 2620 .Case("idiomatic-parentheses", true) 2621 .Case("ignored-qualifiers", true) 2622 .Case("implicit-atomic-properties", true) 2623 .Case("incompatible-pointer-types", true) 2624 .Case("incomplete-implementation", true) 2625 .Case("initializer-overrides", true) 2626 .Case("invalid-noreturn", true) 2627 .Case("invalid-token-paste", true) 2628 .Case("literal-conversion", true) 2629 .Case("literal-range", true) 2630 .Case("local-type-template-args", true) 2631 .Case("logical-op-parentheses", true) 2632 .Case("method-signatures", true) 2633 .Case("microsoft", true) 2634 .Case("mismatched-tags", true) 2635 .Case("missing-method-return-type", true) 2636 .Case("non-pod-varargs", true) 2637 .Case("nonfragile-abi2", true) 2638 .Case("null-arithmetic", true) 2639 .Case("null-dereference", true) 2640 .Case("out-of-line-declaration", true) 2641 .Case("overriding-method-mismatch", true) 2642 .Case("readonly-setter-attrs", true) 2643 .Case("return-stack-address", true) 2644 .Case("self-assign", true) 2645 .Case("semicolon-before-method-body", true) 2646 .Case("sentinel", true) 2647 .Case("shift-overflow", true) 2648 .Case("shift-sign-overflow", true) 2649 .Case("sign-conversion", true) 2650 .Case("sizeof-array-argument", true) 2651 .Case("sizeof-pointer-memaccess", true) 2652 .Case("string-compare", true) 2653 .Case("super-class-method-mismatch", true) 2654 .Case("tautological-compare", true) 2655 .Case("typedef-redefinition", true) 2656 .Case("typename-missing", true) 2657 .Case("undefined-reinterpret-cast", true) 2658 .Case("unknown-warning-option", true) 2659 .Case("unnamed-type-template-args", true) 2660 .Case("unneeded-internal-declaration", true) 2661 .Case("unneeded-member-function", true) 2662 .Case("unused-comparison", true) 2663 .Case("unused-exception-parameter", true) 2664 .Case("unused-member-function", true) 2665 .Case("unused-result", true) 2666 .Case("vector-conversions", true) 2667 .Case("vla", true) 2668 .Case("used-but-marked-unused", true) 2669 .Case("weak-vtables", true) 2670 .Default(false); 2671 } // if (Option.startswith("-W")) 2672 if (RemoveOption) { 2673 it = CmdArgs.erase(it); 2674 ie = CmdArgs.end(); 2675 } else { 2676 ++it; 2677 } 2678 } 2679} 2680 2681void darwin::CC1::AddCC1Args(const ArgList &Args, 2682 ArgStringList &CmdArgs) const { 2683 const Driver &D = getToolChain().getDriver(); 2684 2685 CheckCodeGenerationOptions(D, Args); 2686 2687 // Derived from cc1 spec. 2688 if (!Args.hasArg(options::OPT_mkernel) && !Args.hasArg(options::OPT_static) && 2689 !Args.hasArg(options::OPT_mdynamic_no_pic)) 2690 CmdArgs.push_back("-fPIC"); 2691 2692 if (getToolChain().getTriple().getArch() == llvm::Triple::arm || 2693 getToolChain().getTriple().getArch() == llvm::Triple::thumb) { 2694 if (!Args.hasArg(options::OPT_fbuiltin_strcat)) 2695 CmdArgs.push_back("-fno-builtin-strcat"); 2696 if (!Args.hasArg(options::OPT_fbuiltin_strcpy)) 2697 CmdArgs.push_back("-fno-builtin-strcpy"); 2698 } 2699 2700 if (Args.hasArg(options::OPT_g_Flag) && 2701 !Args.hasArg(options::OPT_fno_eliminate_unused_debug_symbols)) 2702 CmdArgs.push_back("-feliminate-unused-debug-symbols"); 2703} 2704 2705void darwin::CC1::AddCC1OptionsArgs(const ArgList &Args, ArgStringList &CmdArgs, 2706 const InputInfoList &Inputs, 2707 const ArgStringList &OutputArgs) const { 2708 const Driver &D = getToolChain().getDriver(); 2709 2710 // Derived from cc1_options spec. 2711 if (Args.hasArg(options::OPT_fast) || 2712 Args.hasArg(options::OPT_fastf) || 2713 Args.hasArg(options::OPT_fastcp)) 2714 CmdArgs.push_back("-O3"); 2715 2716 if (Arg *A = Args.getLastArg(options::OPT_pg)) 2717 if (Args.hasArg(options::OPT_fomit_frame_pointer)) 2718 D.Diag(diag::err_drv_argument_not_allowed_with) 2719 << A->getAsString(Args) << "-fomit-frame-pointer"; 2720 2721 AddCC1Args(Args, CmdArgs); 2722 2723 if (!Args.hasArg(options::OPT_Q)) 2724 CmdArgs.push_back("-quiet"); 2725 2726 CmdArgs.push_back("-dumpbase"); 2727 CmdArgs.push_back(darwin::CC1::getBaseInputName(Args, Inputs)); 2728 2729 Args.AddAllArgs(CmdArgs, options::OPT_d_Group); 2730 2731 Args.AddAllArgs(CmdArgs, options::OPT_m_Group); 2732 Args.AddAllArgs(CmdArgs, options::OPT_a_Group); 2733 2734 // FIXME: The goal is to use the user provided -o if that is our 2735 // final output, otherwise to drive from the original input 2736 // name. Find a clean way to go about this. 2737 if ((Args.hasArg(options::OPT_c) || Args.hasArg(options::OPT_S)) && 2738 Args.hasArg(options::OPT_o)) { 2739 Arg *OutputOpt = Args.getLastArg(options::OPT_o); 2740 CmdArgs.push_back("-auxbase-strip"); 2741 CmdArgs.push_back(OutputOpt->getValue(Args)); 2742 } else { 2743 CmdArgs.push_back("-auxbase"); 2744 CmdArgs.push_back(darwin::CC1::getBaseInputStem(Args, Inputs)); 2745 } 2746 2747 Args.AddAllArgs(CmdArgs, options::OPT_g_Group); 2748 2749 Args.AddAllArgs(CmdArgs, options::OPT_O); 2750 // FIXME: -Wall is getting some special treatment. Investigate. 2751 Args.AddAllArgs(CmdArgs, options::OPT_W_Group, options::OPT_pedantic_Group); 2752 Args.AddLastArg(CmdArgs, options::OPT_w); 2753 Args.AddAllArgs(CmdArgs, options::OPT_std_EQ, options::OPT_ansi, 2754 options::OPT_trigraphs); 2755 if (!Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) { 2756 // Honor -std-default. 2757 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ, 2758 "-std=", /*Joined=*/true); 2759 } 2760 2761 if (Args.hasArg(options::OPT_v)) 2762 CmdArgs.push_back("-version"); 2763 if (Args.hasArg(options::OPT_pg) && 2764 getToolChain().SupportsProfiling()) 2765 CmdArgs.push_back("-p"); 2766 Args.AddLastArg(CmdArgs, options::OPT_p); 2767 2768 // The driver treats -fsyntax-only specially. 2769 if (getToolChain().getTriple().getArch() == llvm::Triple::arm || 2770 getToolChain().getTriple().getArch() == llvm::Triple::thumb) { 2771 // Removes -fbuiltin-str{cat,cpy}; these aren't recognized by cc1 but are 2772 // used to inhibit the default -fno-builtin-str{cat,cpy}. 2773 // 2774 // FIXME: Should we grow a better way to deal with "removing" args? 2775 for (arg_iterator it = Args.filtered_begin(options::OPT_f_Group, 2776 options::OPT_fsyntax_only), 2777 ie = Args.filtered_end(); it != ie; ++it) { 2778 if (!(*it)->getOption().matches(options::OPT_fbuiltin_strcat) && 2779 !(*it)->getOption().matches(options::OPT_fbuiltin_strcpy)) { 2780 (*it)->claim(); 2781 (*it)->render(Args, CmdArgs); 2782 } 2783 } 2784 } else 2785 Args.AddAllArgs(CmdArgs, options::OPT_f_Group, options::OPT_fsyntax_only); 2786 2787 // Claim Clang only -f options, they aren't worth warning about. 2788 Args.ClaimAllArgs(options::OPT_f_clang_Group); 2789 2790 Args.AddAllArgs(CmdArgs, options::OPT_undef); 2791 if (Args.hasArg(options::OPT_Qn)) 2792 CmdArgs.push_back("-fno-ident"); 2793 2794 // FIXME: This isn't correct. 2795 //Args.AddLastArg(CmdArgs, options::OPT__help) 2796 //Args.AddLastArg(CmdArgs, options::OPT__targetHelp) 2797 2798 CmdArgs.append(OutputArgs.begin(), OutputArgs.end()); 2799 2800 // FIXME: Still don't get what is happening here. Investigate. 2801 Args.AddAllArgs(CmdArgs, options::OPT__param); 2802 2803 if (Args.hasArg(options::OPT_fmudflap) || 2804 Args.hasArg(options::OPT_fmudflapth)) { 2805 CmdArgs.push_back("-fno-builtin"); 2806 CmdArgs.push_back("-fno-merge-constants"); 2807 } 2808 2809 if (Args.hasArg(options::OPT_coverage)) { 2810 CmdArgs.push_back("-fprofile-arcs"); 2811 CmdArgs.push_back("-ftest-coverage"); 2812 } 2813 2814 if (types::isCXX(Inputs[0].getType())) 2815 CmdArgs.push_back("-D__private_extern__=extern"); 2816} 2817 2818void darwin::CC1::AddCPPOptionsArgs(const ArgList &Args, ArgStringList &CmdArgs, 2819 const InputInfoList &Inputs, 2820 const ArgStringList &OutputArgs) const { 2821 // Derived from cpp_options 2822 AddCPPUniqueOptionsArgs(Args, CmdArgs, Inputs); 2823 2824 CmdArgs.append(OutputArgs.begin(), OutputArgs.end()); 2825 2826 AddCC1Args(Args, CmdArgs); 2827 2828 // NOTE: The code below has some commonality with cpp_options, but 2829 // in classic gcc style ends up sending things in different 2830 // orders. This may be a good merge candidate once we drop pedantic 2831 // compatibility. 2832 2833 Args.AddAllArgs(CmdArgs, options::OPT_m_Group); 2834 Args.AddAllArgs(CmdArgs, options::OPT_std_EQ, options::OPT_ansi, 2835 options::OPT_trigraphs); 2836 if (!Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) { 2837 // Honor -std-default. 2838 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ, 2839 "-std=", /*Joined=*/true); 2840 } 2841 Args.AddAllArgs(CmdArgs, options::OPT_W_Group, options::OPT_pedantic_Group); 2842 Args.AddLastArg(CmdArgs, options::OPT_w); 2843 2844 // The driver treats -fsyntax-only specially. 2845 Args.AddAllArgs(CmdArgs, options::OPT_f_Group, options::OPT_fsyntax_only); 2846 2847 // Claim Clang only -f options, they aren't worth warning about. 2848 Args.ClaimAllArgs(options::OPT_f_clang_Group); 2849 2850 if (Args.hasArg(options::OPT_g_Group) && !Args.hasArg(options::OPT_g0) && 2851 !Args.hasArg(options::OPT_fno_working_directory)) 2852 CmdArgs.push_back("-fworking-directory"); 2853 2854 Args.AddAllArgs(CmdArgs, options::OPT_O); 2855 Args.AddAllArgs(CmdArgs, options::OPT_undef); 2856 if (Args.hasArg(options::OPT_save_temps)) 2857 CmdArgs.push_back("-fpch-preprocess"); 2858} 2859 2860void darwin::CC1::AddCPPUniqueOptionsArgs(const ArgList &Args, 2861 ArgStringList &CmdArgs, 2862 const InputInfoList &Inputs) const { 2863 const Driver &D = getToolChain().getDriver(); 2864 2865 CheckPreprocessingOptions(D, Args); 2866 2867 // Derived from cpp_unique_options. 2868 // -{C,CC} only with -E is checked in CheckPreprocessingOptions(). 2869 Args.AddLastArg(CmdArgs, options::OPT_C); 2870 Args.AddLastArg(CmdArgs, options::OPT_CC); 2871 if (!Args.hasArg(options::OPT_Q)) 2872 CmdArgs.push_back("-quiet"); 2873 Args.AddAllArgs(CmdArgs, options::OPT_nostdinc); 2874 Args.AddAllArgs(CmdArgs, options::OPT_nostdincxx); 2875 Args.AddLastArg(CmdArgs, options::OPT_v); 2876 Args.AddAllArgs(CmdArgs, options::OPT_I_Group, options::OPT_F); 2877 Args.AddLastArg(CmdArgs, options::OPT_P); 2878 2879 // FIXME: Handle %I properly. 2880 if (getToolChain().getArchName() == "x86_64") { 2881 CmdArgs.push_back("-imultilib"); 2882 CmdArgs.push_back("x86_64"); 2883 } 2884 2885 if (Args.hasArg(options::OPT_MD)) { 2886 CmdArgs.push_back("-MD"); 2887 CmdArgs.push_back(darwin::CC1::getDependencyFileName(Args, Inputs)); 2888 } 2889 2890 if (Args.hasArg(options::OPT_MMD)) { 2891 CmdArgs.push_back("-MMD"); 2892 CmdArgs.push_back(darwin::CC1::getDependencyFileName(Args, Inputs)); 2893 } 2894 2895 Args.AddLastArg(CmdArgs, options::OPT_M); 2896 Args.AddLastArg(CmdArgs, options::OPT_MM); 2897 Args.AddAllArgs(CmdArgs, options::OPT_MF); 2898 Args.AddLastArg(CmdArgs, options::OPT_MG); 2899 Args.AddLastArg(CmdArgs, options::OPT_MP); 2900 Args.AddAllArgs(CmdArgs, options::OPT_MQ); 2901 Args.AddAllArgs(CmdArgs, options::OPT_MT); 2902 if (!Args.hasArg(options::OPT_M) && !Args.hasArg(options::OPT_MM) && 2903 (Args.hasArg(options::OPT_MD) || Args.hasArg(options::OPT_MMD))) { 2904 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) { 2905 CmdArgs.push_back("-MQ"); 2906 CmdArgs.push_back(OutputOpt->getValue(Args)); 2907 } 2908 } 2909 2910 Args.AddLastArg(CmdArgs, options::OPT_remap); 2911 if (Args.hasArg(options::OPT_g3)) 2912 CmdArgs.push_back("-dD"); 2913 Args.AddLastArg(CmdArgs, options::OPT_H); 2914 2915 AddCPPArgs(Args, CmdArgs); 2916 2917 Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U, options::OPT_A); 2918 Args.AddAllArgs(CmdArgs, options::OPT_i_Group); 2919 2920 for (InputInfoList::const_iterator 2921 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 2922 const InputInfo &II = *it; 2923 2924 CmdArgs.push_back(II.getFilename()); 2925 } 2926 2927 Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA, 2928 options::OPT_Xpreprocessor); 2929 2930 if (Args.hasArg(options::OPT_fmudflap)) { 2931 CmdArgs.push_back("-D_MUDFLAP"); 2932 CmdArgs.push_back("-include"); 2933 CmdArgs.push_back("mf-runtime.h"); 2934 } 2935 2936 if (Args.hasArg(options::OPT_fmudflapth)) { 2937 CmdArgs.push_back("-D_MUDFLAP"); 2938 CmdArgs.push_back("-D_MUDFLAPTH"); 2939 CmdArgs.push_back("-include"); 2940 CmdArgs.push_back("mf-runtime.h"); 2941 } 2942} 2943 2944void darwin::CC1::AddCPPArgs(const ArgList &Args, 2945 ArgStringList &CmdArgs) const { 2946 // Derived from cpp spec. 2947 2948 if (Args.hasArg(options::OPT_static)) { 2949 // The gcc spec is broken here, it refers to dynamic but 2950 // that has been translated. Start by being bug compatible. 2951 2952 // if (!Args.hasArg(arglist.parser.dynamicOption)) 2953 CmdArgs.push_back("-D__STATIC__"); 2954 } else 2955 CmdArgs.push_back("-D__DYNAMIC__"); 2956 2957 if (Args.hasArg(options::OPT_pthread)) 2958 CmdArgs.push_back("-D_REENTRANT"); 2959} 2960 2961void darwin::Preprocess::ConstructJob(Compilation &C, const JobAction &JA, 2962 const InputInfo &Output, 2963 const InputInfoList &Inputs, 2964 const ArgList &Args, 2965 const char *LinkingOutput) const { 2966 ArgStringList CmdArgs; 2967 2968 assert(Inputs.size() == 1 && "Unexpected number of inputs!"); 2969 2970 CmdArgs.push_back("-E"); 2971 2972 if (Args.hasArg(options::OPT_traditional) || 2973 Args.hasArg(options::OPT_traditional_cpp)) 2974 CmdArgs.push_back("-traditional-cpp"); 2975 2976 ArgStringList OutputArgs; 2977 assert(Output.isFilename() && "Unexpected CC1 output."); 2978 OutputArgs.push_back("-o"); 2979 OutputArgs.push_back(Output.getFilename()); 2980 2981 if (Args.hasArg(options::OPT_E) || getToolChain().getDriver().CCCIsCPP) { 2982 AddCPPOptionsArgs(Args, CmdArgs, Inputs, OutputArgs); 2983 } else { 2984 AddCPPOptionsArgs(Args, CmdArgs, Inputs, ArgStringList()); 2985 CmdArgs.append(OutputArgs.begin(), OutputArgs.end()); 2986 } 2987 2988 Args.AddAllArgs(CmdArgs, options::OPT_d_Group); 2989 2990 RemoveCC1UnsupportedArgs(CmdArgs); 2991 2992 const char *CC1Name = getCC1Name(Inputs[0].getType()); 2993 const char *Exec = 2994 Args.MakeArgString(getToolChain().GetProgramPath(CC1Name)); 2995 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 2996} 2997 2998void darwin::Compile::ConstructJob(Compilation &C, const JobAction &JA, 2999 const InputInfo &Output, 3000 const InputInfoList &Inputs, 3001 const ArgList &Args, 3002 const char *LinkingOutput) const { 3003 const Driver &D = getToolChain().getDriver(); 3004 ArgStringList CmdArgs; 3005 3006 assert(Inputs.size() == 1 && "Unexpected number of inputs!"); 3007 3008 types::ID InputType = Inputs[0].getType(); 3009 const Arg *A; 3010 if ((A = Args.getLastArg(options::OPT_traditional))) 3011 D.Diag(diag::err_drv_argument_only_allowed_with) 3012 << A->getAsString(Args) << "-E"; 3013 3014 if (JA.getType() == types::TY_LLVM_IR || 3015 JA.getType() == types::TY_LTO_IR) 3016 CmdArgs.push_back("-emit-llvm"); 3017 else if (JA.getType() == types::TY_LLVM_BC || 3018 JA.getType() == types::TY_LTO_BC) 3019 CmdArgs.push_back("-emit-llvm-bc"); 3020 else if (Output.getType() == types::TY_AST) 3021 D.Diag(diag::err_drv_no_ast_support) 3022 << getToolChain().getTripleString(); 3023 else if (JA.getType() != types::TY_PP_Asm && 3024 JA.getType() != types::TY_PCH) 3025 D.Diag(diag::err_drv_invalid_gcc_output_type) 3026 << getTypeName(JA.getType()); 3027 3028 ArgStringList OutputArgs; 3029 if (Output.getType() != types::TY_PCH) { 3030 OutputArgs.push_back("-o"); 3031 if (Output.isNothing()) 3032 OutputArgs.push_back("/dev/null"); 3033 else 3034 OutputArgs.push_back(Output.getFilename()); 3035 } 3036 3037 // There is no need for this level of compatibility, but it makes 3038 // diffing easier. 3039 bool OutputArgsEarly = (Args.hasArg(options::OPT_fsyntax_only) || 3040 Args.hasArg(options::OPT_S)); 3041 3042 if (types::getPreprocessedType(InputType) != types::TY_INVALID) { 3043 AddCPPUniqueOptionsArgs(Args, CmdArgs, Inputs); 3044 if (OutputArgsEarly) { 3045 AddCC1OptionsArgs(Args, CmdArgs, Inputs, OutputArgs); 3046 } else { 3047 AddCC1OptionsArgs(Args, CmdArgs, Inputs, ArgStringList()); 3048 CmdArgs.append(OutputArgs.begin(), OutputArgs.end()); 3049 } 3050 } else { 3051 CmdArgs.push_back("-fpreprocessed"); 3052 3053 for (InputInfoList::const_iterator 3054 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 3055 const InputInfo &II = *it; 3056 3057 // Reject AST inputs. 3058 if (II.getType() == types::TY_AST) { 3059 D.Diag(diag::err_drv_no_ast_support) 3060 << getToolChain().getTripleString(); 3061 return; 3062 } 3063 3064 CmdArgs.push_back(II.getFilename()); 3065 } 3066 3067 if (OutputArgsEarly) { 3068 AddCC1OptionsArgs(Args, CmdArgs, Inputs, OutputArgs); 3069 } else { 3070 AddCC1OptionsArgs(Args, CmdArgs, Inputs, ArgStringList()); 3071 CmdArgs.append(OutputArgs.begin(), OutputArgs.end()); 3072 } 3073 } 3074 3075 if (Output.getType() == types::TY_PCH) { 3076 assert(Output.isFilename() && "Invalid PCH output."); 3077 3078 CmdArgs.push_back("-o"); 3079 // NOTE: gcc uses a temp .s file for this, but there doesn't seem 3080 // to be a good reason. 3081 const char *TmpPath = C.getArgs().MakeArgString( 3082 D.GetTemporaryPath("cc", "s")); 3083 C.addTempFile(TmpPath); 3084 CmdArgs.push_back(TmpPath); 3085 3086 // If we're emitting a pch file with the last 4 characters of ".pth" 3087 // and falling back to llvm-gcc we want to use ".gch" instead. 3088 std::string OutputFile(Output.getFilename()); 3089 size_t loc = OutputFile.rfind(".pth"); 3090 if (loc != std::string::npos) 3091 OutputFile.replace(loc, 4, ".gch"); 3092 const char *Tmp = C.getArgs().MakeArgString("--output-pch="+OutputFile); 3093 CmdArgs.push_back(Tmp); 3094 } 3095 3096 RemoveCC1UnsupportedArgs(CmdArgs); 3097 3098 const char *CC1Name = getCC1Name(Inputs[0].getType()); 3099 const char *Exec = 3100 Args.MakeArgString(getToolChain().GetProgramPath(CC1Name)); 3101 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 3102} 3103 3104void darwin::Assemble::ConstructJob(Compilation &C, const JobAction &JA, 3105 const InputInfo &Output, 3106 const InputInfoList &Inputs, 3107 const ArgList &Args, 3108 const char *LinkingOutput) const { 3109 ArgStringList CmdArgs; 3110 3111 assert(Inputs.size() == 1 && "Unexpected number of inputs."); 3112 const InputInfo &Input = Inputs[0]; 3113 3114 // Determine the original source input. 3115 const Action *SourceAction = &JA; 3116 while (SourceAction->getKind() != Action::InputClass) { 3117 assert(!SourceAction->getInputs().empty() && "unexpected root action!"); 3118 SourceAction = SourceAction->getInputs()[0]; 3119 } 3120 3121 // Forward -g, assuming we are dealing with an actual assembly file. 3122 if (SourceAction->getType() == types::TY_Asm || 3123 SourceAction->getType() == types::TY_PP_Asm) { 3124 if (Args.hasArg(options::OPT_gstabs)) 3125 CmdArgs.push_back("--gstabs"); 3126 else if (Args.hasArg(options::OPT_g_Group)) 3127 CmdArgs.push_back("--gdwarf2"); 3128 } 3129 3130 // Derived from asm spec. 3131 AddDarwinArch(Args, CmdArgs); 3132 3133 // Use -force_cpusubtype_ALL on x86 by default. 3134 if (getToolChain().getTriple().getArch() == llvm::Triple::x86 || 3135 getToolChain().getTriple().getArch() == llvm::Triple::x86_64 || 3136 Args.hasArg(options::OPT_force__cpusubtype__ALL)) 3137 CmdArgs.push_back("-force_cpusubtype_ALL"); 3138 3139 if (getToolChain().getTriple().getArch() != llvm::Triple::x86_64 && 3140 (Args.hasArg(options::OPT_mkernel) || 3141 Args.hasArg(options::OPT_static) || 3142 Args.hasArg(options::OPT_fapple_kext))) 3143 CmdArgs.push_back("-static"); 3144 3145 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, 3146 options::OPT_Xassembler); 3147 3148 assert(Output.isFilename() && "Unexpected lipo output."); 3149 CmdArgs.push_back("-o"); 3150 CmdArgs.push_back(Output.getFilename()); 3151 3152 assert(Input.isFilename() && "Invalid input."); 3153 CmdArgs.push_back(Input.getFilename()); 3154 3155 // asm_final spec is empty. 3156 3157 const char *Exec = 3158 Args.MakeArgString(getToolChain().GetProgramPath("as")); 3159 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 3160} 3161 3162void darwin::DarwinTool::AddDarwinArch(const ArgList &Args, 3163 ArgStringList &CmdArgs) const { 3164 StringRef ArchName = getDarwinToolChain().getDarwinArchName(Args); 3165 3166 // Derived from darwin_arch spec. 3167 CmdArgs.push_back("-arch"); 3168 CmdArgs.push_back(Args.MakeArgString(ArchName)); 3169 3170 // FIXME: Is this needed anymore? 3171 if (ArchName == "arm") 3172 CmdArgs.push_back("-force_cpusubtype_ALL"); 3173} 3174 3175void darwin::Link::AddLinkArgs(Compilation &C, 3176 const ArgList &Args, 3177 ArgStringList &CmdArgs) const { 3178 const Driver &D = getToolChain().getDriver(); 3179 const toolchains::Darwin &DarwinTC = getDarwinToolChain(); 3180 3181 unsigned Version[3] = { 0, 0, 0 }; 3182 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) { 3183 bool HadExtra; 3184 if (!Driver::GetReleaseVersion(A->getValue(Args), Version[0], 3185 Version[1], Version[2], HadExtra) || 3186 HadExtra) 3187 D.Diag(diag::err_drv_invalid_version_number) 3188 << A->getAsString(Args); 3189 } 3190 3191 // Newer linkers support -demangle, pass it if supported and not disabled by 3192 // the user. 3193 // 3194 // FIXME: We temporarily avoid passing -demangle to any iOS linker, because 3195 // unfortunately we can't be guaranteed that the linker version used there 3196 // will match the linker version detected at configure time. We need the 3197 // universal driver. 3198 if (Version[0] >= 100 && !Args.hasArg(options::OPT_Z_Xlinker__no_demangle) && 3199 !DarwinTC.isTargetIPhoneOS()) { 3200 // Don't pass -demangle to ld_classic. 3201 // 3202 // FIXME: This is a temporary workaround, ld should be handling this. 3203 bool UsesLdClassic = (getToolChain().getArch() == llvm::Triple::x86 && 3204 Args.hasArg(options::OPT_static)); 3205 if (getToolChain().getArch() == llvm::Triple::x86) { 3206 for (arg_iterator it = Args.filtered_begin(options::OPT_Xlinker, 3207 options::OPT_Wl_COMMA), 3208 ie = Args.filtered_end(); it != ie; ++it) { 3209 const Arg *A = *it; 3210 for (unsigned i = 0, e = A->getNumValues(); i != e; ++i) 3211 if (StringRef(A->getValue(Args, i)) == "-kext") 3212 UsesLdClassic = true; 3213 } 3214 } 3215 if (!UsesLdClassic) 3216 CmdArgs.push_back("-demangle"); 3217 } 3218 3219 // If we are using LTO, then automatically create a temporary file path for 3220 // the linker to use, so that it's lifetime will extend past a possible 3221 // dsymutil step. 3222 if (Version[0] >= 116 && D.IsUsingLTO(Args)) { 3223 const char *TmpPath = C.getArgs().MakeArgString( 3224 D.GetTemporaryPath("cc", types::getTypeTempSuffix(types::TY_Object))); 3225 C.addTempFile(TmpPath); 3226 CmdArgs.push_back("-object_path_lto"); 3227 CmdArgs.push_back(TmpPath); 3228 } 3229 3230 // Derived from the "link" spec. 3231 Args.AddAllArgs(CmdArgs, options::OPT_static); 3232 if (!Args.hasArg(options::OPT_static)) 3233 CmdArgs.push_back("-dynamic"); 3234 if (Args.hasArg(options::OPT_fgnu_runtime)) { 3235 // FIXME: gcc replaces -lobjc in forward args with -lobjc-gnu 3236 // here. How do we wish to handle such things? 3237 } 3238 3239 if (!Args.hasArg(options::OPT_dynamiclib)) { 3240 AddDarwinArch(Args, CmdArgs); 3241 // FIXME: Why do this only on this path? 3242 Args.AddLastArg(CmdArgs, options::OPT_force__cpusubtype__ALL); 3243 3244 Args.AddLastArg(CmdArgs, options::OPT_bundle); 3245 Args.AddAllArgs(CmdArgs, options::OPT_bundle__loader); 3246 Args.AddAllArgs(CmdArgs, options::OPT_client__name); 3247 3248 Arg *A; 3249 if ((A = Args.getLastArg(options::OPT_compatibility__version)) || 3250 (A = Args.getLastArg(options::OPT_current__version)) || 3251 (A = Args.getLastArg(options::OPT_install__name))) 3252 D.Diag(diag::err_drv_argument_only_allowed_with) 3253 << A->getAsString(Args) << "-dynamiclib"; 3254 3255 Args.AddLastArg(CmdArgs, options::OPT_force__flat__namespace); 3256 Args.AddLastArg(CmdArgs, options::OPT_keep__private__externs); 3257 Args.AddLastArg(CmdArgs, options::OPT_private__bundle); 3258 } else { 3259 CmdArgs.push_back("-dylib"); 3260 3261 Arg *A; 3262 if ((A = Args.getLastArg(options::OPT_bundle)) || 3263 (A = Args.getLastArg(options::OPT_bundle__loader)) || 3264 (A = Args.getLastArg(options::OPT_client__name)) || 3265 (A = Args.getLastArg(options::OPT_force__flat__namespace)) || 3266 (A = Args.getLastArg(options::OPT_keep__private__externs)) || 3267 (A = Args.getLastArg(options::OPT_private__bundle))) 3268 D.Diag(diag::err_drv_argument_not_allowed_with) 3269 << A->getAsString(Args) << "-dynamiclib"; 3270 3271 Args.AddAllArgsTranslated(CmdArgs, options::OPT_compatibility__version, 3272 "-dylib_compatibility_version"); 3273 Args.AddAllArgsTranslated(CmdArgs, options::OPT_current__version, 3274 "-dylib_current_version"); 3275 3276 AddDarwinArch(Args, CmdArgs); 3277 3278 Args.AddAllArgsTranslated(CmdArgs, options::OPT_install__name, 3279 "-dylib_install_name"); 3280 } 3281 3282 Args.AddLastArg(CmdArgs, options::OPT_all__load); 3283 Args.AddAllArgs(CmdArgs, options::OPT_allowable__client); 3284 Args.AddLastArg(CmdArgs, options::OPT_bind__at__load); 3285 if (DarwinTC.isTargetIPhoneOS()) 3286 Args.AddLastArg(CmdArgs, options::OPT_arch__errors__fatal); 3287 Args.AddLastArg(CmdArgs, options::OPT_dead__strip); 3288 Args.AddLastArg(CmdArgs, options::OPT_no__dead__strip__inits__and__terms); 3289 Args.AddAllArgs(CmdArgs, options::OPT_dylib__file); 3290 Args.AddLastArg(CmdArgs, options::OPT_dynamic); 3291 Args.AddAllArgs(CmdArgs, options::OPT_exported__symbols__list); 3292 Args.AddLastArg(CmdArgs, options::OPT_flat__namespace); 3293 Args.AddAllArgs(CmdArgs, options::OPT_force__load); 3294 Args.AddAllArgs(CmdArgs, options::OPT_headerpad__max__install__names); 3295 Args.AddAllArgs(CmdArgs, options::OPT_image__base); 3296 Args.AddAllArgs(CmdArgs, options::OPT_init); 3297 3298 // Add the deployment target. 3299 unsigned TargetVersion[3]; 3300 DarwinTC.getTargetVersion(TargetVersion); 3301 3302 // If we had an explicit -mios-simulator-version-min argument, honor that, 3303 // otherwise use the traditional deployment targets. We can't just check the 3304 // is-sim attribute because existing code follows this path, and the linker 3305 // may not handle the argument. 3306 // 3307 // FIXME: We may be able to remove this, once we can verify no one depends on 3308 // it. 3309 if (Args.hasArg(options::OPT_mios_simulator_version_min_EQ)) 3310 CmdArgs.push_back("-ios_simulator_version_min"); 3311 else if (DarwinTC.isTargetIPhoneOS()) 3312 CmdArgs.push_back("-iphoneos_version_min"); 3313 else 3314 CmdArgs.push_back("-macosx_version_min"); 3315 CmdArgs.push_back(Args.MakeArgString(Twine(TargetVersion[0]) + "." + 3316 Twine(TargetVersion[1]) + "." + 3317 Twine(TargetVersion[2]))); 3318 3319 Args.AddLastArg(CmdArgs, options::OPT_nomultidefs); 3320 Args.AddLastArg(CmdArgs, options::OPT_multi__module); 3321 Args.AddLastArg(CmdArgs, options::OPT_single__module); 3322 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined); 3323 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined__unused); 3324 3325 if (const Arg *A = Args.getLastArg(options::OPT_fpie, options::OPT_fPIE, 3326 options::OPT_fno_pie, 3327 options::OPT_fno_PIE)) { 3328 if (A->getOption().matches(options::OPT_fpie) || 3329 A->getOption().matches(options::OPT_fPIE)) 3330 CmdArgs.push_back("-pie"); 3331 else 3332 CmdArgs.push_back("-no_pie"); 3333 } 3334 3335 Args.AddLastArg(CmdArgs, options::OPT_prebind); 3336 Args.AddLastArg(CmdArgs, options::OPT_noprebind); 3337 Args.AddLastArg(CmdArgs, options::OPT_nofixprebinding); 3338 Args.AddLastArg(CmdArgs, options::OPT_prebind__all__twolevel__modules); 3339 Args.AddLastArg(CmdArgs, options::OPT_read__only__relocs); 3340 Args.AddAllArgs(CmdArgs, options::OPT_sectcreate); 3341 Args.AddAllArgs(CmdArgs, options::OPT_sectorder); 3342 Args.AddAllArgs(CmdArgs, options::OPT_seg1addr); 3343 Args.AddAllArgs(CmdArgs, options::OPT_segprot); 3344 Args.AddAllArgs(CmdArgs, options::OPT_segaddr); 3345 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__only__addr); 3346 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__write__addr); 3347 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table); 3348 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table__filename); 3349 Args.AddAllArgs(CmdArgs, options::OPT_sub__library); 3350 Args.AddAllArgs(CmdArgs, options::OPT_sub__umbrella); 3351 3352 // Give --sysroot= preference, over the Apple specific behavior to also use 3353 // --isysroot as the syslibroot. 3354 if (const Arg *A = Args.getLastArg(options::OPT__sysroot_EQ)) { 3355 CmdArgs.push_back("-syslibroot"); 3356 CmdArgs.push_back(A->getValue(Args)); 3357 } else if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) { 3358 CmdArgs.push_back("-syslibroot"); 3359 CmdArgs.push_back(A->getValue(Args)); 3360 } else if (getDarwinToolChain().isTargetIPhoneOS()) { 3361 CmdArgs.push_back("-syslibroot"); 3362 CmdArgs.push_back("/Developer/SDKs/Extra"); 3363 } 3364 3365 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace); 3366 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace__hints); 3367 Args.AddAllArgs(CmdArgs, options::OPT_umbrella); 3368 Args.AddAllArgs(CmdArgs, options::OPT_undefined); 3369 Args.AddAllArgs(CmdArgs, options::OPT_unexported__symbols__list); 3370 Args.AddAllArgs(CmdArgs, options::OPT_weak__reference__mismatches); 3371 Args.AddLastArg(CmdArgs, options::OPT_X_Flag); 3372 Args.AddAllArgs(CmdArgs, options::OPT_y); 3373 Args.AddLastArg(CmdArgs, options::OPT_w); 3374 Args.AddAllArgs(CmdArgs, options::OPT_pagezero__size); 3375 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__); 3376 Args.AddLastArg(CmdArgs, options::OPT_seglinkedit); 3377 Args.AddLastArg(CmdArgs, options::OPT_noseglinkedit); 3378 Args.AddAllArgs(CmdArgs, options::OPT_sectalign); 3379 Args.AddAllArgs(CmdArgs, options::OPT_sectobjectsymbols); 3380 Args.AddAllArgs(CmdArgs, options::OPT_segcreate); 3381 Args.AddLastArg(CmdArgs, options::OPT_whyload); 3382 Args.AddLastArg(CmdArgs, options::OPT_whatsloaded); 3383 Args.AddAllArgs(CmdArgs, options::OPT_dylinker__install__name); 3384 Args.AddLastArg(CmdArgs, options::OPT_dylinker); 3385 Args.AddLastArg(CmdArgs, options::OPT_Mach); 3386} 3387 3388void darwin::Link::ConstructJob(Compilation &C, const JobAction &JA, 3389 const InputInfo &Output, 3390 const InputInfoList &Inputs, 3391 const ArgList &Args, 3392 const char *LinkingOutput) const { 3393 assert(Output.getType() == types::TY_Image && "Invalid linker output type."); 3394 3395 // The logic here is derived from gcc's behavior; most of which 3396 // comes from specs (starting with link_command). Consult gcc for 3397 // more information. 3398 ArgStringList CmdArgs; 3399 3400 // I'm not sure why this particular decomposition exists in gcc, but 3401 // we follow suite for ease of comparison. 3402 AddLinkArgs(C, Args, CmdArgs); 3403 3404 Args.AddAllArgs(CmdArgs, options::OPT_d_Flag); 3405 Args.AddAllArgs(CmdArgs, options::OPT_s); 3406 Args.AddAllArgs(CmdArgs, options::OPT_t); 3407 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag); 3408 Args.AddAllArgs(CmdArgs, options::OPT_u_Group); 3409 Args.AddAllArgs(CmdArgs, options::OPT_A); 3410 Args.AddLastArg(CmdArgs, options::OPT_e); 3411 Args.AddAllArgs(CmdArgs, options::OPT_m_Separate); 3412 Args.AddAllArgs(CmdArgs, options::OPT_r); 3413 3414 // Forward -ObjC when either -ObjC or -ObjC++ is used, to force loading 3415 // members of static archive libraries which implement Objective-C classes or 3416 // categories. 3417 if (Args.hasArg(options::OPT_ObjC) || Args.hasArg(options::OPT_ObjCXX)) 3418 CmdArgs.push_back("-ObjC"); 3419 3420 CmdArgs.push_back("-o"); 3421 CmdArgs.push_back(Output.getFilename()); 3422 3423 if (!Args.hasArg(options::OPT_A) && 3424 !Args.hasArg(options::OPT_nostdlib) && 3425 !Args.hasArg(options::OPT_nostartfiles)) { 3426 // Derived from startfile spec. 3427 if (Args.hasArg(options::OPT_dynamiclib)) { 3428 // Derived from darwin_dylib1 spec. 3429 if (getDarwinToolChain().isTargetIOSSimulator()) { 3430 // The simulator doesn't have a versioned crt1 file. 3431 CmdArgs.push_back("-ldylib1.o"); 3432 } else if (getDarwinToolChain().isTargetIPhoneOS()) { 3433 if (getDarwinToolChain().isIPhoneOSVersionLT(3, 1)) 3434 CmdArgs.push_back("-ldylib1.o"); 3435 } else { 3436 if (getDarwinToolChain().isMacosxVersionLT(10, 5)) 3437 CmdArgs.push_back("-ldylib1.o"); 3438 else if (getDarwinToolChain().isMacosxVersionLT(10, 6)) 3439 CmdArgs.push_back("-ldylib1.10.5.o"); 3440 } 3441 } else { 3442 if (Args.hasArg(options::OPT_bundle)) { 3443 if (!Args.hasArg(options::OPT_static)) { 3444 // Derived from darwin_bundle1 spec. 3445 if (getDarwinToolChain().isTargetIOSSimulator()) { 3446 // The simulator doesn't have a versioned crt1 file. 3447 CmdArgs.push_back("-lbundle1.o"); 3448 } else if (getDarwinToolChain().isTargetIPhoneOS()) { 3449 if (getDarwinToolChain().isIPhoneOSVersionLT(3, 1)) 3450 CmdArgs.push_back("-lbundle1.o"); 3451 } else { 3452 if (getDarwinToolChain().isMacosxVersionLT(10, 6)) 3453 CmdArgs.push_back("-lbundle1.o"); 3454 } 3455 } 3456 } else { 3457 if (Args.hasArg(options::OPT_pg) && 3458 getToolChain().SupportsProfiling()) { 3459 if (Args.hasArg(options::OPT_static) || 3460 Args.hasArg(options::OPT_object) || 3461 Args.hasArg(options::OPT_preload)) { 3462 CmdArgs.push_back("-lgcrt0.o"); 3463 } else { 3464 CmdArgs.push_back("-lgcrt1.o"); 3465 3466 // darwin_crt2 spec is empty. 3467 } 3468 } else { 3469 if (Args.hasArg(options::OPT_static) || 3470 Args.hasArg(options::OPT_object) || 3471 Args.hasArg(options::OPT_preload)) { 3472 CmdArgs.push_back("-lcrt0.o"); 3473 } else { 3474 // Derived from darwin_crt1 spec. 3475 if (getDarwinToolChain().isTargetIOSSimulator()) { 3476 // The simulator doesn't have a versioned crt1 file. 3477 CmdArgs.push_back("-lcrt1.o"); 3478 } else if (getDarwinToolChain().isTargetIPhoneOS()) { 3479 if (getDarwinToolChain().isIPhoneOSVersionLT(3, 1)) 3480 CmdArgs.push_back("-lcrt1.o"); 3481 else 3482 CmdArgs.push_back("-lcrt1.3.1.o"); 3483 } else { 3484 if (getDarwinToolChain().isMacosxVersionLT(10, 5)) 3485 CmdArgs.push_back("-lcrt1.o"); 3486 else if (getDarwinToolChain().isMacosxVersionLT(10, 6)) 3487 CmdArgs.push_back("-lcrt1.10.5.o"); 3488 else 3489 CmdArgs.push_back("-lcrt1.10.6.o"); 3490 3491 // darwin_crt2 spec is empty. 3492 } 3493 } 3494 } 3495 } 3496 } 3497 3498 if (!getDarwinToolChain().isTargetIPhoneOS() && 3499 Args.hasArg(options::OPT_shared_libgcc) && 3500 getDarwinToolChain().isMacosxVersionLT(10, 5)) { 3501 const char *Str = 3502 Args.MakeArgString(getToolChain().GetFilePath("crt3.o")); 3503 CmdArgs.push_back(Str); 3504 } 3505 } 3506 3507 Args.AddAllArgs(CmdArgs, options::OPT_L); 3508 3509 if (Args.hasArg(options::OPT_fopenmp)) 3510 // This is more complicated in gcc... 3511 CmdArgs.push_back("-lgomp"); 3512 3513 getDarwinToolChain().AddLinkSearchPathArgs(Args, CmdArgs); 3514 3515 // In ARC, if we don't have runtime support, link in the runtime 3516 // stubs. We have to do this *before* adding any of the normal 3517 // linker inputs so that its initializer gets run first. 3518 if (isObjCAutoRefCount(Args)) { 3519 ObjCRuntime runtime; 3520 getDarwinToolChain().configureObjCRuntime(runtime); 3521 if (!runtime.HasARC) 3522 getDarwinToolChain().AddLinkARCArgs(Args, CmdArgs); 3523 } 3524 3525 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs); 3526 3527 if (LinkingOutput) { 3528 CmdArgs.push_back("-arch_multiple"); 3529 CmdArgs.push_back("-final_output"); 3530 CmdArgs.push_back(LinkingOutput); 3531 } 3532 3533 if (Args.hasArg(options::OPT_fnested_functions)) 3534 CmdArgs.push_back("-allow_stack_execute"); 3535 3536 if (!Args.hasArg(options::OPT_nostdlib) && 3537 !Args.hasArg(options::OPT_nodefaultlibs)) { 3538 if (getToolChain().getDriver().CCCIsCXX) 3539 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs); 3540 3541 // link_ssp spec is empty. 3542 3543 // Let the tool chain choose which runtime library to link. 3544 getDarwinToolChain().AddLinkRuntimeLibArgs(Args, CmdArgs); 3545 } 3546 3547 if (!Args.hasArg(options::OPT_A) && 3548 !Args.hasArg(options::OPT_nostdlib) && 3549 !Args.hasArg(options::OPT_nostartfiles)) { 3550 // endfile_spec is empty. 3551 } 3552 3553 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple()); 3554 3555 Args.AddAllArgs(CmdArgs, options::OPT_T_Group); 3556 Args.AddAllArgs(CmdArgs, options::OPT_F); 3557 3558 const char *Exec = 3559 Args.MakeArgString(getToolChain().GetProgramPath("ld")); 3560 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 3561} 3562 3563void darwin::Lipo::ConstructJob(Compilation &C, const JobAction &JA, 3564 const InputInfo &Output, 3565 const InputInfoList &Inputs, 3566 const ArgList &Args, 3567 const char *LinkingOutput) const { 3568 ArgStringList CmdArgs; 3569 3570 CmdArgs.push_back("-create"); 3571 assert(Output.isFilename() && "Unexpected lipo output."); 3572 3573 CmdArgs.push_back("-output"); 3574 CmdArgs.push_back(Output.getFilename()); 3575 3576 for (InputInfoList::const_iterator 3577 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 3578 const InputInfo &II = *it; 3579 assert(II.isFilename() && "Unexpected lipo input."); 3580 CmdArgs.push_back(II.getFilename()); 3581 } 3582 const char *Exec = 3583 Args.MakeArgString(getToolChain().GetProgramPath("lipo")); 3584 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 3585} 3586 3587void darwin::Dsymutil::ConstructJob(Compilation &C, const JobAction &JA, 3588 const InputInfo &Output, 3589 const InputInfoList &Inputs, 3590 const ArgList &Args, 3591 const char *LinkingOutput) const { 3592 ArgStringList CmdArgs; 3593 3594 CmdArgs.push_back("-o"); 3595 CmdArgs.push_back(Output.getFilename()); 3596 3597 assert(Inputs.size() == 1 && "Unable to handle multiple inputs."); 3598 const InputInfo &Input = Inputs[0]; 3599 assert(Input.isFilename() && "Unexpected dsymutil input."); 3600 CmdArgs.push_back(Input.getFilename()); 3601 3602 const char *Exec = 3603 Args.MakeArgString(getToolChain().GetProgramPath("dsymutil")); 3604 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 3605} 3606 3607void darwin::VerifyDebug::ConstructJob(Compilation &C, const JobAction &JA, 3608 const InputInfo &Output, 3609 const InputInfoList &Inputs, 3610 const ArgList &Args, 3611 const char *LinkingOutput) const { 3612 ArgStringList CmdArgs; 3613 CmdArgs.push_back("--verify"); 3614 3615 assert(Inputs.size() == 1 && "Unable to handle multiple inputs."); 3616 const InputInfo &Input = Inputs[0]; 3617 assert(Input.isFilename() && "Unexpected verify input"); 3618 3619 // Grabbing the output of the earlier dsymutil run. 3620 CmdArgs.push_back(Input.getFilename()); 3621 3622 const char *Exec = 3623 Args.MakeArgString(getToolChain().GetProgramPath("dwarfdump")); 3624 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 3625} 3626 3627void auroraux::Assemble::ConstructJob(Compilation &C, const JobAction &JA, 3628 const InputInfo &Output, 3629 const InputInfoList &Inputs, 3630 const ArgList &Args, 3631 const char *LinkingOutput) const { 3632 ArgStringList CmdArgs; 3633 3634 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, 3635 options::OPT_Xassembler); 3636 3637 CmdArgs.push_back("-o"); 3638 CmdArgs.push_back(Output.getFilename()); 3639 3640 for (InputInfoList::const_iterator 3641 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 3642 const InputInfo &II = *it; 3643 CmdArgs.push_back(II.getFilename()); 3644 } 3645 3646 const char *Exec = 3647 Args.MakeArgString(getToolChain().GetProgramPath("gas")); 3648 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 3649} 3650 3651void auroraux::Link::ConstructJob(Compilation &C, const JobAction &JA, 3652 const InputInfo &Output, 3653 const InputInfoList &Inputs, 3654 const ArgList &Args, 3655 const char *LinkingOutput) const { 3656 ArgStringList CmdArgs; 3657 3658 if ((!Args.hasArg(options::OPT_nostdlib)) && 3659 (!Args.hasArg(options::OPT_shared))) { 3660 CmdArgs.push_back("-e"); 3661 CmdArgs.push_back("_start"); 3662 } 3663 3664 if (Args.hasArg(options::OPT_static)) { 3665 CmdArgs.push_back("-Bstatic"); 3666 CmdArgs.push_back("-dn"); 3667 } else { 3668// CmdArgs.push_back("--eh-frame-hdr"); 3669 CmdArgs.push_back("-Bdynamic"); 3670 if (Args.hasArg(options::OPT_shared)) { 3671 CmdArgs.push_back("-shared"); 3672 } else { 3673 CmdArgs.push_back("--dynamic-linker"); 3674 CmdArgs.push_back("/lib/ld.so.1"); // 64Bit Path /lib/amd64/ld.so.1 3675 } 3676 } 3677 3678 if (Output.isFilename()) { 3679 CmdArgs.push_back("-o"); 3680 CmdArgs.push_back(Output.getFilename()); 3681 } else { 3682 assert(Output.isNothing() && "Invalid output."); 3683 } 3684 3685 if (!Args.hasArg(options::OPT_nostdlib) && 3686 !Args.hasArg(options::OPT_nostartfiles)) { 3687 if (!Args.hasArg(options::OPT_shared)) { 3688 CmdArgs.push_back(Args.MakeArgString( 3689 getToolChain().GetFilePath("crt1.o"))); 3690 CmdArgs.push_back(Args.MakeArgString( 3691 getToolChain().GetFilePath("crti.o"))); 3692 CmdArgs.push_back(Args.MakeArgString( 3693 getToolChain().GetFilePath("crtbegin.o"))); 3694 } else { 3695 CmdArgs.push_back(Args.MakeArgString( 3696 getToolChain().GetFilePath("crti.o"))); 3697 } 3698 CmdArgs.push_back(Args.MakeArgString( 3699 getToolChain().GetFilePath("crtn.o"))); 3700 } 3701 3702 CmdArgs.push_back(Args.MakeArgString("-L/opt/gcc4/lib/gcc/" 3703 + getToolChain().getTripleString() 3704 + "/4.2.4")); 3705 3706 Args.AddAllArgs(CmdArgs, options::OPT_L); 3707 Args.AddAllArgs(CmdArgs, options::OPT_T_Group); 3708 Args.AddAllArgs(CmdArgs, options::OPT_e); 3709 3710 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs); 3711 3712 if (!Args.hasArg(options::OPT_nostdlib) && 3713 !Args.hasArg(options::OPT_nodefaultlibs)) { 3714 // FIXME: For some reason GCC passes -lgcc before adding 3715 // the default system libraries. Just mimic this for now. 3716 CmdArgs.push_back("-lgcc"); 3717 3718 if (Args.hasArg(options::OPT_pthread)) 3719 CmdArgs.push_back("-pthread"); 3720 if (!Args.hasArg(options::OPT_shared)) 3721 CmdArgs.push_back("-lc"); 3722 CmdArgs.push_back("-lgcc"); 3723 } 3724 3725 if (!Args.hasArg(options::OPT_nostdlib) && 3726 !Args.hasArg(options::OPT_nostartfiles)) { 3727 if (!Args.hasArg(options::OPT_shared)) 3728 CmdArgs.push_back(Args.MakeArgString( 3729 getToolChain().GetFilePath("crtend.o"))); 3730 } 3731 3732 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple()); 3733 3734 const char *Exec = 3735 Args.MakeArgString(getToolChain().GetProgramPath("ld")); 3736 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 3737} 3738 3739void openbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA, 3740 const InputInfo &Output, 3741 const InputInfoList &Inputs, 3742 const ArgList &Args, 3743 const char *LinkingOutput) const { 3744 ArgStringList CmdArgs; 3745 3746 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, 3747 options::OPT_Xassembler); 3748 3749 CmdArgs.push_back("-o"); 3750 CmdArgs.push_back(Output.getFilename()); 3751 3752 for (InputInfoList::const_iterator 3753 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 3754 const InputInfo &II = *it; 3755 CmdArgs.push_back(II.getFilename()); 3756 } 3757 3758 const char *Exec = 3759 Args.MakeArgString(getToolChain().GetProgramPath("as")); 3760 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 3761} 3762 3763void openbsd::Link::ConstructJob(Compilation &C, const JobAction &JA, 3764 const InputInfo &Output, 3765 const InputInfoList &Inputs, 3766 const ArgList &Args, 3767 const char *LinkingOutput) const { 3768 const Driver &D = getToolChain().getDriver(); 3769 ArgStringList CmdArgs; 3770 3771 if ((!Args.hasArg(options::OPT_nostdlib)) && 3772 (!Args.hasArg(options::OPT_shared))) { 3773 CmdArgs.push_back("-e"); 3774 CmdArgs.push_back("__start"); 3775 } 3776 3777 if (Args.hasArg(options::OPT_static)) { 3778 CmdArgs.push_back("-Bstatic"); 3779 } else { 3780 if (Args.hasArg(options::OPT_rdynamic)) 3781 CmdArgs.push_back("-export-dynamic"); 3782 CmdArgs.push_back("--eh-frame-hdr"); 3783 CmdArgs.push_back("-Bdynamic"); 3784 if (Args.hasArg(options::OPT_shared)) { 3785 CmdArgs.push_back("-shared"); 3786 } else { 3787 CmdArgs.push_back("-dynamic-linker"); 3788 CmdArgs.push_back("/usr/libexec/ld.so"); 3789 } 3790 } 3791 3792 if (Output.isFilename()) { 3793 CmdArgs.push_back("-o"); 3794 CmdArgs.push_back(Output.getFilename()); 3795 } else { 3796 assert(Output.isNothing() && "Invalid output."); 3797 } 3798 3799 if (!Args.hasArg(options::OPT_nostdlib) && 3800 !Args.hasArg(options::OPT_nostartfiles)) { 3801 if (!Args.hasArg(options::OPT_shared)) { 3802 CmdArgs.push_back(Args.MakeArgString( 3803 getToolChain().GetFilePath("crt0.o"))); 3804 CmdArgs.push_back(Args.MakeArgString( 3805 getToolChain().GetFilePath("crtbegin.o"))); 3806 } else { 3807 CmdArgs.push_back(Args.MakeArgString( 3808 getToolChain().GetFilePath("crtbeginS.o"))); 3809 } 3810 } 3811 3812 std::string Triple = getToolChain().getTripleString(); 3813 if (Triple.substr(0, 6) == "x86_64") 3814 Triple.replace(0, 6, "amd64"); 3815 CmdArgs.push_back(Args.MakeArgString("-L/usr/lib/gcc-lib/" + Triple + 3816 "/4.2.1")); 3817 3818 Args.AddAllArgs(CmdArgs, options::OPT_L); 3819 Args.AddAllArgs(CmdArgs, options::OPT_T_Group); 3820 Args.AddAllArgs(CmdArgs, options::OPT_e); 3821 3822 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs); 3823 3824 if (!Args.hasArg(options::OPT_nostdlib) && 3825 !Args.hasArg(options::OPT_nodefaultlibs)) { 3826 if (D.CCCIsCXX) { 3827 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs); 3828 CmdArgs.push_back("-lm"); 3829 } 3830 3831 // FIXME: For some reason GCC passes -lgcc before adding 3832 // the default system libraries. Just mimic this for now. 3833 CmdArgs.push_back("-lgcc"); 3834 3835 if (Args.hasArg(options::OPT_pthread)) 3836 CmdArgs.push_back("-lpthread"); 3837 if (!Args.hasArg(options::OPT_shared)) 3838 CmdArgs.push_back("-lc"); 3839 CmdArgs.push_back("-lgcc"); 3840 } 3841 3842 if (!Args.hasArg(options::OPT_nostdlib) && 3843 !Args.hasArg(options::OPT_nostartfiles)) { 3844 if (!Args.hasArg(options::OPT_shared)) 3845 CmdArgs.push_back(Args.MakeArgString( 3846 getToolChain().GetFilePath("crtend.o"))); 3847 else 3848 CmdArgs.push_back(Args.MakeArgString( 3849 getToolChain().GetFilePath("crtendS.o"))); 3850 } 3851 3852 const char *Exec = 3853 Args.MakeArgString(getToolChain().GetProgramPath("ld")); 3854 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 3855} 3856 3857void freebsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA, 3858 const InputInfo &Output, 3859 const InputInfoList &Inputs, 3860 const ArgList &Args, 3861 const char *LinkingOutput) const { 3862 ArgStringList CmdArgs; 3863 3864 // When building 32-bit code on FreeBSD/amd64, we have to explicitly 3865 // instruct as in the base system to assemble 32-bit code. 3866 if (getToolChain().getArchName() == "i386") 3867 CmdArgs.push_back("--32"); 3868 3869 if (getToolChain().getArchName() == "powerpc") 3870 CmdArgs.push_back("-a32"); 3871 3872 // Set byte order explicitly 3873 if (getToolChain().getArchName() == "mips") 3874 CmdArgs.push_back("-EB"); 3875 else if (getToolChain().getArchName() == "mipsel") 3876 CmdArgs.push_back("-EL"); 3877 3878 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, 3879 options::OPT_Xassembler); 3880 3881 CmdArgs.push_back("-o"); 3882 CmdArgs.push_back(Output.getFilename()); 3883 3884 for (InputInfoList::const_iterator 3885 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 3886 const InputInfo &II = *it; 3887 CmdArgs.push_back(II.getFilename()); 3888 } 3889 3890 const char *Exec = 3891 Args.MakeArgString(getToolChain().GetProgramPath("as")); 3892 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 3893} 3894 3895void freebsd::Link::ConstructJob(Compilation &C, const JobAction &JA, 3896 const InputInfo &Output, 3897 const InputInfoList &Inputs, 3898 const ArgList &Args, 3899 const char *LinkingOutput) const { 3900 const Driver &D = getToolChain().getDriver(); 3901 ArgStringList CmdArgs; 3902 3903 if (!D.SysRoot.empty()) 3904 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot)); 3905 3906 if (Args.hasArg(options::OPT_static)) { 3907 CmdArgs.push_back("-Bstatic"); 3908 } else { 3909 if (Args.hasArg(options::OPT_rdynamic)) 3910 CmdArgs.push_back("-export-dynamic"); 3911 CmdArgs.push_back("--eh-frame-hdr"); 3912 if (Args.hasArg(options::OPT_shared)) { 3913 CmdArgs.push_back("-Bshareable"); 3914 } else { 3915 CmdArgs.push_back("-dynamic-linker"); 3916 CmdArgs.push_back("/libexec/ld-elf.so.1"); 3917 } 3918 } 3919 3920 // When building 32-bit code on FreeBSD/amd64, we have to explicitly 3921 // instruct ld in the base system to link 32-bit code. 3922 if (getToolChain().getArchName() == "i386") { 3923 CmdArgs.push_back("-m"); 3924 CmdArgs.push_back("elf_i386_fbsd"); 3925 } 3926 3927 if (getToolChain().getArchName() == "powerpc") { 3928 CmdArgs.push_back("-m"); 3929 CmdArgs.push_back("elf32ppc"); 3930 } 3931 3932 if (Output.isFilename()) { 3933 CmdArgs.push_back("-o"); 3934 CmdArgs.push_back(Output.getFilename()); 3935 } else { 3936 assert(Output.isNothing() && "Invalid output."); 3937 } 3938 3939 if (!Args.hasArg(options::OPT_nostdlib) && 3940 !Args.hasArg(options::OPT_nostartfiles)) { 3941 if (!Args.hasArg(options::OPT_shared)) { 3942 if (Args.hasArg(options::OPT_pg)) 3943 CmdArgs.push_back(Args.MakeArgString( 3944 getToolChain().GetFilePath("gcrt1.o"))); 3945 else 3946 CmdArgs.push_back(Args.MakeArgString( 3947 getToolChain().GetFilePath("crt1.o"))); 3948 CmdArgs.push_back(Args.MakeArgString( 3949 getToolChain().GetFilePath("crti.o"))); 3950 CmdArgs.push_back(Args.MakeArgString( 3951 getToolChain().GetFilePath("crtbegin.o"))); 3952 } else { 3953 CmdArgs.push_back(Args.MakeArgString( 3954 getToolChain().GetFilePath("crti.o"))); 3955 CmdArgs.push_back(Args.MakeArgString( 3956 getToolChain().GetFilePath("crtbeginS.o"))); 3957 } 3958 } 3959 3960 Args.AddAllArgs(CmdArgs, options::OPT_L); 3961 const ToolChain::path_list Paths = getToolChain().getFilePaths(); 3962 for (ToolChain::path_list::const_iterator i = Paths.begin(), e = Paths.end(); 3963 i != e; ++i) 3964 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + *i)); 3965 Args.AddAllArgs(CmdArgs, options::OPT_T_Group); 3966 Args.AddAllArgs(CmdArgs, options::OPT_e); 3967 Args.AddAllArgs(CmdArgs, options::OPT_s); 3968 Args.AddAllArgs(CmdArgs, options::OPT_t); 3969 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag); 3970 Args.AddAllArgs(CmdArgs, options::OPT_r); 3971 3972 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs); 3973 3974 if (!Args.hasArg(options::OPT_nostdlib) && 3975 !Args.hasArg(options::OPT_nodefaultlibs)) { 3976 if (D.CCCIsCXX) { 3977 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs); 3978 if (Args.hasArg(options::OPT_pg)) 3979 CmdArgs.push_back("-lm_p"); 3980 else 3981 CmdArgs.push_back("-lm"); 3982 } 3983 // FIXME: For some reason GCC passes -lgcc and -lgcc_s before adding 3984 // the default system libraries. Just mimic this for now. 3985 if (Args.hasArg(options::OPT_pg)) 3986 CmdArgs.push_back("-lgcc_p"); 3987 else 3988 CmdArgs.push_back("-lgcc"); 3989 if (Args.hasArg(options::OPT_static)) { 3990 CmdArgs.push_back("-lgcc_eh"); 3991 } else if (Args.hasArg(options::OPT_pg)) { 3992 CmdArgs.push_back("-lgcc_eh_p"); 3993 } else { 3994 CmdArgs.push_back("--as-needed"); 3995 CmdArgs.push_back("-lgcc_s"); 3996 CmdArgs.push_back("--no-as-needed"); 3997 } 3998 3999 if (Args.hasArg(options::OPT_pthread)) { 4000 if (Args.hasArg(options::OPT_pg)) 4001 CmdArgs.push_back("-lpthread_p"); 4002 else 4003 CmdArgs.push_back("-lpthread"); 4004 } 4005 4006 if (Args.hasArg(options::OPT_pg)) { 4007 if (Args.hasArg(options::OPT_shared)) 4008 CmdArgs.push_back("-lc"); 4009 else 4010 CmdArgs.push_back("-lc_p"); 4011 CmdArgs.push_back("-lgcc_p"); 4012 } else { 4013 CmdArgs.push_back("-lc"); 4014 CmdArgs.push_back("-lgcc"); 4015 } 4016 4017 if (Args.hasArg(options::OPT_static)) { 4018 CmdArgs.push_back("-lgcc_eh"); 4019 } else if (Args.hasArg(options::OPT_pg)) { 4020 CmdArgs.push_back("-lgcc_eh_p"); 4021 } else { 4022 CmdArgs.push_back("--as-needed"); 4023 CmdArgs.push_back("-lgcc_s"); 4024 CmdArgs.push_back("--no-as-needed"); 4025 } 4026 } 4027 4028 if (!Args.hasArg(options::OPT_nostdlib) && 4029 !Args.hasArg(options::OPT_nostartfiles)) { 4030 if (!Args.hasArg(options::OPT_shared)) 4031 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath( 4032 "crtend.o"))); 4033 else 4034 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath( 4035 "crtendS.o"))); 4036 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath( 4037 "crtn.o"))); 4038 } 4039 4040 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple()); 4041 4042 const char *Exec = 4043 Args.MakeArgString(getToolChain().GetProgramPath("ld")); 4044 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 4045} 4046 4047void netbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA, 4048 const InputInfo &Output, 4049 const InputInfoList &Inputs, 4050 const ArgList &Args, 4051 const char *LinkingOutput) const { 4052 ArgStringList CmdArgs; 4053 4054 // When building 32-bit code on NetBSD/amd64, we have to explicitly 4055 // instruct as in the base system to assemble 32-bit code. 4056 if (ToolTriple.getArch() == llvm::Triple::x86_64 && 4057 getToolChain().getArch() == llvm::Triple::x86) 4058 CmdArgs.push_back("--32"); 4059 4060 4061 // Set byte order explicitly 4062 if (getToolChain().getArchName() == "mips") 4063 CmdArgs.push_back("-EB"); 4064 else if (getToolChain().getArchName() == "mipsel") 4065 CmdArgs.push_back("-EL"); 4066 4067 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, 4068 options::OPT_Xassembler); 4069 4070 CmdArgs.push_back("-o"); 4071 CmdArgs.push_back(Output.getFilename()); 4072 4073 for (InputInfoList::const_iterator 4074 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 4075 const InputInfo &II = *it; 4076 CmdArgs.push_back(II.getFilename()); 4077 } 4078 4079 const char *Exec = Args.MakeArgString((getToolChain().GetProgramPath("as"))); 4080 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 4081} 4082 4083void netbsd::Link::ConstructJob(Compilation &C, const JobAction &JA, 4084 const InputInfo &Output, 4085 const InputInfoList &Inputs, 4086 const ArgList &Args, 4087 const char *LinkingOutput) const { 4088 const Driver &D = getToolChain().getDriver(); 4089 ArgStringList CmdArgs; 4090 4091 if (!D.SysRoot.empty()) 4092 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot)); 4093 4094 if (Args.hasArg(options::OPT_static)) { 4095 CmdArgs.push_back("-Bstatic"); 4096 } else { 4097 if (Args.hasArg(options::OPT_rdynamic)) 4098 CmdArgs.push_back("-export-dynamic"); 4099 CmdArgs.push_back("--eh-frame-hdr"); 4100 if (Args.hasArg(options::OPT_shared)) { 4101 CmdArgs.push_back("-Bshareable"); 4102 } else { 4103 CmdArgs.push_back("-dynamic-linker"); 4104 CmdArgs.push_back("/libexec/ld.elf_so"); 4105 } 4106 } 4107 4108 // When building 32-bit code on NetBSD/amd64, we have to explicitly 4109 // instruct ld in the base system to link 32-bit code. 4110 if (ToolTriple.getArch() == llvm::Triple::x86_64 && 4111 getToolChain().getArch() == llvm::Triple::x86) { 4112 CmdArgs.push_back("-m"); 4113 CmdArgs.push_back("elf_i386"); 4114 } 4115 4116 if (Output.isFilename()) { 4117 CmdArgs.push_back("-o"); 4118 CmdArgs.push_back(Output.getFilename()); 4119 } else { 4120 assert(Output.isNothing() && "Invalid output."); 4121 } 4122 4123 if (!Args.hasArg(options::OPT_nostdlib) && 4124 !Args.hasArg(options::OPT_nostartfiles)) { 4125 if (!Args.hasArg(options::OPT_shared)) { 4126 CmdArgs.push_back(Args.MakeArgString( 4127 getToolChain().GetFilePath("crt0.o"))); 4128 CmdArgs.push_back(Args.MakeArgString( 4129 getToolChain().GetFilePath("crti.o"))); 4130 CmdArgs.push_back(Args.MakeArgString( 4131 getToolChain().GetFilePath("crtbegin.o"))); 4132 } else { 4133 CmdArgs.push_back(Args.MakeArgString( 4134 getToolChain().GetFilePath("crti.o"))); 4135 CmdArgs.push_back(Args.MakeArgString( 4136 getToolChain().GetFilePath("crtbeginS.o"))); 4137 } 4138 } 4139 4140 Args.AddAllArgs(CmdArgs, options::OPT_L); 4141 Args.AddAllArgs(CmdArgs, options::OPT_T_Group); 4142 Args.AddAllArgs(CmdArgs, options::OPT_e); 4143 Args.AddAllArgs(CmdArgs, options::OPT_s); 4144 Args.AddAllArgs(CmdArgs, options::OPT_t); 4145 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag); 4146 Args.AddAllArgs(CmdArgs, options::OPT_r); 4147 4148 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs); 4149 4150 if (!Args.hasArg(options::OPT_nostdlib) && 4151 !Args.hasArg(options::OPT_nodefaultlibs)) { 4152 if (D.CCCIsCXX) { 4153 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs); 4154 CmdArgs.push_back("-lm"); 4155 } 4156 // FIXME: For some reason GCC passes -lgcc and -lgcc_s before adding 4157 // the default system libraries. Just mimic this for now. 4158 if (Args.hasArg(options::OPT_static)) { 4159 CmdArgs.push_back("-lgcc_eh"); 4160 } else { 4161 CmdArgs.push_back("--as-needed"); 4162 CmdArgs.push_back("-lgcc_s"); 4163 CmdArgs.push_back("--no-as-needed"); 4164 } 4165 CmdArgs.push_back("-lgcc"); 4166 4167 if (Args.hasArg(options::OPT_pthread)) 4168 CmdArgs.push_back("-lpthread"); 4169 CmdArgs.push_back("-lc"); 4170 4171 CmdArgs.push_back("-lgcc"); 4172 if (Args.hasArg(options::OPT_static)) { 4173 CmdArgs.push_back("-lgcc_eh"); 4174 } else { 4175 CmdArgs.push_back("--as-needed"); 4176 CmdArgs.push_back("-lgcc_s"); 4177 CmdArgs.push_back("--no-as-needed"); 4178 } 4179 } 4180 4181 if (!Args.hasArg(options::OPT_nostdlib) && 4182 !Args.hasArg(options::OPT_nostartfiles)) { 4183 if (!Args.hasArg(options::OPT_shared)) 4184 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath( 4185 "crtend.o"))); 4186 else 4187 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath( 4188 "crtendS.o"))); 4189 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath( 4190 "crtn.o"))); 4191 } 4192 4193 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple()); 4194 4195 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("ld")); 4196 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 4197} 4198 4199void linuxtools::Assemble::ConstructJob(Compilation &C, const JobAction &JA, 4200 const InputInfo &Output, 4201 const InputInfoList &Inputs, 4202 const ArgList &Args, 4203 const char *LinkingOutput) const { 4204 ArgStringList CmdArgs; 4205 4206 // Add --32/--64 to make sure we get the format we want. 4207 // This is incomplete 4208 if (getToolChain().getArch() == llvm::Triple::x86) { 4209 CmdArgs.push_back("--32"); 4210 } else if (getToolChain().getArch() == llvm::Triple::x86_64) { 4211 CmdArgs.push_back("--64"); 4212 } else if (getToolChain().getArch() == llvm::Triple::arm) { 4213 StringRef MArch = getToolChain().getArchName(); 4214 if (MArch == "armv7" || MArch == "armv7a" || MArch == "armv7-a") 4215 CmdArgs.push_back("-mfpu=neon"); 4216 } 4217 4218 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, 4219 options::OPT_Xassembler); 4220 4221 CmdArgs.push_back("-o"); 4222 CmdArgs.push_back(Output.getFilename()); 4223 4224 for (InputInfoList::const_iterator 4225 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 4226 const InputInfo &II = *it; 4227 CmdArgs.push_back(II.getFilename()); 4228 } 4229 4230 const char *Exec = 4231 Args.MakeArgString(getToolChain().GetProgramPath("as")); 4232 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 4233} 4234 4235void linuxtools::Link::ConstructJob(Compilation &C, const JobAction &JA, 4236 const InputInfo &Output, 4237 const InputInfoList &Inputs, 4238 const ArgList &Args, 4239 const char *LinkingOutput) const { 4240 const toolchains::Linux& ToolChain = 4241 static_cast<const toolchains::Linux&>(getToolChain()); 4242 const Driver &D = ToolChain.getDriver(); 4243 ArgStringList CmdArgs; 4244 4245 // Silence warning for "clang -g foo.o -o foo" 4246 Args.ClaimAllArgs(options::OPT_g_Group); 4247 // and "clang -emit-llvm foo.o -o foo" 4248 Args.ClaimAllArgs(options::OPT_emit_llvm); 4249 // and for "clang -g foo.o -o foo". Other warning options are already 4250 // handled somewhere else. 4251 Args.ClaimAllArgs(options::OPT_w); 4252 4253 if (!D.SysRoot.empty()) 4254 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot)); 4255 4256 if (Args.hasArg(options::OPT_pie)) 4257 CmdArgs.push_back("-pie"); 4258 4259 if (Args.hasArg(options::OPT_rdynamic)) 4260 CmdArgs.push_back("-export-dynamic"); 4261 4262 if (Args.hasArg(options::OPT_s)) 4263 CmdArgs.push_back("-s"); 4264 4265 for (std::vector<std::string>::const_iterator i = ToolChain.ExtraOpts.begin(), 4266 e = ToolChain.ExtraOpts.end(); 4267 i != e; ++i) 4268 CmdArgs.push_back(i->c_str()); 4269 4270 if (!Args.hasArg(options::OPT_static)) { 4271 CmdArgs.push_back("--eh-frame-hdr"); 4272 } 4273 4274 CmdArgs.push_back("-m"); 4275 if (ToolChain.getArch() == llvm::Triple::x86) 4276 CmdArgs.push_back("elf_i386"); 4277 else if (ToolChain.getArch() == llvm::Triple::arm 4278 || ToolChain.getArch() == llvm::Triple::thumb) 4279 CmdArgs.push_back("armelf_linux_eabi"); 4280 else if (ToolChain.getArch() == llvm::Triple::ppc) 4281 CmdArgs.push_back("elf32ppclinux"); 4282 else if (ToolChain.getArch() == llvm::Triple::ppc64) 4283 CmdArgs.push_back("elf64ppc"); 4284 else 4285 CmdArgs.push_back("elf_x86_64"); 4286 4287 if (Args.hasArg(options::OPT_static)) { 4288 if (ToolChain.getArch() == llvm::Triple::arm 4289 || ToolChain.getArch() == llvm::Triple::thumb) 4290 CmdArgs.push_back("-Bstatic"); 4291 else 4292 CmdArgs.push_back("-static"); 4293 } else if (Args.hasArg(options::OPT_shared)) { 4294 CmdArgs.push_back("-shared"); 4295 } 4296 4297 if (ToolChain.getArch() == llvm::Triple::arm || 4298 ToolChain.getArch() == llvm::Triple::thumb || 4299 (!Args.hasArg(options::OPT_static) && 4300 !Args.hasArg(options::OPT_shared))) { 4301 CmdArgs.push_back("-dynamic-linker"); 4302 if (ToolChain.getArch() == llvm::Triple::x86) 4303 CmdArgs.push_back("/lib/ld-linux.so.2"); 4304 else if (ToolChain.getArch() == llvm::Triple::arm || 4305 ToolChain.getArch() == llvm::Triple::thumb) 4306 CmdArgs.push_back("/lib/ld-linux.so.3"); 4307 else if (ToolChain.getArch() == llvm::Triple::ppc) 4308 CmdArgs.push_back("/lib/ld.so.1"); 4309 else if (ToolChain.getArch() == llvm::Triple::ppc64) 4310 CmdArgs.push_back("/lib64/ld64.so.1"); 4311 else 4312 CmdArgs.push_back("/lib64/ld-linux-x86-64.so.2"); 4313 } 4314 4315 CmdArgs.push_back("-o"); 4316 CmdArgs.push_back(Output.getFilename()); 4317 4318 if (!Args.hasArg(options::OPT_nostdlib) && 4319 !Args.hasArg(options::OPT_nostartfiles)) { 4320 const char *crt1 = NULL; 4321 if (!Args.hasArg(options::OPT_shared)){ 4322 if (Args.hasArg(options::OPT_pie)) 4323 crt1 = "Scrt1.o"; 4324 else 4325 crt1 = "crt1.o"; 4326 } 4327 if (crt1) 4328 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1))); 4329 4330 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o"))); 4331 4332 const char *crtbegin; 4333 if (Args.hasArg(options::OPT_static)) 4334 crtbegin = "crtbeginT.o"; 4335 else if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie)) 4336 crtbegin = "crtbeginS.o"; 4337 else 4338 crtbegin = "crtbegin.o"; 4339 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin))); 4340 } 4341 4342 Args.AddAllArgs(CmdArgs, options::OPT_L); 4343 4344 const ToolChain::path_list Paths = ToolChain.getFilePaths(); 4345 4346 for (ToolChain::path_list::const_iterator i = Paths.begin(), e = Paths.end(); 4347 i != e; ++i) 4348 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + *i)); 4349 4350 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs); 4351 4352 if (D.CCCIsCXX && !Args.hasArg(options::OPT_nostdlib)) { 4353 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs); 4354 CmdArgs.push_back("-lm"); 4355 } 4356 4357 if (!Args.hasArg(options::OPT_nostdlib)) { 4358 if (Args.hasArg(options::OPT_static)) 4359 CmdArgs.push_back("--start-group"); 4360 4361 if (!D.CCCIsCXX) 4362 CmdArgs.push_back("-lgcc"); 4363 4364 if (Args.hasArg(options::OPT_static)) { 4365 if (D.CCCIsCXX) 4366 CmdArgs.push_back("-lgcc"); 4367 } else { 4368 if (!D.CCCIsCXX) 4369 CmdArgs.push_back("--as-needed"); 4370 CmdArgs.push_back("-lgcc_s"); 4371 if (!D.CCCIsCXX) 4372 CmdArgs.push_back("--no-as-needed"); 4373 } 4374 4375 if (Args.hasArg(options::OPT_static)) 4376 CmdArgs.push_back("-lgcc_eh"); 4377 else if (!Args.hasArg(options::OPT_shared) && D.CCCIsCXX) 4378 CmdArgs.push_back("-lgcc"); 4379 4380 if (Args.hasArg(options::OPT_pthread) || 4381 Args.hasArg(options::OPT_pthreads)) 4382 CmdArgs.push_back("-lpthread"); 4383 4384 CmdArgs.push_back("-lc"); 4385 4386 if (Args.hasArg(options::OPT_static)) 4387 CmdArgs.push_back("--end-group"); 4388 else { 4389 if (!D.CCCIsCXX) 4390 CmdArgs.push_back("-lgcc"); 4391 4392 if (!D.CCCIsCXX) 4393 CmdArgs.push_back("--as-needed"); 4394 CmdArgs.push_back("-lgcc_s"); 4395 if (!D.CCCIsCXX) 4396 CmdArgs.push_back("--no-as-needed"); 4397 4398 if (!Args.hasArg(options::OPT_shared) && D.CCCIsCXX) 4399 CmdArgs.push_back("-lgcc"); 4400 } 4401 4402 4403 if (!Args.hasArg(options::OPT_nostartfiles)) { 4404 const char *crtend; 4405 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie)) 4406 crtend = "crtendS.o"; 4407 else 4408 crtend = "crtend.o"; 4409 4410 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtend))); 4411 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o"))); 4412 } 4413 } 4414 4415 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple()); 4416 4417 if (Args.hasArg(options::OPT_use_gold_plugin)) { 4418 CmdArgs.push_back("-plugin"); 4419 std::string Plugin = ToolChain.getDriver().Dir + "/../lib/LLVMgold.so"; 4420 CmdArgs.push_back(Args.MakeArgString(Plugin)); 4421 } 4422 4423 C.addCommand(new Command(JA, *this, ToolChain.Linker.c_str(), CmdArgs)); 4424} 4425 4426void minix::Assemble::ConstructJob(Compilation &C, const JobAction &JA, 4427 const InputInfo &Output, 4428 const InputInfoList &Inputs, 4429 const ArgList &Args, 4430 const char *LinkingOutput) const { 4431 ArgStringList CmdArgs; 4432 4433 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, 4434 options::OPT_Xassembler); 4435 4436 CmdArgs.push_back("-o"); 4437 CmdArgs.push_back(Output.getFilename()); 4438 4439 for (InputInfoList::const_iterator 4440 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 4441 const InputInfo &II = *it; 4442 CmdArgs.push_back(II.getFilename()); 4443 } 4444 4445 const char *Exec = 4446 Args.MakeArgString(getToolChain().GetProgramPath("gas")); 4447 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 4448} 4449 4450void minix::Link::ConstructJob(Compilation &C, const JobAction &JA, 4451 const InputInfo &Output, 4452 const InputInfoList &Inputs, 4453 const ArgList &Args, 4454 const char *LinkingOutput) const { 4455 const Driver &D = getToolChain().getDriver(); 4456 ArgStringList CmdArgs; 4457 4458 if (Output.isFilename()) { 4459 CmdArgs.push_back("-o"); 4460 CmdArgs.push_back(Output.getFilename()); 4461 } else { 4462 assert(Output.isNothing() && "Invalid output."); 4463 } 4464 4465 if (!Args.hasArg(options::OPT_nostdlib) && 4466 !Args.hasArg(options::OPT_nostartfiles)) 4467 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath( 4468 "/usr/gnu/lib/crtso.o"))); 4469 4470 Args.AddAllArgs(CmdArgs, options::OPT_L); 4471 Args.AddAllArgs(CmdArgs, options::OPT_T_Group); 4472 Args.AddAllArgs(CmdArgs, options::OPT_e); 4473 4474 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs); 4475 4476 if (!Args.hasArg(options::OPT_nostdlib) && 4477 !Args.hasArg(options::OPT_nodefaultlibs)) { 4478 if (D.CCCIsCXX) { 4479 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs); 4480 CmdArgs.push_back("-lm"); 4481 } 4482 4483 if (Args.hasArg(options::OPT_pthread)) 4484 CmdArgs.push_back("-lpthread"); 4485 CmdArgs.push_back("-lc"); 4486 CmdArgs.push_back("-lgcc"); 4487 CmdArgs.push_back("-L/usr/gnu/lib"); 4488 // FIXME: fill in the correct search path for the final 4489 // support libraries. 4490 CmdArgs.push_back("-L/usr/gnu/lib/gcc/i686-pc-minix/4.4.3"); 4491 } 4492 4493 if (!Args.hasArg(options::OPT_nostdlib) && 4494 !Args.hasArg(options::OPT_nostartfiles)) { 4495 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath( 4496 "/usr/gnu/lib/libend.a"))); 4497 } 4498 4499 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple()); 4500 4501 const char *Exec = 4502 Args.MakeArgString(getToolChain().GetProgramPath("/usr/gnu/bin/gld")); 4503 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 4504} 4505 4506/// DragonFly Tools 4507 4508// For now, DragonFly Assemble does just about the same as for 4509// FreeBSD, but this may change soon. 4510void dragonfly::Assemble::ConstructJob(Compilation &C, const JobAction &JA, 4511 const InputInfo &Output, 4512 const InputInfoList &Inputs, 4513 const ArgList &Args, 4514 const char *LinkingOutput) const { 4515 ArgStringList CmdArgs; 4516 4517 // When building 32-bit code on DragonFly/pc64, we have to explicitly 4518 // instruct as in the base system to assemble 32-bit code. 4519 if (getToolChain().getArchName() == "i386") 4520 CmdArgs.push_back("--32"); 4521 4522 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, 4523 options::OPT_Xassembler); 4524 4525 CmdArgs.push_back("-o"); 4526 CmdArgs.push_back(Output.getFilename()); 4527 4528 for (InputInfoList::const_iterator 4529 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 4530 const InputInfo &II = *it; 4531 CmdArgs.push_back(II.getFilename()); 4532 } 4533 4534 const char *Exec = 4535 Args.MakeArgString(getToolChain().GetProgramPath("as")); 4536 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 4537} 4538 4539void dragonfly::Link::ConstructJob(Compilation &C, const JobAction &JA, 4540 const InputInfo &Output, 4541 const InputInfoList &Inputs, 4542 const ArgList &Args, 4543 const char *LinkingOutput) const { 4544 const Driver &D = getToolChain().getDriver(); 4545 ArgStringList CmdArgs; 4546 4547 if (!D.SysRoot.empty()) 4548 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot)); 4549 4550 if (Args.hasArg(options::OPT_static)) { 4551 CmdArgs.push_back("-Bstatic"); 4552 } else { 4553 if (Args.hasArg(options::OPT_shared)) 4554 CmdArgs.push_back("-Bshareable"); 4555 else { 4556 CmdArgs.push_back("-dynamic-linker"); 4557 CmdArgs.push_back("/usr/libexec/ld-elf.so.2"); 4558 } 4559 } 4560 4561 // When building 32-bit code on DragonFly/pc64, we have to explicitly 4562 // instruct ld in the base system to link 32-bit code. 4563 if (getToolChain().getArchName() == "i386") { 4564 CmdArgs.push_back("-m"); 4565 CmdArgs.push_back("elf_i386"); 4566 } 4567 4568 if (Output.isFilename()) { 4569 CmdArgs.push_back("-o"); 4570 CmdArgs.push_back(Output.getFilename()); 4571 } else { 4572 assert(Output.isNothing() && "Invalid output."); 4573 } 4574 4575 if (!Args.hasArg(options::OPT_nostdlib) && 4576 !Args.hasArg(options::OPT_nostartfiles)) { 4577 if (!Args.hasArg(options::OPT_shared)) { 4578 CmdArgs.push_back( 4579 Args.MakeArgString(getToolChain().GetFilePath("crt1.o"))); 4580 CmdArgs.push_back( 4581 Args.MakeArgString(getToolChain().GetFilePath("crti.o"))); 4582 CmdArgs.push_back( 4583 Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o"))); 4584 } else { 4585 CmdArgs.push_back( 4586 Args.MakeArgString(getToolChain().GetFilePath("crti.o"))); 4587 CmdArgs.push_back( 4588 Args.MakeArgString(getToolChain().GetFilePath("crtbeginS.o"))); 4589 } 4590 } 4591 4592 Args.AddAllArgs(CmdArgs, options::OPT_L); 4593 Args.AddAllArgs(CmdArgs, options::OPT_T_Group); 4594 Args.AddAllArgs(CmdArgs, options::OPT_e); 4595 4596 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs); 4597 4598 if (!Args.hasArg(options::OPT_nostdlib) && 4599 !Args.hasArg(options::OPT_nodefaultlibs)) { 4600 // FIXME: GCC passes on -lgcc, -lgcc_pic and a whole lot of 4601 // rpaths 4602 CmdArgs.push_back("-L/usr/lib/gcc41"); 4603 4604 if (!Args.hasArg(options::OPT_static)) { 4605 CmdArgs.push_back("-rpath"); 4606 CmdArgs.push_back("/usr/lib/gcc41"); 4607 4608 CmdArgs.push_back("-rpath-link"); 4609 CmdArgs.push_back("/usr/lib/gcc41"); 4610 4611 CmdArgs.push_back("-rpath"); 4612 CmdArgs.push_back("/usr/lib"); 4613 4614 CmdArgs.push_back("-rpath-link"); 4615 CmdArgs.push_back("/usr/lib"); 4616 } 4617 4618 if (D.CCCIsCXX) { 4619 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs); 4620 CmdArgs.push_back("-lm"); 4621 } 4622 4623 if (Args.hasArg(options::OPT_shared)) { 4624 CmdArgs.push_back("-lgcc_pic"); 4625 } else { 4626 CmdArgs.push_back("-lgcc"); 4627 } 4628 4629 4630 if (Args.hasArg(options::OPT_pthread)) 4631 CmdArgs.push_back("-lpthread"); 4632 4633 if (!Args.hasArg(options::OPT_nolibc)) { 4634 CmdArgs.push_back("-lc"); 4635 } 4636 4637 if (Args.hasArg(options::OPT_shared)) { 4638 CmdArgs.push_back("-lgcc_pic"); 4639 } else { 4640 CmdArgs.push_back("-lgcc"); 4641 } 4642 } 4643 4644 if (!Args.hasArg(options::OPT_nostdlib) && 4645 !Args.hasArg(options::OPT_nostartfiles)) { 4646 if (!Args.hasArg(options::OPT_shared)) 4647 CmdArgs.push_back(Args.MakeArgString( 4648 getToolChain().GetFilePath("crtend.o"))); 4649 else 4650 CmdArgs.push_back(Args.MakeArgString( 4651 getToolChain().GetFilePath("crtendS.o"))); 4652 CmdArgs.push_back(Args.MakeArgString( 4653 getToolChain().GetFilePath("crtn.o"))); 4654 } 4655 4656 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple()); 4657 4658 const char *Exec = 4659 Args.MakeArgString(getToolChain().GetProgramPath("ld")); 4660 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 4661} 4662 4663void visualstudio::Link::ConstructJob(Compilation &C, const JobAction &JA, 4664 const InputInfo &Output, 4665 const InputInfoList &Inputs, 4666 const ArgList &Args, 4667 const char *LinkingOutput) const { 4668 ArgStringList CmdArgs; 4669 4670 if (Output.isFilename()) { 4671 CmdArgs.push_back(Args.MakeArgString(std::string("-out:") + 4672 Output.getFilename())); 4673 } else { 4674 assert(Output.isNothing() && "Invalid output."); 4675 } 4676 4677 if (!Args.hasArg(options::OPT_nostdlib) && 4678 !Args.hasArg(options::OPT_nostartfiles)) { 4679 CmdArgs.push_back("-defaultlib:libcmt"); 4680 } 4681 4682 CmdArgs.push_back("-nologo"); 4683 4684 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs); 4685 4686 const char *Exec = 4687 Args.MakeArgString(getToolChain().GetProgramPath("link.exe")); 4688 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 4689} 4690