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