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