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