Tools.cpp revision 263763
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#include "InputInfo.h" 12#include "ToolChains.h" 13#include "clang/Basic/ObjCRuntime.h" 14#include "clang/Basic/Version.h" 15#include "clang/Driver/Action.h" 16#include "clang/Driver/Compilation.h" 17#include "clang/Driver/Driver.h" 18#include "clang/Driver/DriverDiagnostic.h" 19#include "clang/Driver/Job.h" 20#include "clang/Driver/Options.h" 21#include "clang/Driver/SanitizerArgs.h" 22#include "clang/Driver/ToolChain.h" 23#include "clang/Driver/Util.h" 24#include "clang/Sema/SemaDiagnostic.h" 25#include "llvm/ADT/SmallString.h" 26#include "llvm/ADT/StringExtras.h" 27#include "llvm/ADT/StringSwitch.h" 28#include "llvm/ADT/Twine.h" 29#include "llvm/Option/Arg.h" 30#include "llvm/Option/ArgList.h" 31#include "llvm/Option/Option.h" 32#include "llvm/Support/ErrorHandling.h" 33#include "llvm/Support/FileSystem.h" 34#include "llvm/Support/Format.h" 35#include "llvm/Support/Host.h" 36#include "llvm/Support/Path.h" 37#include "llvm/Support/Program.h" 38#include "llvm/Support/Process.h" 39#include "llvm/Support/raw_ostream.h" 40#include <sys/stat.h> 41 42using namespace clang::driver; 43using namespace clang::driver::tools; 44using namespace clang; 45using namespace llvm::opt; 46 47/// CheckPreprocessingOptions - Perform some validation of preprocessing 48/// arguments that is shared with gcc. 49static void CheckPreprocessingOptions(const Driver &D, const ArgList &Args) { 50 if (Arg *A = Args.getLastArg(options::OPT_C, options::OPT_CC)) 51 if (!Args.hasArg(options::OPT_E) && !D.CCCIsCPP()) 52 D.Diag(diag::err_drv_argument_only_allowed_with) 53 << A->getAsString(Args) << "-E"; 54} 55 56/// CheckCodeGenerationOptions - Perform some validation of code generation 57/// arguments that is shared with gcc. 58static void CheckCodeGenerationOptions(const Driver &D, const ArgList &Args) { 59 // In gcc, only ARM checks this, but it seems reasonable to check universally. 60 if (Args.hasArg(options::OPT_static)) 61 if (const Arg *A = Args.getLastArg(options::OPT_dynamic, 62 options::OPT_mdynamic_no_pic)) 63 D.Diag(diag::err_drv_argument_not_allowed_with) 64 << A->getAsString(Args) << "-static"; 65} 66 67// Quote target names for inclusion in GNU Make dependency files. 68// Only the characters '$', '#', ' ', '\t' are quoted. 69static void QuoteTarget(StringRef Target, 70 SmallVectorImpl<char> &Res) { 71 for (unsigned i = 0, e = Target.size(); i != e; ++i) { 72 switch (Target[i]) { 73 case ' ': 74 case '\t': 75 // Escape the preceding backslashes 76 for (int j = i - 1; j >= 0 && Target[j] == '\\'; --j) 77 Res.push_back('\\'); 78 79 // Escape the space/tab 80 Res.push_back('\\'); 81 break; 82 case '$': 83 Res.push_back('$'); 84 break; 85 case '#': 86 Res.push_back('\\'); 87 break; 88 default: 89 break; 90 } 91 92 Res.push_back(Target[i]); 93 } 94} 95 96static void addDirectoryList(const ArgList &Args, 97 ArgStringList &CmdArgs, 98 const char *ArgName, 99 const char *EnvVar) { 100 const char *DirList = ::getenv(EnvVar); 101 bool CombinedArg = false; 102 103 if (!DirList) 104 return; // Nothing to do. 105 106 StringRef Name(ArgName); 107 if (Name.equals("-I") || Name.equals("-L")) 108 CombinedArg = true; 109 110 StringRef Dirs(DirList); 111 if (Dirs.empty()) // Empty string should not add '.'. 112 return; 113 114 StringRef::size_type Delim; 115 while ((Delim = Dirs.find(llvm::sys::EnvPathSeparator)) != StringRef::npos) { 116 if (Delim == 0) { // Leading colon. 117 if (CombinedArg) { 118 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + ".")); 119 } else { 120 CmdArgs.push_back(ArgName); 121 CmdArgs.push_back("."); 122 } 123 } else { 124 if (CombinedArg) { 125 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + Dirs.substr(0, Delim))); 126 } else { 127 CmdArgs.push_back(ArgName); 128 CmdArgs.push_back(Args.MakeArgString(Dirs.substr(0, Delim))); 129 } 130 } 131 Dirs = Dirs.substr(Delim + 1); 132 } 133 134 if (Dirs.empty()) { // Trailing colon. 135 if (CombinedArg) { 136 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + ".")); 137 } else { 138 CmdArgs.push_back(ArgName); 139 CmdArgs.push_back("."); 140 } 141 } else { // Add the last path. 142 if (CombinedArg) { 143 CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + Dirs)); 144 } else { 145 CmdArgs.push_back(ArgName); 146 CmdArgs.push_back(Args.MakeArgString(Dirs)); 147 } 148 } 149} 150 151static void AddLinkerInputs(const ToolChain &TC, 152 const InputInfoList &Inputs, const ArgList &Args, 153 ArgStringList &CmdArgs) { 154 const Driver &D = TC.getDriver(); 155 156 // Add extra linker input arguments which are not treated as inputs 157 // (constructed via -Xarch_). 158 Args.AddAllArgValues(CmdArgs, options::OPT_Zlinker_input); 159 160 for (InputInfoList::const_iterator 161 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 162 const InputInfo &II = *it; 163 164 if (!TC.HasNativeLLVMSupport()) { 165 // Don't try to pass LLVM inputs unless we have native support. 166 if (II.getType() == types::TY_LLVM_IR || 167 II.getType() == types::TY_LTO_IR || 168 II.getType() == types::TY_LLVM_BC || 169 II.getType() == types::TY_LTO_BC) 170 D.Diag(diag::err_drv_no_linker_llvm_support) 171 << TC.getTripleString(); 172 } 173 174 // Add filenames immediately. 175 if (II.isFilename()) { 176 CmdArgs.push_back(II.getFilename()); 177 continue; 178 } 179 180 // Otherwise, this is a linker input argument. 181 const Arg &A = II.getInputArg(); 182 183 // Handle reserved library options. 184 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) { 185 TC.AddCXXStdlibLibArgs(Args, CmdArgs); 186 } else if (A.getOption().matches(options::OPT_Z_reserved_lib_cckext)) { 187 TC.AddCCKextLibArgs(Args, CmdArgs); 188 } else 189 A.renderAsInput(Args, CmdArgs); 190 } 191 192 // LIBRARY_PATH - included following the user specified library paths. 193 addDirectoryList(Args, CmdArgs, "-L", "LIBRARY_PATH"); 194} 195 196/// \brief Determine whether Objective-C automated reference counting is 197/// enabled. 198static bool isObjCAutoRefCount(const ArgList &Args) { 199 return Args.hasFlag(options::OPT_fobjc_arc, options::OPT_fno_objc_arc, false); 200} 201 202/// \brief Determine whether we are linking the ObjC runtime. 203static bool isObjCRuntimeLinked(const ArgList &Args) { 204 if (isObjCAutoRefCount(Args)) { 205 Args.ClaimAllArgs(options::OPT_fobjc_link_runtime); 206 return true; 207 } 208 return Args.hasArg(options::OPT_fobjc_link_runtime); 209} 210 211static void addProfileRT(const ToolChain &TC, const ArgList &Args, 212 ArgStringList &CmdArgs, 213 llvm::Triple Triple) { 214 if (!(Args.hasArg(options::OPT_fprofile_arcs) || 215 Args.hasArg(options::OPT_fprofile_generate) || 216 Args.hasArg(options::OPT_fcreate_profile) || 217 Args.hasArg(options::OPT_coverage))) 218 return; 219 220 // GCC links libgcov.a by adding -L<inst>/gcc/lib/gcc/<triple>/<ver> -lgcov to 221 // the link line. We cannot do the same thing because unlike gcov there is a 222 // libprofile_rt.so. We used to use the -l:libprofile_rt.a syntax, but that is 223 // not supported by old linkers. 224 std::string ProfileRT = 225 std::string(TC.getDriver().Dir) + "/../lib/libprofile_rt.a"; 226 227 CmdArgs.push_back(Args.MakeArgString(ProfileRT)); 228} 229 230static bool forwardToGCC(const Option &O) { 231 // Don't forward inputs from the original command line. They are added from 232 // InputInfoList. 233 return O.getKind() != Option::InputClass && 234 !O.hasFlag(options::DriverOption) && 235 !O.hasFlag(options::LinkerInput); 236} 237 238void Clang::AddPreprocessingOptions(Compilation &C, 239 const JobAction &JA, 240 const Driver &D, 241 const ArgList &Args, 242 ArgStringList &CmdArgs, 243 const InputInfo &Output, 244 const InputInfoList &Inputs) const { 245 Arg *A; 246 247 CheckPreprocessingOptions(D, Args); 248 249 Args.AddLastArg(CmdArgs, options::OPT_C); 250 Args.AddLastArg(CmdArgs, options::OPT_CC); 251 252 // Handle dependency file generation. 253 if ((A = Args.getLastArg(options::OPT_M, options::OPT_MM)) || 254 (A = Args.getLastArg(options::OPT_MD)) || 255 (A = Args.getLastArg(options::OPT_MMD))) { 256 // Determine the output location. 257 const char *DepFile; 258 if (Arg *MF = Args.getLastArg(options::OPT_MF)) { 259 DepFile = MF->getValue(); 260 C.addFailureResultFile(DepFile, &JA); 261 } else if (Output.getType() == types::TY_Dependencies) { 262 DepFile = Output.getFilename(); 263 } else if (A->getOption().matches(options::OPT_M) || 264 A->getOption().matches(options::OPT_MM)) { 265 DepFile = "-"; 266 } else { 267 DepFile = getDependencyFileName(Args, Inputs); 268 C.addFailureResultFile(DepFile, &JA); 269 } 270 CmdArgs.push_back("-dependency-file"); 271 CmdArgs.push_back(DepFile); 272 273 // Add a default target if one wasn't specified. 274 if (!Args.hasArg(options::OPT_MT) && !Args.hasArg(options::OPT_MQ)) { 275 const char *DepTarget; 276 277 // If user provided -o, that is the dependency target, except 278 // when we are only generating a dependency file. 279 Arg *OutputOpt = Args.getLastArg(options::OPT_o); 280 if (OutputOpt && Output.getType() != types::TY_Dependencies) { 281 DepTarget = OutputOpt->getValue(); 282 } else { 283 // Otherwise derive from the base input. 284 // 285 // FIXME: This should use the computed output file location. 286 SmallString<128> P(Inputs[0].getBaseInput()); 287 llvm::sys::path::replace_extension(P, "o"); 288 DepTarget = Args.MakeArgString(llvm::sys::path::filename(P)); 289 } 290 291 CmdArgs.push_back("-MT"); 292 SmallString<128> Quoted; 293 QuoteTarget(DepTarget, Quoted); 294 CmdArgs.push_back(Args.MakeArgString(Quoted)); 295 } 296 297 if (A->getOption().matches(options::OPT_M) || 298 A->getOption().matches(options::OPT_MD)) 299 CmdArgs.push_back("-sys-header-deps"); 300 } 301 302 if (Args.hasArg(options::OPT_MG)) { 303 if (!A || A->getOption().matches(options::OPT_MD) || 304 A->getOption().matches(options::OPT_MMD)) 305 D.Diag(diag::err_drv_mg_requires_m_or_mm); 306 CmdArgs.push_back("-MG"); 307 } 308 309 Args.AddLastArg(CmdArgs, options::OPT_MP); 310 311 // Convert all -MQ <target> args to -MT <quoted target> 312 for (arg_iterator it = Args.filtered_begin(options::OPT_MT, 313 options::OPT_MQ), 314 ie = Args.filtered_end(); it != ie; ++it) { 315 const Arg *A = *it; 316 A->claim(); 317 318 if (A->getOption().matches(options::OPT_MQ)) { 319 CmdArgs.push_back("-MT"); 320 SmallString<128> Quoted; 321 QuoteTarget(A->getValue(), Quoted); 322 CmdArgs.push_back(Args.MakeArgString(Quoted)); 323 324 // -MT flag - no change 325 } else { 326 A->render(Args, CmdArgs); 327 } 328 } 329 330 // Add -i* options, and automatically translate to 331 // -include-pch/-include-pth for transparent PCH support. It's 332 // wonky, but we include looking for .gch so we can support seamless 333 // replacement into a build system already set up to be generating 334 // .gch files. 335 bool RenderedImplicitInclude = false; 336 for (arg_iterator it = Args.filtered_begin(options::OPT_clang_i_Group), 337 ie = Args.filtered_end(); it != ie; ++it) { 338 const Arg *A = it; 339 340 if (A->getOption().matches(options::OPT_include)) { 341 bool IsFirstImplicitInclude = !RenderedImplicitInclude; 342 RenderedImplicitInclude = true; 343 344 // Use PCH if the user requested it. 345 bool UsePCH = D.CCCUsePCH; 346 347 bool FoundPTH = false; 348 bool FoundPCH = false; 349 SmallString<128> P(A->getValue()); 350 // We want the files to have a name like foo.h.pch. Add a dummy extension 351 // so that replace_extension does the right thing. 352 P += ".dummy"; 353 if (UsePCH) { 354 llvm::sys::path::replace_extension(P, "pch"); 355 if (llvm::sys::fs::exists(P.str())) 356 FoundPCH = true; 357 } 358 359 if (!FoundPCH) { 360 llvm::sys::path::replace_extension(P, "pth"); 361 if (llvm::sys::fs::exists(P.str())) 362 FoundPTH = true; 363 } 364 365 if (!FoundPCH && !FoundPTH) { 366 llvm::sys::path::replace_extension(P, "gch"); 367 if (llvm::sys::fs::exists(P.str())) { 368 FoundPCH = UsePCH; 369 FoundPTH = !UsePCH; 370 } 371 } 372 373 if (FoundPCH || FoundPTH) { 374 if (IsFirstImplicitInclude) { 375 A->claim(); 376 if (UsePCH) 377 CmdArgs.push_back("-include-pch"); 378 else 379 CmdArgs.push_back("-include-pth"); 380 CmdArgs.push_back(Args.MakeArgString(P.str())); 381 continue; 382 } else { 383 // Ignore the PCH if not first on command line and emit warning. 384 D.Diag(diag::warn_drv_pch_not_first_include) 385 << P.str() << A->getAsString(Args); 386 } 387 } 388 } 389 390 // Not translated, render as usual. 391 A->claim(); 392 A->render(Args, CmdArgs); 393 } 394 395 Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U); 396 Args.AddAllArgs(CmdArgs, options::OPT_I_Group, options::OPT_F, 397 options::OPT_index_header_map); 398 399 // Add -Wp, and -Xassembler if using the preprocessor. 400 401 // FIXME: There is a very unfortunate problem here, some troubled 402 // souls abuse -Wp, to pass preprocessor options in gcc syntax. To 403 // really support that we would have to parse and then translate 404 // those options. :( 405 Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA, 406 options::OPT_Xpreprocessor); 407 408 // -I- is a deprecated GCC feature, reject it. 409 if (Arg *A = Args.getLastArg(options::OPT_I_)) 410 D.Diag(diag::err_drv_I_dash_not_supported) << A->getAsString(Args); 411 412 // If we have a --sysroot, and don't have an explicit -isysroot flag, add an 413 // -isysroot to the CC1 invocation. 414 StringRef sysroot = C.getSysRoot(); 415 if (sysroot != "") { 416 if (!Args.hasArg(options::OPT_isysroot)) { 417 CmdArgs.push_back("-isysroot"); 418 CmdArgs.push_back(C.getArgs().MakeArgString(sysroot)); 419 } 420 } 421 422 // Parse additional include paths from environment variables. 423 // FIXME: We should probably sink the logic for handling these from the 424 // frontend into the driver. It will allow deleting 4 otherwise unused flags. 425 // CPATH - included following the user specified includes (but prior to 426 // builtin and standard includes). 427 addDirectoryList(Args, CmdArgs, "-I", "CPATH"); 428 // C_INCLUDE_PATH - system includes enabled when compiling C. 429 addDirectoryList(Args, CmdArgs, "-c-isystem", "C_INCLUDE_PATH"); 430 // CPLUS_INCLUDE_PATH - system includes enabled when compiling C++. 431 addDirectoryList(Args, CmdArgs, "-cxx-isystem", "CPLUS_INCLUDE_PATH"); 432 // OBJC_INCLUDE_PATH - system includes enabled when compiling ObjC. 433 addDirectoryList(Args, CmdArgs, "-objc-isystem", "OBJC_INCLUDE_PATH"); 434 // OBJCPLUS_INCLUDE_PATH - system includes enabled when compiling ObjC++. 435 addDirectoryList(Args, CmdArgs, "-objcxx-isystem", "OBJCPLUS_INCLUDE_PATH"); 436 437 // Add C++ include arguments, if needed. 438 if (types::isCXX(Inputs[0].getType())) 439 getToolChain().AddClangCXXStdlibIncludeArgs(Args, CmdArgs); 440 441 // Add system include arguments. 442 getToolChain().AddClangSystemIncludeArgs(Args, CmdArgs); 443} 444 445/// getLLVMArchSuffixForARM - Get the LLVM arch name to use for a particular 446/// CPU. 447// 448// FIXME: This is redundant with -mcpu, why does LLVM use this. 449// FIXME: tblgen this, or kill it! 450static const char *getLLVMArchSuffixForARM(StringRef CPU) { 451 return llvm::StringSwitch<const char *>(CPU) 452 .Case("strongarm", "v4") 453 .Cases("arm7tdmi", "arm7tdmi-s", "arm710t", "v4t") 454 .Cases("arm720t", "arm9", "arm9tdmi", "v4t") 455 .Cases("arm920", "arm920t", "arm922t", "v4t") 456 .Cases("arm940t", "ep9312","v4t") 457 .Cases("arm10tdmi", "arm1020t", "v5") 458 .Cases("arm9e", "arm926ej-s", "arm946e-s", "v5e") 459 .Cases("arm966e-s", "arm968e-s", "arm10e", "v5e") 460 .Cases("arm1020e", "arm1022e", "xscale", "iwmmxt", "v5e") 461 .Cases("arm1136j-s", "arm1136jf-s", "arm1176jz-s", "v6") 462 .Cases("arm1176jzf-s", "mpcorenovfp", "mpcore", "v6") 463 .Cases("arm1156t2-s", "arm1156t2f-s", "v6t2") 464 .Cases("cortex-a5", "cortex-a7", "cortex-a8", "v7") 465 .Cases("cortex-a9", "cortex-a12", "cortex-a15", "v7") 466 .Cases("cortex-r4", "cortex-r5", "v7r") 467 .Case("cortex-m0", "v6m") 468 .Case("cortex-m3", "v7m") 469 .Case("cortex-m4", "v7em") 470 .Case("cortex-a9-mp", "v7f") 471 .Case("swift", "v7s") 472 .Cases("cortex-a53", "cortex-a57", "v8") 473 .Default(""); 474} 475 476/// getARMTargetCPU - Get the (LLVM) name of the ARM cpu we are targeting. 477// 478// FIXME: tblgen this. 479static std::string getARMTargetCPU(const ArgList &Args, 480 const llvm::Triple &Triple) { 481 // FIXME: Warn on inconsistent use of -mcpu and -march. 482 483 // If we have -mcpu=, use that. 484 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) { 485 StringRef MCPU = A->getValue(); 486 // Handle -mcpu=native. 487 if (MCPU == "native") 488 return llvm::sys::getHostCPUName(); 489 else 490 return MCPU; 491 } 492 493 StringRef MArch; 494 if (Arg *A = Args.getLastArg(options::OPT_march_EQ)) { 495 // Otherwise, if we have -march= choose the base CPU for that arch. 496 MArch = A->getValue(); 497 } else { 498 // Otherwise, use the Arch from the triple. 499 MArch = Triple.getArchName(); 500 } 501 502 if (Triple.getOS() == llvm::Triple::NetBSD) { 503 if (MArch == "armv6") 504 return "arm1176jzf-s"; 505 } 506 507 // Handle -march=native. 508 std::string NativeMArch; 509 if (MArch == "native") { 510 std::string CPU = llvm::sys::getHostCPUName(); 511 if (CPU != "generic") { 512 // Translate the native cpu into the architecture. The switch below will 513 // then chose the minimum cpu for that arch. 514 NativeMArch = std::string("arm") + getLLVMArchSuffixForARM(CPU); 515 MArch = NativeMArch; 516 } 517 } 518 519 return llvm::StringSwitch<const char *>(MArch) 520 .Cases("armv2", "armv2a","arm2") 521 .Case("armv3", "arm6") 522 .Case("armv3m", "arm7m") 523 .Case("armv4", "strongarm") 524 .Case("armv4t", "arm7tdmi") 525 .Cases("armv5", "armv5t", "arm10tdmi") 526 .Cases("armv5e", "armv5te", "arm1022e") 527 .Case("armv5tej", "arm926ej-s") 528 .Cases("armv6", "armv6k", "arm1136jf-s") 529 .Case("armv6j", "arm1136j-s") 530 .Cases("armv6z", "armv6zk", "arm1176jzf-s") 531 .Case("armv6t2", "arm1156t2-s") 532 .Cases("armv6m", "armv6-m", "cortex-m0") 533 .Cases("armv7", "armv7a", "armv7-a", "cortex-a8") 534 .Cases("armv7em", "armv7e-m", "cortex-m4") 535 .Cases("armv7f", "armv7-f", "cortex-a9-mp") 536 .Cases("armv7s", "armv7-s", "swift") 537 .Cases("armv7r", "armv7-r", "cortex-r4") 538 .Cases("armv7m", "armv7-m", "cortex-m3") 539 .Cases("armv8", "armv8a", "armv8-a", "cortex-a53") 540 .Case("ep9312", "ep9312") 541 .Case("iwmmxt", "iwmmxt") 542 .Case("xscale", "xscale") 543 // If all else failed, return the most base CPU with thumb interworking 544 // supported by LLVM. 545 .Default("arm7tdmi"); 546} 547 548/// getAArch64TargetCPU - Get the (LLVM) name of the AArch64 cpu we are targeting. 549// 550// FIXME: tblgen this. 551static std::string getAArch64TargetCPU(const ArgList &Args, 552 const llvm::Triple &Triple) { 553 // FIXME: Warn on inconsistent use of -mcpu and -march. 554 555 // If we have -mcpu=, use that. 556 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) { 557 StringRef MCPU = A->getValue(); 558 // Handle -mcpu=native. 559 if (MCPU == "native") 560 return llvm::sys::getHostCPUName(); 561 else 562 return MCPU; 563 } 564 565 return "generic"; 566} 567 568// FIXME: Move to target hook. 569static bool isSignedCharDefault(const llvm::Triple &Triple) { 570 switch (Triple.getArch()) { 571 default: 572 return true; 573 574 case llvm::Triple::aarch64: 575 case llvm::Triple::arm: 576 case llvm::Triple::ppc: 577 case llvm::Triple::ppc64: 578 if (Triple.isOSDarwin()) 579 return true; 580 return false; 581 582 case llvm::Triple::ppc64le: 583 case llvm::Triple::systemz: 584 case llvm::Triple::xcore: 585 return false; 586 } 587} 588 589static bool isNoCommonDefault(const llvm::Triple &Triple) { 590 switch (Triple.getArch()) { 591 default: 592 return false; 593 594 case llvm::Triple::xcore: 595 return true; 596 } 597} 598 599// Handle -mfpu=. 600// 601// FIXME: Centralize feature selection, defaulting shouldn't be also in the 602// frontend target. 603static void getAArch64FPUFeatures(const Driver &D, const Arg *A, 604 const ArgList &Args, 605 std::vector<const char *> &Features) { 606 StringRef FPU = A->getValue(); 607 if (FPU == "fp-armv8") { 608 Features.push_back("+fp-armv8"); 609 } else if (FPU == "neon-fp-armv8") { 610 Features.push_back("+fp-armv8"); 611 Features.push_back("+neon"); 612 } else if (FPU == "crypto-neon-fp-armv8") { 613 Features.push_back("+fp-armv8"); 614 Features.push_back("+neon"); 615 Features.push_back("+crypto"); 616 } else if (FPU == "neon") { 617 Features.push_back("+neon"); 618 } else if (FPU == "none") { 619 Features.push_back("-fp-armv8"); 620 Features.push_back("-crypto"); 621 Features.push_back("-neon"); 622 } else 623 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args); 624} 625 626// Handle -mhwdiv=. 627static void getARMHWDivFeatures(const Driver &D, const Arg *A, 628 const ArgList &Args, 629 std::vector<const char *> &Features) { 630 StringRef HWDiv = A->getValue(); 631 if (HWDiv == "arm") { 632 Features.push_back("+hwdiv-arm"); 633 Features.push_back("-hwdiv"); 634 } else if (HWDiv == "thumb") { 635 Features.push_back("-hwdiv-arm"); 636 Features.push_back("+hwdiv"); 637 } else if (HWDiv == "arm,thumb" || HWDiv == "thumb,arm") { 638 Features.push_back("+hwdiv-arm"); 639 Features.push_back("+hwdiv"); 640 } else if (HWDiv == "none") { 641 Features.push_back("-hwdiv-arm"); 642 Features.push_back("-hwdiv"); 643 } else 644 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args); 645} 646 647// Handle -mfpu=. 648// 649// FIXME: Centralize feature selection, defaulting shouldn't be also in the 650// frontend target. 651static void getARMFPUFeatures(const Driver &D, const Arg *A, 652 const ArgList &Args, 653 std::vector<const char *> &Features) { 654 StringRef FPU = A->getValue(); 655 656 // Set the target features based on the FPU. 657 if (FPU == "fpa" || FPU == "fpe2" || FPU == "fpe3" || FPU == "maverick") { 658 // Disable any default FPU support. 659 Features.push_back("-vfp2"); 660 Features.push_back("-vfp3"); 661 Features.push_back("-neon"); 662 } else if (FPU == "vfp3-d16" || FPU == "vfpv3-d16") { 663 Features.push_back("+vfp3"); 664 Features.push_back("+d16"); 665 Features.push_back("-neon"); 666 } else if (FPU == "vfp") { 667 Features.push_back("+vfp2"); 668 Features.push_back("-neon"); 669 } else if (FPU == "vfp3" || FPU == "vfpv3") { 670 Features.push_back("+vfp3"); 671 Features.push_back("-neon"); 672 } else if (FPU == "fp-armv8") { 673 Features.push_back("+fp-armv8"); 674 Features.push_back("-neon"); 675 Features.push_back("-crypto"); 676 } else if (FPU == "neon-fp-armv8") { 677 Features.push_back("+fp-armv8"); 678 Features.push_back("+neon"); 679 Features.push_back("-crypto"); 680 } else if (FPU == "crypto-neon-fp-armv8") { 681 Features.push_back("+fp-armv8"); 682 Features.push_back("+neon"); 683 Features.push_back("+crypto"); 684 } else if (FPU == "neon") { 685 Features.push_back("+neon"); 686 } else if (FPU == "none") { 687 Features.push_back("-vfp2"); 688 Features.push_back("-vfp3"); 689 Features.push_back("-vfp4"); 690 Features.push_back("-fp-armv8"); 691 Features.push_back("-crypto"); 692 Features.push_back("-neon"); 693 } else 694 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args); 695} 696 697// Select the float ABI as determined by -msoft-float, -mhard-float, and 698// -mfloat-abi=. 699static StringRef getARMFloatABI(const Driver &D, 700 const ArgList &Args, 701 const llvm::Triple &Triple) { 702 StringRef FloatABI; 703 if (Arg *A = Args.getLastArg(options::OPT_msoft_float, 704 options::OPT_mhard_float, 705 options::OPT_mfloat_abi_EQ)) { 706 if (A->getOption().matches(options::OPT_msoft_float)) 707 FloatABI = "soft"; 708 else if (A->getOption().matches(options::OPT_mhard_float)) 709 FloatABI = "hard"; 710 else { 711 FloatABI = A->getValue(); 712 if (FloatABI != "soft" && FloatABI != "softfp" && FloatABI != "hard") { 713 D.Diag(diag::err_drv_invalid_mfloat_abi) 714 << A->getAsString(Args); 715 FloatABI = "soft"; 716 } 717 } 718 } 719 720 // If unspecified, choose the default based on the platform. 721 if (FloatABI.empty()) { 722 switch (Triple.getOS()) { 723 case llvm::Triple::Darwin: 724 case llvm::Triple::MacOSX: 725 case llvm::Triple::IOS: { 726 // Darwin defaults to "softfp" for v6 and v7. 727 // 728 // FIXME: Factor out an ARM class so we can cache the arch somewhere. 729 std::string ArchName = 730 getLLVMArchSuffixForARM(getARMTargetCPU(Args, Triple)); 731 if (StringRef(ArchName).startswith("v6") || 732 StringRef(ArchName).startswith("v7")) 733 FloatABI = "softfp"; 734 else 735 FloatABI = "soft"; 736 break; 737 } 738 739 case llvm::Triple::FreeBSD: 740 // FreeBSD defaults to soft float 741 FloatABI = "soft"; 742 break; 743 744 default: 745 switch(Triple.getEnvironment()) { 746 case llvm::Triple::GNUEABIHF: 747 FloatABI = "hard"; 748 break; 749 case llvm::Triple::GNUEABI: 750 FloatABI = "softfp"; 751 break; 752 case llvm::Triple::EABI: 753 // EABI is always AAPCS, and if it was not marked 'hard', it's softfp 754 FloatABI = "softfp"; 755 break; 756 case llvm::Triple::Android: { 757 std::string ArchName = 758 getLLVMArchSuffixForARM(getARMTargetCPU(Args, Triple)); 759 if (StringRef(ArchName).startswith("v7")) 760 FloatABI = "softfp"; 761 else 762 FloatABI = "soft"; 763 break; 764 } 765 default: 766 // Assume "soft", but warn the user we are guessing. 767 FloatABI = "soft"; 768 D.Diag(diag::warn_drv_assuming_mfloat_abi_is) << "soft"; 769 break; 770 } 771 } 772 } 773 774 return FloatABI; 775} 776 777static void getARMTargetFeatures(const Driver &D, const llvm::Triple &Triple, 778 const ArgList &Args, 779 std::vector<const char *> &Features) { 780 StringRef FloatABI = getARMFloatABI(D, Args, Triple); 781 // FIXME: Note, this is a hack, the LLVM backend doesn't actually use these 782 // yet (it uses the -mfloat-abi and -msoft-float options), and it is 783 // stripped out by the ARM target. 784 // Use software floating point operations? 785 if (FloatABI == "soft") 786 Features.push_back("+soft-float"); 787 788 // Use software floating point argument passing? 789 if (FloatABI != "hard") 790 Features.push_back("+soft-float-abi"); 791 792 // Honor -mfpu=. 793 if (const Arg *A = Args.getLastArg(options::OPT_mfpu_EQ)) 794 getARMFPUFeatures(D, A, Args, Features); 795 if (const Arg *A = Args.getLastArg(options::OPT_mhwdiv_EQ)) 796 getARMHWDivFeatures(D, A, Args, Features); 797 798 // Setting -msoft-float effectively disables NEON because of the GCC 799 // implementation, although the same isn't true of VFP or VFP3. 800 if (FloatABI == "soft") 801 Features.push_back("-neon"); 802 803 // En/disable crc 804 if (Arg *A = Args.getLastArg(options::OPT_mcrc, 805 options::OPT_mnocrc)) { 806 if (A->getOption().matches(options::OPT_mcrc)) 807 Features.push_back("+crc"); 808 else 809 Features.push_back("-crc"); 810 } 811} 812 813void Clang::AddARMTargetArgs(const ArgList &Args, 814 ArgStringList &CmdArgs, 815 bool KernelOrKext) const { 816 const Driver &D = getToolChain().getDriver(); 817 // Get the effective triple, which takes into account the deployment target. 818 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args); 819 llvm::Triple Triple(TripleStr); 820 std::string CPUName = getARMTargetCPU(Args, Triple); 821 822 // Select the ABI to use. 823 // 824 // FIXME: Support -meabi. 825 const char *ABIName = 0; 826 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) { 827 ABIName = A->getValue(); 828 } else if (Triple.isOSDarwin()) { 829 // The backend is hardwired to assume AAPCS for M-class processors, ensure 830 // the frontend matches that. 831 if (Triple.getEnvironment() == llvm::Triple::EABI || 832 StringRef(CPUName).startswith("cortex-m")) { 833 ABIName = "aapcs"; 834 } else { 835 ABIName = "apcs-gnu"; 836 } 837 } else { 838 // Select the default based on the platform. 839 switch(Triple.getEnvironment()) { 840 case llvm::Triple::Android: 841 case llvm::Triple::GNUEABI: 842 case llvm::Triple::GNUEABIHF: 843 ABIName = "aapcs-linux"; 844 break; 845 case llvm::Triple::EABI: 846 ABIName = "aapcs"; 847 break; 848 default: 849 ABIName = "apcs-gnu"; 850 } 851 } 852 CmdArgs.push_back("-target-abi"); 853 CmdArgs.push_back(ABIName); 854 855 // Determine floating point ABI from the options & target defaults. 856 StringRef FloatABI = getARMFloatABI(D, Args, Triple); 857 if (FloatABI == "soft") { 858 // Floating point operations and argument passing are soft. 859 // 860 // FIXME: This changes CPP defines, we need -target-soft-float. 861 CmdArgs.push_back("-msoft-float"); 862 CmdArgs.push_back("-mfloat-abi"); 863 CmdArgs.push_back("soft"); 864 } else if (FloatABI == "softfp") { 865 // Floating point operations are hard, but argument passing is soft. 866 CmdArgs.push_back("-mfloat-abi"); 867 CmdArgs.push_back("soft"); 868 } else { 869 // Floating point operations and argument passing are hard. 870 assert(FloatABI == "hard" && "Invalid float abi!"); 871 CmdArgs.push_back("-mfloat-abi"); 872 CmdArgs.push_back("hard"); 873 } 874 875 // Kernel code has more strict alignment requirements. 876 if (KernelOrKext) { 877 if (!Triple.isiOS() || Triple.isOSVersionLT(6)) { 878 CmdArgs.push_back("-backend-option"); 879 CmdArgs.push_back("-arm-long-calls"); 880 } 881 882 CmdArgs.push_back("-backend-option"); 883 CmdArgs.push_back("-arm-strict-align"); 884 885 // The kext linker doesn't know how to deal with movw/movt. 886 CmdArgs.push_back("-backend-option"); 887 CmdArgs.push_back("-arm-use-movt=0"); 888 } 889 890 // Setting -mno-global-merge disables the codegen global merge pass. Setting 891 // -mglobal-merge has no effect as the pass is enabled by default. 892 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge, 893 options::OPT_mno_global_merge)) { 894 if (A->getOption().matches(options::OPT_mno_global_merge)) 895 CmdArgs.push_back("-mno-global-merge"); 896 } 897 898 if (!Args.hasFlag(options::OPT_mimplicit_float, 899 options::OPT_mno_implicit_float, 900 true)) 901 CmdArgs.push_back("-no-implicit-float"); 902 903 // llvm does not support reserving registers in general. There is support 904 // for reserving r9 on ARM though (defined as a platform-specific register 905 // in ARM EABI). 906 if (Args.hasArg(options::OPT_ffixed_r9)) { 907 CmdArgs.push_back("-backend-option"); 908 CmdArgs.push_back("-arm-reserve-r9"); 909 } 910} 911 912// Get CPU and ABI names. They are not independent 913// so we have to calculate them together. 914static void getMipsCPUAndABI(const ArgList &Args, 915 const llvm::Triple &Triple, 916 StringRef &CPUName, 917 StringRef &ABIName) { 918 const char *DefMips32CPU = "mips32"; 919 const char *DefMips64CPU = "mips64"; 920 921 if (Arg *A = Args.getLastArg(options::OPT_march_EQ, 922 options::OPT_mcpu_EQ)) 923 CPUName = A->getValue(); 924 925 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) { 926 ABIName = A->getValue(); 927 // Convert a GNU style Mips ABI name to the name 928 // accepted by LLVM Mips backend. 929 ABIName = llvm::StringSwitch<llvm::StringRef>(ABIName) 930 .Case("32", "o32") 931 .Case("64", "n64") 932 .Default(ABIName); 933 } 934 935 // Setup default CPU and ABI names. 936 if (CPUName.empty() && ABIName.empty()) { 937 switch (Triple.getArch()) { 938 default: 939 llvm_unreachable("Unexpected triple arch name"); 940 case llvm::Triple::mips: 941 case llvm::Triple::mipsel: 942 CPUName = DefMips32CPU; 943 break; 944 case llvm::Triple::mips64: 945 case llvm::Triple::mips64el: 946 CPUName = DefMips64CPU; 947 break; 948 } 949 } 950 951 if (!ABIName.empty()) { 952 // Deduce CPU name from ABI name. 953 CPUName = llvm::StringSwitch<const char *>(ABIName) 954 .Cases("32", "o32", "eabi", DefMips32CPU) 955 .Cases("n32", "n64", "64", DefMips64CPU) 956 .Default(""); 957 } 958 else if (!CPUName.empty()) { 959 // Deduce ABI name from CPU name. 960 ABIName = llvm::StringSwitch<const char *>(CPUName) 961 .Cases("mips32", "mips32r2", "o32") 962 .Cases("mips64", "mips64r2", "n64") 963 .Default(""); 964 } 965 966 // FIXME: Warn on inconsistent cpu and abi usage. 967} 968 969// Convert ABI name to the GNU tools acceptable variant. 970static StringRef getGnuCompatibleMipsABIName(StringRef ABI) { 971 return llvm::StringSwitch<llvm::StringRef>(ABI) 972 .Case("o32", "32") 973 .Case("n64", "64") 974 .Default(ABI); 975} 976 977// Select the MIPS float ABI as determined by -msoft-float, -mhard-float, 978// and -mfloat-abi=. 979static StringRef getMipsFloatABI(const Driver &D, const ArgList &Args) { 980 StringRef FloatABI; 981 if (Arg *A = Args.getLastArg(options::OPT_msoft_float, 982 options::OPT_mhard_float, 983 options::OPT_mfloat_abi_EQ)) { 984 if (A->getOption().matches(options::OPT_msoft_float)) 985 FloatABI = "soft"; 986 else if (A->getOption().matches(options::OPT_mhard_float)) 987 FloatABI = "hard"; 988 else { 989 FloatABI = A->getValue(); 990 if (FloatABI != "soft" && FloatABI != "hard") { 991 D.Diag(diag::err_drv_invalid_mfloat_abi) << A->getAsString(Args); 992 FloatABI = "hard"; 993 } 994 } 995 } 996 997 // If unspecified, choose the default based on the platform. 998 if (FloatABI.empty()) { 999 // Assume "hard", because it's a default value used by gcc. 1000 // When we start to recognize specific target MIPS processors, 1001 // we will be able to select the default more correctly. 1002 FloatABI = "hard"; 1003 } 1004 1005 return FloatABI; 1006} 1007 1008static void AddTargetFeature(const ArgList &Args, 1009 std::vector<const char *> &Features, 1010 OptSpecifier OnOpt, OptSpecifier OffOpt, 1011 StringRef FeatureName) { 1012 if (Arg *A = Args.getLastArg(OnOpt, OffOpt)) { 1013 if (A->getOption().matches(OnOpt)) 1014 Features.push_back(Args.MakeArgString("+" + FeatureName)); 1015 else 1016 Features.push_back(Args.MakeArgString("-" + FeatureName)); 1017 } 1018} 1019 1020static void getMIPSTargetFeatures(const Driver &D, const ArgList &Args, 1021 std::vector<const char *> &Features) { 1022 StringRef FloatABI = getMipsFloatABI(D, Args); 1023 bool IsMips16 = Args.getLastArg(options::OPT_mips16) != NULL; 1024 if (FloatABI == "soft" || (FloatABI == "hard" && IsMips16)) { 1025 // FIXME: Note, this is a hack. We need to pass the selected float 1026 // mode to the MipsTargetInfoBase to define appropriate macros there. 1027 // Now it is the only method. 1028 Features.push_back("+soft-float"); 1029 } 1030 1031 if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) { 1032 if (StringRef(A->getValue()) == "2008") 1033 Features.push_back("+nan2008"); 1034 } 1035 1036 AddTargetFeature(Args, Features, options::OPT_msingle_float, 1037 options::OPT_mdouble_float, "single-float"); 1038 AddTargetFeature(Args, Features, options::OPT_mips16, options::OPT_mno_mips16, 1039 "mips16"); 1040 AddTargetFeature(Args, Features, options::OPT_mmicromips, 1041 options::OPT_mno_micromips, "micromips"); 1042 AddTargetFeature(Args, Features, options::OPT_mdsp, options::OPT_mno_dsp, 1043 "dsp"); 1044 AddTargetFeature(Args, Features, options::OPT_mdspr2, options::OPT_mno_dspr2, 1045 "dspr2"); 1046 AddTargetFeature(Args, Features, options::OPT_mmsa, options::OPT_mno_msa, 1047 "msa"); 1048 AddTargetFeature(Args, Features, options::OPT_mfp64, options::OPT_mfp32, 1049 "fp64"); 1050} 1051 1052void Clang::AddMIPSTargetArgs(const ArgList &Args, 1053 ArgStringList &CmdArgs) const { 1054 const Driver &D = getToolChain().getDriver(); 1055 StringRef CPUName; 1056 StringRef ABIName; 1057 const llvm::Triple &Triple = getToolChain().getTriple(); 1058 getMipsCPUAndABI(Args, Triple, CPUName, ABIName); 1059 1060 CmdArgs.push_back("-target-abi"); 1061 CmdArgs.push_back(ABIName.data()); 1062 1063 StringRef FloatABI = getMipsFloatABI(D, Args); 1064 1065 bool IsMips16 = Args.getLastArg(options::OPT_mips16) != NULL; 1066 1067 if (FloatABI == "soft" || (FloatABI == "hard" && IsMips16)) { 1068 // Floating point operations and argument passing are soft. 1069 CmdArgs.push_back("-msoft-float"); 1070 CmdArgs.push_back("-mfloat-abi"); 1071 CmdArgs.push_back("soft"); 1072 1073 if (FloatABI == "hard" && IsMips16) { 1074 CmdArgs.push_back("-mllvm"); 1075 CmdArgs.push_back("-mips16-hard-float"); 1076 } 1077 } 1078 else { 1079 // Floating point operations and argument passing are hard. 1080 assert(FloatABI == "hard" && "Invalid float abi!"); 1081 CmdArgs.push_back("-mfloat-abi"); 1082 CmdArgs.push_back("hard"); 1083 } 1084 1085 if (Arg *A = Args.getLastArg(options::OPT_mxgot, options::OPT_mno_xgot)) { 1086 if (A->getOption().matches(options::OPT_mxgot)) { 1087 CmdArgs.push_back("-mllvm"); 1088 CmdArgs.push_back("-mxgot"); 1089 } 1090 } 1091 1092 if (Arg *A = Args.getLastArg(options::OPT_mldc1_sdc1, 1093 options::OPT_mno_ldc1_sdc1)) { 1094 if (A->getOption().matches(options::OPT_mno_ldc1_sdc1)) { 1095 CmdArgs.push_back("-mllvm"); 1096 CmdArgs.push_back("-mno-ldc1-sdc1"); 1097 } 1098 } 1099 1100 if (Arg *A = Args.getLastArg(options::OPT_mcheck_zero_division, 1101 options::OPT_mno_check_zero_division)) { 1102 if (A->getOption().matches(options::OPT_mno_check_zero_division)) { 1103 CmdArgs.push_back("-mllvm"); 1104 CmdArgs.push_back("-mno-check-zero-division"); 1105 } 1106 } 1107 1108 if (Arg *A = Args.getLastArg(options::OPT_G)) { 1109 StringRef v = A->getValue(); 1110 CmdArgs.push_back("-mllvm"); 1111 CmdArgs.push_back(Args.MakeArgString("-mips-ssection-threshold=" + v)); 1112 A->claim(); 1113 } 1114} 1115 1116/// getPPCTargetCPU - Get the (LLVM) name of the PowerPC cpu we are targeting. 1117static std::string getPPCTargetCPU(const ArgList &Args) { 1118 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) { 1119 StringRef CPUName = A->getValue(); 1120 1121 if (CPUName == "native") { 1122 std::string CPU = llvm::sys::getHostCPUName(); 1123 if (!CPU.empty() && CPU != "generic") 1124 return CPU; 1125 else 1126 return ""; 1127 } 1128 1129 return llvm::StringSwitch<const char *>(CPUName) 1130 .Case("common", "generic") 1131 .Case("440", "440") 1132 .Case("440fp", "440") 1133 .Case("450", "450") 1134 .Case("601", "601") 1135 .Case("602", "602") 1136 .Case("603", "603") 1137 .Case("603e", "603e") 1138 .Case("603ev", "603ev") 1139 .Case("604", "604") 1140 .Case("604e", "604e") 1141 .Case("620", "620") 1142 .Case("630", "pwr3") 1143 .Case("G3", "g3") 1144 .Case("7400", "7400") 1145 .Case("G4", "g4") 1146 .Case("7450", "7450") 1147 .Case("G4+", "g4+") 1148 .Case("750", "750") 1149 .Case("970", "970") 1150 .Case("G5", "g5") 1151 .Case("a2", "a2") 1152 .Case("a2q", "a2q") 1153 .Case("e500mc", "e500mc") 1154 .Case("e5500", "e5500") 1155 .Case("power3", "pwr3") 1156 .Case("power4", "pwr4") 1157 .Case("power5", "pwr5") 1158 .Case("power5x", "pwr5x") 1159 .Case("power6", "pwr6") 1160 .Case("power6x", "pwr6x") 1161 .Case("power7", "pwr7") 1162 .Case("pwr3", "pwr3") 1163 .Case("pwr4", "pwr4") 1164 .Case("pwr5", "pwr5") 1165 .Case("pwr5x", "pwr5x") 1166 .Case("pwr6", "pwr6") 1167 .Case("pwr6x", "pwr6x") 1168 .Case("pwr7", "pwr7") 1169 .Case("powerpc", "ppc") 1170 .Case("powerpc64", "ppc64") 1171 .Case("powerpc64le", "ppc64le") 1172 .Default(""); 1173 } 1174 1175 return ""; 1176} 1177 1178static void getPPCTargetFeatures(const ArgList &Args, 1179 std::vector<const char *> &Features) { 1180 for (arg_iterator it = Args.filtered_begin(options::OPT_m_ppc_Features_Group), 1181 ie = Args.filtered_end(); 1182 it != ie; ++it) { 1183 StringRef Name = (*it)->getOption().getName(); 1184 (*it)->claim(); 1185 1186 // Skip over "-m". 1187 assert(Name.startswith("m") && "Invalid feature name."); 1188 Name = Name.substr(1); 1189 1190 bool IsNegative = Name.startswith("no-"); 1191 if (IsNegative) 1192 Name = Name.substr(3); 1193 1194 // Note that gcc calls this mfcrf and LLVM calls this mfocrf so we 1195 // pass the correct option to the backend while calling the frontend 1196 // option the same. 1197 // TODO: Change the LLVM backend option maybe? 1198 if (Name == "mfcrf") 1199 Name = "mfocrf"; 1200 1201 Features.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name)); 1202 } 1203 1204 // Altivec is a bit weird, allow overriding of the Altivec feature here. 1205 AddTargetFeature(Args, Features, options::OPT_faltivec, 1206 options::OPT_fno_altivec, "altivec"); 1207} 1208 1209/// Get the (LLVM) name of the R600 gpu we are targeting. 1210static std::string getR600TargetGPU(const ArgList &Args) { 1211 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) { 1212 const char *GPUName = A->getValue(); 1213 return llvm::StringSwitch<const char *>(GPUName) 1214 .Cases("rv630", "rv635", "r600") 1215 .Cases("rv610", "rv620", "rs780", "rs880") 1216 .Case("rv740", "rv770") 1217 .Case("palm", "cedar") 1218 .Cases("sumo", "sumo2", "sumo") 1219 .Case("hemlock", "cypress") 1220 .Case("aruba", "cayman") 1221 .Default(GPUName); 1222 } 1223 return ""; 1224} 1225 1226static void getSparcTargetFeatures(const ArgList &Args, 1227 std::vector<const char *> Features) { 1228 bool SoftFloatABI = true; 1229 if (Arg *A = 1230 Args.getLastArg(options::OPT_msoft_float, options::OPT_mhard_float)) { 1231 if (A->getOption().matches(options::OPT_mhard_float)) 1232 SoftFloatABI = false; 1233 } 1234 if (SoftFloatABI) 1235 Features.push_back("+soft-float"); 1236} 1237 1238void Clang::AddSparcTargetArgs(const ArgList &Args, 1239 ArgStringList &CmdArgs) const { 1240 const Driver &D = getToolChain().getDriver(); 1241 1242 // Select the float ABI as determined by -msoft-float, -mhard-float, and 1243 StringRef FloatABI; 1244 if (Arg *A = Args.getLastArg(options::OPT_msoft_float, 1245 options::OPT_mhard_float)) { 1246 if (A->getOption().matches(options::OPT_msoft_float)) 1247 FloatABI = "soft"; 1248 else if (A->getOption().matches(options::OPT_mhard_float)) 1249 FloatABI = "hard"; 1250 } 1251 1252 // If unspecified, choose the default based on the platform. 1253 if (FloatABI.empty()) { 1254 // Assume "soft", but warn the user we are guessing. 1255 FloatABI = "soft"; 1256 D.Diag(diag::warn_drv_assuming_mfloat_abi_is) << "soft"; 1257 } 1258 1259 if (FloatABI == "soft") { 1260 // Floating point operations and argument passing are soft. 1261 // 1262 // FIXME: This changes CPP defines, we need -target-soft-float. 1263 CmdArgs.push_back("-msoft-float"); 1264 } else { 1265 assert(FloatABI == "hard" && "Invalid float abi!"); 1266 CmdArgs.push_back("-mhard-float"); 1267 } 1268} 1269 1270static const char *getSystemZTargetCPU(const ArgList &Args) { 1271 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) 1272 return A->getValue(); 1273 return "z10"; 1274} 1275 1276static const char *getX86TargetCPU(const ArgList &Args, 1277 const llvm::Triple &Triple) { 1278 if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) { 1279 if (StringRef(A->getValue()) != "native") { 1280 if (Triple.isOSDarwin() && Triple.getArchName() == "x86_64h") 1281 return "core-avx2"; 1282 1283 return A->getValue(); 1284 } 1285 1286 // FIXME: Reject attempts to use -march=native unless the target matches 1287 // the host. 1288 // 1289 // FIXME: We should also incorporate the detected target features for use 1290 // with -native. 1291 std::string CPU = llvm::sys::getHostCPUName(); 1292 if (!CPU.empty() && CPU != "generic") 1293 return Args.MakeArgString(CPU); 1294 } 1295 1296 // Select the default CPU if none was given (or detection failed). 1297 1298 if (Triple.getArch() != llvm::Triple::x86_64 && 1299 Triple.getArch() != llvm::Triple::x86) 1300 return 0; // This routine is only handling x86 targets. 1301 1302 bool Is64Bit = Triple.getArch() == llvm::Triple::x86_64; 1303 1304 // FIXME: Need target hooks. 1305 if (Triple.isOSDarwin()) { 1306 if (Triple.getArchName() == "x86_64h") 1307 return "core-avx2"; 1308 return Is64Bit ? "core2" : "yonah"; 1309 } 1310 1311 // All x86 devices running Android have core2 as their common 1312 // denominator. This makes a better choice than pentium4. 1313 if (Triple.getEnvironment() == llvm::Triple::Android) 1314 return "core2"; 1315 1316 // Everything else goes to x86-64 in 64-bit mode. 1317 if (Is64Bit) 1318 return "x86-64"; 1319 1320 switch (Triple.getOS()) { 1321 case llvm::Triple::FreeBSD: 1322 case llvm::Triple::NetBSD: 1323 case llvm::Triple::OpenBSD: 1324 return "i486"; 1325 case llvm::Triple::Haiku: 1326 return "i586"; 1327 case llvm::Triple::Bitrig: 1328 return "i686"; 1329 default: 1330 // Fallback to p4. 1331 return "pentium4"; 1332 } 1333} 1334 1335static std::string getCPUName(const ArgList &Args, const llvm::Triple &T) { 1336 switch(T.getArch()) { 1337 default: 1338 return ""; 1339 1340 case llvm::Triple::aarch64: 1341 return getAArch64TargetCPU(Args, T); 1342 1343 case llvm::Triple::arm: 1344 case llvm::Triple::thumb: 1345 return getARMTargetCPU(Args, T); 1346 1347 case llvm::Triple::mips: 1348 case llvm::Triple::mipsel: 1349 case llvm::Triple::mips64: 1350 case llvm::Triple::mips64el: { 1351 StringRef CPUName; 1352 StringRef ABIName; 1353 getMipsCPUAndABI(Args, T, CPUName, ABIName); 1354 return CPUName; 1355 } 1356 1357 case llvm::Triple::ppc: 1358 case llvm::Triple::ppc64: 1359 case llvm::Triple::ppc64le: { 1360 std::string TargetCPUName = getPPCTargetCPU(Args); 1361 // LLVM may default to generating code for the native CPU, 1362 // but, like gcc, we default to a more generic option for 1363 // each architecture. (except on Darwin) 1364 if (TargetCPUName.empty() && !T.isOSDarwin()) { 1365 if (T.getArch() == llvm::Triple::ppc64) 1366 TargetCPUName = "ppc64"; 1367 else if (T.getArch() == llvm::Triple::ppc64le) 1368 TargetCPUName = "ppc64le"; 1369 else 1370 TargetCPUName = "ppc"; 1371 } 1372 return TargetCPUName; 1373 } 1374 1375 case llvm::Triple::sparc: 1376 case llvm::Triple::sparcv9: 1377 if (const Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) 1378 return A->getValue(); 1379 return ""; 1380 1381 case llvm::Triple::x86: 1382 case llvm::Triple::x86_64: 1383 return getX86TargetCPU(Args, T); 1384 1385 case llvm::Triple::hexagon: 1386 return "hexagon" + toolchains::Hexagon_TC::GetTargetCPU(Args).str(); 1387 1388 case llvm::Triple::systemz: 1389 return getSystemZTargetCPU(Args); 1390 1391 case llvm::Triple::r600: 1392 return getR600TargetGPU(Args); 1393 } 1394} 1395 1396static void getX86TargetFeatures(const llvm::Triple &Triple, 1397 const ArgList &Args, 1398 std::vector<const char *> &Features) { 1399 if (Triple.getArchName() == "x86_64h") { 1400 // x86_64h implies quite a few of the more modern subtarget features 1401 // for Haswell class CPUs, but not all of them. Opt-out of a few. 1402 Features.push_back("-rdrnd"); 1403 Features.push_back("-aes"); 1404 Features.push_back("-pclmul"); 1405 Features.push_back("-rtm"); 1406 Features.push_back("-hle"); 1407 Features.push_back("-fsgsbase"); 1408 } 1409 1410 // Now add any that the user explicitly requested on the command line, 1411 // which may override the defaults. 1412 for (arg_iterator it = Args.filtered_begin(options::OPT_m_x86_Features_Group), 1413 ie = Args.filtered_end(); 1414 it != ie; ++it) { 1415 StringRef Name = (*it)->getOption().getName(); 1416 (*it)->claim(); 1417 1418 // Skip over "-m". 1419 assert(Name.startswith("m") && "Invalid feature name."); 1420 Name = Name.substr(1); 1421 1422 bool IsNegative = Name.startswith("no-"); 1423 if (IsNegative) 1424 Name = Name.substr(3); 1425 1426 Features.push_back(Args.MakeArgString((IsNegative ? "-" : "+") + Name)); 1427 } 1428} 1429 1430void Clang::AddX86TargetArgs(const ArgList &Args, 1431 ArgStringList &CmdArgs) const { 1432 if (!Args.hasFlag(options::OPT_mred_zone, 1433 options::OPT_mno_red_zone, 1434 true) || 1435 Args.hasArg(options::OPT_mkernel) || 1436 Args.hasArg(options::OPT_fapple_kext)) 1437 CmdArgs.push_back("-disable-red-zone"); 1438 1439 // Default to avoid implicit floating-point for kernel/kext code, but allow 1440 // that to be overridden with -mno-soft-float. 1441 bool NoImplicitFloat = (Args.hasArg(options::OPT_mkernel) || 1442 Args.hasArg(options::OPT_fapple_kext)); 1443 if (Arg *A = Args.getLastArg(options::OPT_msoft_float, 1444 options::OPT_mno_soft_float, 1445 options::OPT_mimplicit_float, 1446 options::OPT_mno_implicit_float)) { 1447 const Option &O = A->getOption(); 1448 NoImplicitFloat = (O.matches(options::OPT_mno_implicit_float) || 1449 O.matches(options::OPT_msoft_float)); 1450 } 1451 if (NoImplicitFloat) 1452 CmdArgs.push_back("-no-implicit-float"); 1453} 1454 1455static inline bool HasPICArg(const ArgList &Args) { 1456 return Args.hasArg(options::OPT_fPIC) 1457 || Args.hasArg(options::OPT_fpic); 1458} 1459 1460static Arg *GetLastSmallDataThresholdArg(const ArgList &Args) { 1461 return Args.getLastArg(options::OPT_G, 1462 options::OPT_G_EQ, 1463 options::OPT_msmall_data_threshold_EQ); 1464} 1465 1466static std::string GetHexagonSmallDataThresholdValue(const ArgList &Args) { 1467 std::string value; 1468 if (HasPICArg(Args)) 1469 value = "0"; 1470 else if (Arg *A = GetLastSmallDataThresholdArg(Args)) { 1471 value = A->getValue(); 1472 A->claim(); 1473 } 1474 return value; 1475} 1476 1477void Clang::AddHexagonTargetArgs(const ArgList &Args, 1478 ArgStringList &CmdArgs) const { 1479 CmdArgs.push_back("-fno-signed-char"); 1480 CmdArgs.push_back("-mqdsp6-compat"); 1481 CmdArgs.push_back("-Wreturn-type"); 1482 1483 std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args); 1484 if (!SmallDataThreshold.empty()) { 1485 CmdArgs.push_back ("-mllvm"); 1486 CmdArgs.push_back(Args.MakeArgString( 1487 "-hexagon-small-data-threshold=" + SmallDataThreshold)); 1488 } 1489 1490 if (!Args.hasArg(options::OPT_fno_short_enums)) 1491 CmdArgs.push_back("-fshort-enums"); 1492 if (Args.getLastArg(options::OPT_mieee_rnd_near)) { 1493 CmdArgs.push_back ("-mllvm"); 1494 CmdArgs.push_back ("-enable-hexagon-ieee-rnd-near"); 1495 } 1496 CmdArgs.push_back ("-mllvm"); 1497 CmdArgs.push_back ("-machine-sink-split=0"); 1498} 1499 1500static void getAArch64TargetFeatures(const Driver &D, const ArgList &Args, 1501 std::vector<const char *> &Features) { 1502 // Honor -mfpu=. 1503 if (const Arg *A = Args.getLastArg(options::OPT_mfpu_EQ)) 1504 getAArch64FPUFeatures(D, A, Args, Features); 1505} 1506 1507static void getTargetFeatures(const Driver &D, const llvm::Triple &Triple, 1508 const ArgList &Args, ArgStringList &CmdArgs) { 1509 std::vector<const char *> Features; 1510 switch (Triple.getArch()) { 1511 default: 1512 break; 1513 case llvm::Triple::mips: 1514 case llvm::Triple::mipsel: 1515 case llvm::Triple::mips64: 1516 case llvm::Triple::mips64el: 1517 getMIPSTargetFeatures(D, Args, Features); 1518 break; 1519 1520 case llvm::Triple::arm: 1521 case llvm::Triple::thumb: 1522 getARMTargetFeatures(D, Triple, Args, Features); 1523 break; 1524 1525 case llvm::Triple::ppc: 1526 case llvm::Triple::ppc64: 1527 case llvm::Triple::ppc64le: 1528 getPPCTargetFeatures(Args, Features); 1529 break; 1530 case llvm::Triple::sparc: 1531 getSparcTargetFeatures(Args, Features); 1532 break; 1533 case llvm::Triple::aarch64: 1534 getAArch64TargetFeatures(D, Args, Features); 1535 break; 1536 case llvm::Triple::x86: 1537 case llvm::Triple::x86_64: 1538 getX86TargetFeatures(Triple, Args, Features); 1539 break; 1540 } 1541 1542 // Find the last of each feature. 1543 llvm::StringMap<unsigned> LastOpt; 1544 for (unsigned I = 0, N = Features.size(); I < N; ++I) { 1545 const char *Name = Features[I]; 1546 assert(Name[0] == '-' || Name[0] == '+'); 1547 LastOpt[Name + 1] = I; 1548 } 1549 1550 for (unsigned I = 0, N = Features.size(); I < N; ++I) { 1551 // If this feature was overridden, ignore it. 1552 const char *Name = Features[I]; 1553 llvm::StringMap<unsigned>::iterator LastI = LastOpt.find(Name + 1); 1554 assert(LastI != LastOpt.end()); 1555 unsigned Last = LastI->second; 1556 if (Last != I) 1557 continue; 1558 1559 CmdArgs.push_back("-target-feature"); 1560 CmdArgs.push_back(Name); 1561 } 1562} 1563 1564static bool 1565shouldUseExceptionTablesForObjCExceptions(const ObjCRuntime &runtime, 1566 const llvm::Triple &Triple) { 1567 // We use the zero-cost exception tables for Objective-C if the non-fragile 1568 // ABI is enabled or when compiling for x86_64 and ARM on Snow Leopard and 1569 // later. 1570 if (runtime.isNonFragile()) 1571 return true; 1572 1573 if (!Triple.isOSDarwin()) 1574 return false; 1575 1576 return (!Triple.isMacOSXVersionLT(10,5) && 1577 (Triple.getArch() == llvm::Triple::x86_64 || 1578 Triple.getArch() == llvm::Triple::arm)); 1579} 1580 1581/// addExceptionArgs - Adds exception related arguments to the driver command 1582/// arguments. There's a master flag, -fexceptions and also language specific 1583/// flags to enable/disable C++ and Objective-C exceptions. 1584/// This makes it possible to for example disable C++ exceptions but enable 1585/// Objective-C exceptions. 1586static void addExceptionArgs(const ArgList &Args, types::ID InputType, 1587 const llvm::Triple &Triple, 1588 bool KernelOrKext, 1589 const ObjCRuntime &objcRuntime, 1590 ArgStringList &CmdArgs) { 1591 if (KernelOrKext) { 1592 // -mkernel and -fapple-kext imply no exceptions, so claim exception related 1593 // arguments now to avoid warnings about unused arguments. 1594 Args.ClaimAllArgs(options::OPT_fexceptions); 1595 Args.ClaimAllArgs(options::OPT_fno_exceptions); 1596 Args.ClaimAllArgs(options::OPT_fobjc_exceptions); 1597 Args.ClaimAllArgs(options::OPT_fno_objc_exceptions); 1598 Args.ClaimAllArgs(options::OPT_fcxx_exceptions); 1599 Args.ClaimAllArgs(options::OPT_fno_cxx_exceptions); 1600 return; 1601 } 1602 1603 // Exceptions are enabled by default. 1604 bool ExceptionsEnabled = true; 1605 1606 // This keeps track of whether exceptions were explicitly turned on or off. 1607 bool DidHaveExplicitExceptionFlag = false; 1608 1609 if (Arg *A = Args.getLastArg(options::OPT_fexceptions, 1610 options::OPT_fno_exceptions)) { 1611 if (A->getOption().matches(options::OPT_fexceptions)) 1612 ExceptionsEnabled = true; 1613 else 1614 ExceptionsEnabled = false; 1615 1616 DidHaveExplicitExceptionFlag = true; 1617 } 1618 1619 bool ShouldUseExceptionTables = false; 1620 1621 // Exception tables and cleanups can be enabled with -fexceptions even if the 1622 // language itself doesn't support exceptions. 1623 if (ExceptionsEnabled && DidHaveExplicitExceptionFlag) 1624 ShouldUseExceptionTables = true; 1625 1626 // Obj-C exceptions are enabled by default, regardless of -fexceptions. This 1627 // is not necessarily sensible, but follows GCC. 1628 if (types::isObjC(InputType) && 1629 Args.hasFlag(options::OPT_fobjc_exceptions, 1630 options::OPT_fno_objc_exceptions, 1631 true)) { 1632 CmdArgs.push_back("-fobjc-exceptions"); 1633 1634 ShouldUseExceptionTables |= 1635 shouldUseExceptionTablesForObjCExceptions(objcRuntime, Triple); 1636 } 1637 1638 if (types::isCXX(InputType)) { 1639 bool CXXExceptionsEnabled = ExceptionsEnabled; 1640 1641 if (Arg *A = Args.getLastArg(options::OPT_fcxx_exceptions, 1642 options::OPT_fno_cxx_exceptions, 1643 options::OPT_fexceptions, 1644 options::OPT_fno_exceptions)) { 1645 if (A->getOption().matches(options::OPT_fcxx_exceptions)) 1646 CXXExceptionsEnabled = true; 1647 else if (A->getOption().matches(options::OPT_fno_cxx_exceptions)) 1648 CXXExceptionsEnabled = false; 1649 } 1650 1651 if (CXXExceptionsEnabled) { 1652 CmdArgs.push_back("-fcxx-exceptions"); 1653 1654 ShouldUseExceptionTables = true; 1655 } 1656 } 1657 1658 if (ShouldUseExceptionTables) 1659 CmdArgs.push_back("-fexceptions"); 1660} 1661 1662static bool ShouldDisableAutolink(const ArgList &Args, 1663 const ToolChain &TC) { 1664 bool Default = true; 1665 if (TC.getTriple().isOSDarwin()) { 1666 // The native darwin assembler doesn't support the linker_option directives, 1667 // so we disable them if we think the .s file will be passed to it. 1668 Default = TC.useIntegratedAs(); 1669 } 1670 return !Args.hasFlag(options::OPT_fautolink, options::OPT_fno_autolink, 1671 Default); 1672} 1673 1674static bool ShouldDisableCFI(const ArgList &Args, 1675 const ToolChain &TC) { 1676 bool Default = true; 1677 if (TC.getTriple().isOSDarwin()) { 1678 // The native darwin assembler doesn't support cfi directives, so 1679 // we disable them if we think the .s file will be passed to it. 1680 Default = TC.useIntegratedAs(); 1681 } 1682 return !Args.hasFlag(options::OPT_fdwarf2_cfi_asm, 1683 options::OPT_fno_dwarf2_cfi_asm, 1684 Default); 1685} 1686 1687static bool ShouldDisableDwarfDirectory(const ArgList &Args, 1688 const ToolChain &TC) { 1689 bool UseDwarfDirectory = Args.hasFlag(options::OPT_fdwarf_directory_asm, 1690 options::OPT_fno_dwarf_directory_asm, 1691 TC.useIntegratedAs()); 1692 return !UseDwarfDirectory; 1693} 1694 1695/// \brief Check whether the given input tree contains any compilation actions. 1696static bool ContainsCompileAction(const Action *A) { 1697 if (isa<CompileJobAction>(A)) 1698 return true; 1699 1700 for (Action::const_iterator it = A->begin(), ie = A->end(); it != ie; ++it) 1701 if (ContainsCompileAction(*it)) 1702 return true; 1703 1704 return false; 1705} 1706 1707/// \brief Check if -relax-all should be passed to the internal assembler. 1708/// This is done by default when compiling non-assembler source with -O0. 1709static bool UseRelaxAll(Compilation &C, const ArgList &Args) { 1710 bool RelaxDefault = true; 1711 1712 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) 1713 RelaxDefault = A->getOption().matches(options::OPT_O0); 1714 1715 if (RelaxDefault) { 1716 RelaxDefault = false; 1717 for (ActionList::const_iterator it = C.getActions().begin(), 1718 ie = C.getActions().end(); it != ie; ++it) { 1719 if (ContainsCompileAction(*it)) { 1720 RelaxDefault = true; 1721 break; 1722 } 1723 } 1724 } 1725 1726 return Args.hasFlag(options::OPT_mrelax_all, options::OPT_mno_relax_all, 1727 RelaxDefault); 1728} 1729 1730static void CollectArgsForIntegratedAssembler(Compilation &C, 1731 const ArgList &Args, 1732 ArgStringList &CmdArgs, 1733 const Driver &D) { 1734 if (UseRelaxAll(C, Args)) 1735 CmdArgs.push_back("-mrelax-all"); 1736 1737 // When passing -I arguments to the assembler we sometimes need to 1738 // unconditionally take the next argument. For example, when parsing 1739 // '-Wa,-I -Wa,foo' we need to accept the -Wa,foo arg after seeing the 1740 // -Wa,-I arg and when parsing '-Wa,-I,foo' we need to accept the 'foo' 1741 // arg after parsing the '-I' arg. 1742 bool TakeNextArg = false; 1743 1744 // When using an integrated assembler, translate -Wa, and -Xassembler 1745 // options. 1746 for (arg_iterator it = Args.filtered_begin(options::OPT_Wa_COMMA, 1747 options::OPT_Xassembler), 1748 ie = Args.filtered_end(); it != ie; ++it) { 1749 const Arg *A = *it; 1750 A->claim(); 1751 1752 for (unsigned i = 0, e = A->getNumValues(); i != e; ++i) { 1753 StringRef Value = A->getValue(i); 1754 if (TakeNextArg) { 1755 CmdArgs.push_back(Value.data()); 1756 TakeNextArg = false; 1757 continue; 1758 } 1759 1760 if (Value == "-force_cpusubtype_ALL") { 1761 // Do nothing, this is the default and we don't support anything else. 1762 } else if (Value == "-L") { 1763 CmdArgs.push_back("-msave-temp-labels"); 1764 } else if (Value == "--fatal-warnings") { 1765 CmdArgs.push_back("-mllvm"); 1766 CmdArgs.push_back("-fatal-assembler-warnings"); 1767 } else if (Value == "--noexecstack") { 1768 CmdArgs.push_back("-mnoexecstack"); 1769 } else if (Value.startswith("-I")) { 1770 CmdArgs.push_back(Value.data()); 1771 // We need to consume the next argument if the current arg is a plain 1772 // -I. The next arg will be the include directory. 1773 if (Value == "-I") 1774 TakeNextArg = true; 1775 } else { 1776 D.Diag(diag::err_drv_unsupported_option_argument) 1777 << A->getOption().getName() << Value; 1778 } 1779 } 1780 } 1781} 1782 1783static void addProfileRTLinux( 1784 const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs) { 1785 if (!(Args.hasArg(options::OPT_fprofile_arcs) || 1786 Args.hasArg(options::OPT_fprofile_generate) || 1787 Args.hasArg(options::OPT_fcreate_profile) || 1788 Args.hasArg(options::OPT_coverage))) 1789 return; 1790 1791 // The profile runtime is located in the Linux library directory and has name 1792 // "libclang_rt.profile-<ArchName>.a". 1793 SmallString<128> LibProfile(TC.getDriver().ResourceDir); 1794 llvm::sys::path::append( 1795 LibProfile, "lib", "linux", 1796 Twine("libclang_rt.profile-") + TC.getArchName() + ".a"); 1797 1798 CmdArgs.push_back(Args.MakeArgString(LibProfile)); 1799} 1800 1801static void addSanitizerRTLinkFlagsLinux( 1802 const ToolChain &TC, const ArgList &Args, ArgStringList &CmdArgs, 1803 const StringRef Sanitizer, bool BeforeLibStdCXX, 1804 bool ExportSymbols = true) { 1805 // Sanitizer runtime is located in the Linux library directory and 1806 // has name "libclang_rt.<Sanitizer>-<ArchName>.a". 1807 SmallString<128> LibSanitizer(TC.getDriver().ResourceDir); 1808 llvm::sys::path::append( 1809 LibSanitizer, "lib", "linux", 1810 (Twine("libclang_rt.") + Sanitizer + "-" + TC.getArchName() + ".a")); 1811 1812 // Sanitizer runtime may need to come before -lstdc++ (or -lc++, libstdc++.a, 1813 // etc.) so that the linker picks custom versions of the global 'operator 1814 // new' and 'operator delete' symbols. We take the extreme (but simple) 1815 // strategy of inserting it at the front of the link command. It also 1816 // needs to be forced to end up in the executable, so wrap it in 1817 // whole-archive. 1818 SmallVector<const char *, 3> LibSanitizerArgs; 1819 LibSanitizerArgs.push_back("-whole-archive"); 1820 LibSanitizerArgs.push_back(Args.MakeArgString(LibSanitizer)); 1821 LibSanitizerArgs.push_back("-no-whole-archive"); 1822 1823 CmdArgs.insert(BeforeLibStdCXX ? CmdArgs.begin() : CmdArgs.end(), 1824 LibSanitizerArgs.begin(), LibSanitizerArgs.end()); 1825 1826 CmdArgs.push_back("-lpthread"); 1827 CmdArgs.push_back("-lrt"); 1828 CmdArgs.push_back("-ldl"); 1829 CmdArgs.push_back("-lm"); 1830 1831 // If possible, use a dynamic symbols file to export the symbols from the 1832 // runtime library. If we can't do so, use -export-dynamic instead to export 1833 // all symbols from the binary. 1834 if (ExportSymbols) { 1835 if (llvm::sys::fs::exists(LibSanitizer + ".syms")) 1836 CmdArgs.push_back( 1837 Args.MakeArgString("--dynamic-list=" + LibSanitizer + ".syms")); 1838 else 1839 CmdArgs.push_back("-export-dynamic"); 1840 } 1841} 1842 1843/// If AddressSanitizer is enabled, add appropriate linker flags (Linux). 1844/// This needs to be called before we add the C run-time (malloc, etc). 1845static void addAsanRTLinux(const ToolChain &TC, const ArgList &Args, 1846 ArgStringList &CmdArgs) { 1847 if (TC.getTriple().getEnvironment() == llvm::Triple::Android) { 1848 SmallString<128> LibAsan(TC.getDriver().ResourceDir); 1849 llvm::sys::path::append(LibAsan, "lib", "linux", 1850 (Twine("libclang_rt.asan-") + 1851 TC.getArchName() + "-android.so")); 1852 CmdArgs.insert(CmdArgs.begin(), Args.MakeArgString(LibAsan)); 1853 } else { 1854 if (!Args.hasArg(options::OPT_shared)) 1855 addSanitizerRTLinkFlagsLinux(TC, Args, CmdArgs, "asan", true); 1856 } 1857} 1858 1859/// If ThreadSanitizer is enabled, add appropriate linker flags (Linux). 1860/// This needs to be called before we add the C run-time (malloc, etc). 1861static void addTsanRTLinux(const ToolChain &TC, const ArgList &Args, 1862 ArgStringList &CmdArgs) { 1863 if (!Args.hasArg(options::OPT_shared)) 1864 addSanitizerRTLinkFlagsLinux(TC, Args, CmdArgs, "tsan", true); 1865} 1866 1867/// If MemorySanitizer is enabled, add appropriate linker flags (Linux). 1868/// This needs to be called before we add the C run-time (malloc, etc). 1869static void addMsanRTLinux(const ToolChain &TC, const ArgList &Args, 1870 ArgStringList &CmdArgs) { 1871 if (!Args.hasArg(options::OPT_shared)) 1872 addSanitizerRTLinkFlagsLinux(TC, Args, CmdArgs, "msan", true); 1873} 1874 1875/// If LeakSanitizer is enabled, add appropriate linker flags (Linux). 1876/// This needs to be called before we add the C run-time (malloc, etc). 1877static void addLsanRTLinux(const ToolChain &TC, const ArgList &Args, 1878 ArgStringList &CmdArgs) { 1879 if (!Args.hasArg(options::OPT_shared)) 1880 addSanitizerRTLinkFlagsLinux(TC, Args, CmdArgs, "lsan", true); 1881} 1882 1883/// If UndefinedBehaviorSanitizer is enabled, add appropriate linker flags 1884/// (Linux). 1885static void addUbsanRTLinux(const ToolChain &TC, const ArgList &Args, 1886 ArgStringList &CmdArgs, bool IsCXX, 1887 bool HasOtherSanitizerRt) { 1888 // Need a copy of sanitizer_common. This could come from another sanitizer 1889 // runtime; if we're not including one, include our own copy. 1890 if (!HasOtherSanitizerRt) 1891 addSanitizerRTLinkFlagsLinux(TC, Args, CmdArgs, "san", true, false); 1892 1893 addSanitizerRTLinkFlagsLinux(TC, Args, CmdArgs, "ubsan", false); 1894 1895 // Only include the bits of the runtime which need a C++ ABI library if 1896 // we're linking in C++ mode. 1897 if (IsCXX) 1898 addSanitizerRTLinkFlagsLinux(TC, Args, CmdArgs, "ubsan_cxx", false); 1899} 1900 1901static void addDfsanRTLinux(const ToolChain &TC, const ArgList &Args, 1902 ArgStringList &CmdArgs) { 1903 if (!Args.hasArg(options::OPT_shared)) 1904 addSanitizerRTLinkFlagsLinux(TC, Args, CmdArgs, "dfsan", true); 1905} 1906 1907static bool shouldUseFramePointerForTarget(const ArgList &Args, 1908 const llvm::Triple &Triple) { 1909 switch (Triple.getArch()) { 1910 // Don't use a frame pointer on linux if optimizing for certain targets. 1911 case llvm::Triple::mips64: 1912 case llvm::Triple::mips64el: 1913 case llvm::Triple::mips: 1914 case llvm::Triple::mipsel: 1915 case llvm::Triple::systemz: 1916 case llvm::Triple::x86: 1917 case llvm::Triple::x86_64: 1918 if (Triple.isOSLinux()) 1919 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) 1920 if (!A->getOption().matches(options::OPT_O0)) 1921 return false; 1922 return true; 1923 case llvm::Triple::xcore: 1924 return false; 1925 default: 1926 return true; 1927 } 1928} 1929 1930static bool shouldUseFramePointer(const ArgList &Args, 1931 const llvm::Triple &Triple) { 1932 if (Arg *A = Args.getLastArg(options::OPT_fno_omit_frame_pointer, 1933 options::OPT_fomit_frame_pointer)) 1934 return A->getOption().matches(options::OPT_fno_omit_frame_pointer); 1935 1936 return shouldUseFramePointerForTarget(Args, Triple); 1937} 1938 1939static bool shouldUseLeafFramePointer(const ArgList &Args, 1940 const llvm::Triple &Triple) { 1941 if (Arg *A = Args.getLastArg(options::OPT_mno_omit_leaf_frame_pointer, 1942 options::OPT_momit_leaf_frame_pointer)) 1943 return A->getOption().matches(options::OPT_mno_omit_leaf_frame_pointer); 1944 1945 return shouldUseFramePointerForTarget(Args, Triple); 1946} 1947 1948/// Add a CC1 option to specify the debug compilation directory. 1949static void addDebugCompDirArg(const ArgList &Args, ArgStringList &CmdArgs) { 1950 SmallString<128> cwd; 1951 if (!llvm::sys::fs::current_path(cwd)) { 1952 CmdArgs.push_back("-fdebug-compilation-dir"); 1953 CmdArgs.push_back(Args.MakeArgString(cwd)); 1954 } 1955} 1956 1957static const char *SplitDebugName(const ArgList &Args, 1958 const InputInfoList &Inputs) { 1959 Arg *FinalOutput = Args.getLastArg(options::OPT_o); 1960 if (FinalOutput && Args.hasArg(options::OPT_c)) { 1961 SmallString<128> T(FinalOutput->getValue()); 1962 llvm::sys::path::replace_extension(T, "dwo"); 1963 return Args.MakeArgString(T); 1964 } else { 1965 // Use the compilation dir. 1966 SmallString<128> T(Args.getLastArgValue(options::OPT_fdebug_compilation_dir)); 1967 SmallString<128> F(llvm::sys::path::stem(Inputs[0].getBaseInput())); 1968 llvm::sys::path::replace_extension(F, "dwo"); 1969 T += F; 1970 return Args.MakeArgString(F); 1971 } 1972} 1973 1974static void SplitDebugInfo(const ToolChain &TC, Compilation &C, 1975 const Tool &T, const JobAction &JA, 1976 const ArgList &Args, const InputInfo &Output, 1977 const char *OutFile) { 1978 ArgStringList ExtractArgs; 1979 ExtractArgs.push_back("--extract-dwo"); 1980 1981 ArgStringList StripArgs; 1982 StripArgs.push_back("--strip-dwo"); 1983 1984 // Grabbing the output of the earlier compile step. 1985 StripArgs.push_back(Output.getFilename()); 1986 ExtractArgs.push_back(Output.getFilename()); 1987 ExtractArgs.push_back(OutFile); 1988 1989 const char *Exec = 1990 Args.MakeArgString(TC.GetProgramPath("objcopy")); 1991 1992 // First extract the dwo sections. 1993 C.addCommand(new Command(JA, T, Exec, ExtractArgs)); 1994 1995 // Then remove them from the original .o file. 1996 C.addCommand(new Command(JA, T, Exec, StripArgs)); 1997} 1998 1999static bool isOptimizationLevelFast(const ArgList &Args) { 2000 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) 2001 if (A->getOption().matches(options::OPT_Ofast)) 2002 return true; 2003 return false; 2004} 2005 2006/// \brief Vectorize at all optimization levels greater than 1 except for -Oz. 2007static bool shouldEnableVectorizerAtOLevel(const ArgList &Args) { 2008 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) { 2009 if (A->getOption().matches(options::OPT_O4) || 2010 A->getOption().matches(options::OPT_Ofast)) 2011 return true; 2012 2013 if (A->getOption().matches(options::OPT_O0)) 2014 return false; 2015 2016 assert(A->getOption().matches(options::OPT_O) && "Must have a -O flag"); 2017 2018 // Vectorize -Os. 2019 StringRef S(A->getValue()); 2020 if (S == "s") 2021 return true; 2022 2023 // Don't vectorize -Oz. 2024 if (S == "z") 2025 return false; 2026 2027 unsigned OptLevel = 0; 2028 if (S.getAsInteger(10, OptLevel)) 2029 return false; 2030 2031 return OptLevel > 1; 2032 } 2033 2034 return false; 2035} 2036 2037void Clang::ConstructJob(Compilation &C, const JobAction &JA, 2038 const InputInfo &Output, 2039 const InputInfoList &Inputs, 2040 const ArgList &Args, 2041 const char *LinkingOutput) const { 2042 bool KernelOrKext = Args.hasArg(options::OPT_mkernel, 2043 options::OPT_fapple_kext); 2044 const Driver &D = getToolChain().getDriver(); 2045 ArgStringList CmdArgs; 2046 2047 assert(Inputs.size() == 1 && "Unable to handle multiple inputs."); 2048 2049 // Invoke ourselves in -cc1 mode. 2050 // 2051 // FIXME: Implement custom jobs for internal actions. 2052 CmdArgs.push_back("-cc1"); 2053 2054 // Add the "effective" target triple. 2055 CmdArgs.push_back("-triple"); 2056 std::string TripleStr = getToolChain().ComputeEffectiveClangTriple(Args); 2057 CmdArgs.push_back(Args.MakeArgString(TripleStr)); 2058 2059 // Select the appropriate action. 2060 RewriteKind rewriteKind = RK_None; 2061 2062 if (isa<AnalyzeJobAction>(JA)) { 2063 assert(JA.getType() == types::TY_Plist && "Invalid output type."); 2064 CmdArgs.push_back("-analyze"); 2065 } else if (isa<MigrateJobAction>(JA)) { 2066 CmdArgs.push_back("-migrate"); 2067 } else if (isa<PreprocessJobAction>(JA)) { 2068 if (Output.getType() == types::TY_Dependencies) 2069 CmdArgs.push_back("-Eonly"); 2070 else { 2071 CmdArgs.push_back("-E"); 2072 if (Args.hasArg(options::OPT_rewrite_objc) && 2073 !Args.hasArg(options::OPT_g_Group)) 2074 CmdArgs.push_back("-P"); 2075 } 2076 } else if (isa<AssembleJobAction>(JA)) { 2077 CmdArgs.push_back("-emit-obj"); 2078 2079 CollectArgsForIntegratedAssembler(C, Args, CmdArgs, D); 2080 2081 // Also ignore explicit -force_cpusubtype_ALL option. 2082 (void) Args.hasArg(options::OPT_force__cpusubtype__ALL); 2083 } else if (isa<PrecompileJobAction>(JA)) { 2084 // Use PCH if the user requested it. 2085 bool UsePCH = D.CCCUsePCH; 2086 2087 if (JA.getType() == types::TY_Nothing) 2088 CmdArgs.push_back("-fsyntax-only"); 2089 else if (UsePCH) 2090 CmdArgs.push_back("-emit-pch"); 2091 else 2092 CmdArgs.push_back("-emit-pth"); 2093 } else { 2094 assert(isa<CompileJobAction>(JA) && "Invalid action for clang tool."); 2095 2096 if (JA.getType() == types::TY_Nothing) { 2097 CmdArgs.push_back("-fsyntax-only"); 2098 } else if (JA.getType() == types::TY_LLVM_IR || 2099 JA.getType() == types::TY_LTO_IR) { 2100 CmdArgs.push_back("-emit-llvm"); 2101 } else if (JA.getType() == types::TY_LLVM_BC || 2102 JA.getType() == types::TY_LTO_BC) { 2103 CmdArgs.push_back("-emit-llvm-bc"); 2104 } else if (JA.getType() == types::TY_PP_Asm) { 2105 CmdArgs.push_back("-S"); 2106 } else if (JA.getType() == types::TY_AST) { 2107 CmdArgs.push_back("-emit-pch"); 2108 } else if (JA.getType() == types::TY_ModuleFile) { 2109 CmdArgs.push_back("-module-file-info"); 2110 } else if (JA.getType() == types::TY_RewrittenObjC) { 2111 CmdArgs.push_back("-rewrite-objc"); 2112 rewriteKind = RK_NonFragile; 2113 } else if (JA.getType() == types::TY_RewrittenLegacyObjC) { 2114 CmdArgs.push_back("-rewrite-objc"); 2115 rewriteKind = RK_Fragile; 2116 } else { 2117 assert(JA.getType() == types::TY_PP_Asm && 2118 "Unexpected output type!"); 2119 } 2120 } 2121 2122 // The make clang go fast button. 2123 CmdArgs.push_back("-disable-free"); 2124 2125 // Disable the verification pass in -asserts builds. 2126#ifdef NDEBUG 2127 CmdArgs.push_back("-disable-llvm-verifier"); 2128#endif 2129 2130 // Set the main file name, so that debug info works even with 2131 // -save-temps. 2132 CmdArgs.push_back("-main-file-name"); 2133 CmdArgs.push_back(getBaseInputName(Args, Inputs)); 2134 2135 // Some flags which affect the language (via preprocessor 2136 // defines). 2137 if (Args.hasArg(options::OPT_static)) 2138 CmdArgs.push_back("-static-define"); 2139 2140 if (isa<AnalyzeJobAction>(JA)) { 2141 // Enable region store model by default. 2142 CmdArgs.push_back("-analyzer-store=region"); 2143 2144 // Treat blocks as analysis entry points. 2145 CmdArgs.push_back("-analyzer-opt-analyze-nested-blocks"); 2146 2147 CmdArgs.push_back("-analyzer-eagerly-assume"); 2148 2149 // Add default argument set. 2150 if (!Args.hasArg(options::OPT__analyzer_no_default_checks)) { 2151 CmdArgs.push_back("-analyzer-checker=core"); 2152 2153 if (getToolChain().getTriple().getOS() != llvm::Triple::Win32) 2154 CmdArgs.push_back("-analyzer-checker=unix"); 2155 2156 if (getToolChain().getTriple().getVendor() == llvm::Triple::Apple) 2157 CmdArgs.push_back("-analyzer-checker=osx"); 2158 2159 CmdArgs.push_back("-analyzer-checker=deadcode"); 2160 2161 if (types::isCXX(Inputs[0].getType())) 2162 CmdArgs.push_back("-analyzer-checker=cplusplus"); 2163 2164 // Enable the following experimental checkers for testing. 2165 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.UncheckedReturn"); 2166 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.getpw"); 2167 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.gets"); 2168 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mktemp"); 2169 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mkstemp"); 2170 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.vfork"); 2171 } 2172 2173 // Set the output format. The default is plist, for (lame) historical 2174 // reasons. 2175 CmdArgs.push_back("-analyzer-output"); 2176 if (Arg *A = Args.getLastArg(options::OPT__analyzer_output)) 2177 CmdArgs.push_back(A->getValue()); 2178 else 2179 CmdArgs.push_back("plist"); 2180 2181 // Disable the presentation of standard compiler warnings when 2182 // using --analyze. We only want to show static analyzer diagnostics 2183 // or frontend errors. 2184 CmdArgs.push_back("-w"); 2185 2186 // Add -Xanalyzer arguments when running as analyzer. 2187 Args.AddAllArgValues(CmdArgs, options::OPT_Xanalyzer); 2188 } 2189 2190 CheckCodeGenerationOptions(D, Args); 2191 2192 bool PIE = getToolChain().isPIEDefault(); 2193 bool PIC = PIE || getToolChain().isPICDefault(); 2194 bool IsPICLevelTwo = PIC; 2195 2196 // For the PIC and PIE flag options, this logic is different from the 2197 // legacy logic in very old versions of GCC, as that logic was just 2198 // a bug no one had ever fixed. This logic is both more rational and 2199 // consistent with GCC's new logic now that the bugs are fixed. The last 2200 // argument relating to either PIC or PIE wins, and no other argument is 2201 // used. If the last argument is any flavor of the '-fno-...' arguments, 2202 // both PIC and PIE are disabled. Any PIE option implicitly enables PIC 2203 // at the same level. 2204 Arg *LastPICArg =Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC, 2205 options::OPT_fpic, options::OPT_fno_pic, 2206 options::OPT_fPIE, options::OPT_fno_PIE, 2207 options::OPT_fpie, options::OPT_fno_pie); 2208 // Check whether the tool chain trumps the PIC-ness decision. If the PIC-ness 2209 // is forced, then neither PIC nor PIE flags will have no effect. 2210 if (!getToolChain().isPICDefaultForced()) { 2211 if (LastPICArg) { 2212 Option O = LastPICArg->getOption(); 2213 if (O.matches(options::OPT_fPIC) || O.matches(options::OPT_fpic) || 2214 O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie)) { 2215 PIE = O.matches(options::OPT_fPIE) || O.matches(options::OPT_fpie); 2216 PIC = PIE || O.matches(options::OPT_fPIC) || 2217 O.matches(options::OPT_fpic); 2218 IsPICLevelTwo = O.matches(options::OPT_fPIE) || 2219 O.matches(options::OPT_fPIC); 2220 } else { 2221 PIE = PIC = false; 2222 } 2223 } 2224 } 2225 2226 // Introduce a Darwin-specific hack. If the default is PIC but the flags 2227 // specified while enabling PIC enabled level 1 PIC, just force it back to 2228 // level 2 PIC instead. This matches the behavior of Darwin GCC (based on my 2229 // informal testing). 2230 if (PIC && getToolChain().getTriple().isOSDarwin()) 2231 IsPICLevelTwo |= getToolChain().isPICDefault(); 2232 2233 // Note that these flags are trump-cards. Regardless of the order w.r.t. the 2234 // PIC or PIE options above, if these show up, PIC is disabled. 2235 llvm::Triple Triple(TripleStr); 2236 if (KernelOrKext && 2237 (!Triple.isiOS() || Triple.isOSVersionLT(6))) 2238 PIC = PIE = false; 2239 if (Args.hasArg(options::OPT_static)) 2240 PIC = PIE = false; 2241 2242 if (Arg *A = Args.getLastArg(options::OPT_mdynamic_no_pic)) { 2243 // This is a very special mode. It trumps the other modes, almost no one 2244 // uses it, and it isn't even valid on any OS but Darwin. 2245 if (!getToolChain().getTriple().isOSDarwin()) 2246 D.Diag(diag::err_drv_unsupported_opt_for_target) 2247 << A->getSpelling() << getToolChain().getTriple().str(); 2248 2249 // FIXME: Warn when this flag trumps some other PIC or PIE flag. 2250 2251 CmdArgs.push_back("-mrelocation-model"); 2252 CmdArgs.push_back("dynamic-no-pic"); 2253 2254 // Only a forced PIC mode can cause the actual compile to have PIC defines 2255 // etc., no flags are sufficient. This behavior was selected to closely 2256 // match that of llvm-gcc and Apple GCC before that. 2257 if (getToolChain().isPICDefault() && getToolChain().isPICDefaultForced()) { 2258 CmdArgs.push_back("-pic-level"); 2259 CmdArgs.push_back("2"); 2260 } 2261 } else { 2262 // Currently, LLVM only knows about PIC vs. static; the PIE differences are 2263 // handled in Clang's IRGen by the -pie-level flag. 2264 CmdArgs.push_back("-mrelocation-model"); 2265 CmdArgs.push_back(PIC ? "pic" : "static"); 2266 2267 if (PIC) { 2268 CmdArgs.push_back("-pic-level"); 2269 CmdArgs.push_back(IsPICLevelTwo ? "2" : "1"); 2270 if (PIE) { 2271 CmdArgs.push_back("-pie-level"); 2272 CmdArgs.push_back(IsPICLevelTwo ? "2" : "1"); 2273 } 2274 } 2275 } 2276 2277 if (!Args.hasFlag(options::OPT_fmerge_all_constants, 2278 options::OPT_fno_merge_all_constants)) 2279 CmdArgs.push_back("-fno-merge-all-constants"); 2280 2281 // LLVM Code Generator Options. 2282 2283 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) { 2284 CmdArgs.push_back("-mregparm"); 2285 CmdArgs.push_back(A->getValue()); 2286 } 2287 2288 if (Arg *A = Args.getLastArg(options::OPT_fpcc_struct_return, 2289 options::OPT_freg_struct_return)) { 2290 if (getToolChain().getArch() != llvm::Triple::x86) { 2291 D.Diag(diag::err_drv_unsupported_opt_for_target) 2292 << A->getSpelling() << getToolChain().getTriple().str(); 2293 } else if (A->getOption().matches(options::OPT_fpcc_struct_return)) { 2294 CmdArgs.push_back("-fpcc-struct-return"); 2295 } else { 2296 assert(A->getOption().matches(options::OPT_freg_struct_return)); 2297 CmdArgs.push_back("-freg-struct-return"); 2298 } 2299 } 2300 2301 if (Args.hasFlag(options::OPT_mrtd, options::OPT_mno_rtd, false)) 2302 CmdArgs.push_back("-mrtd"); 2303 2304 if (shouldUseFramePointer(Args, getToolChain().getTriple())) 2305 CmdArgs.push_back("-mdisable-fp-elim"); 2306 if (!Args.hasFlag(options::OPT_fzero_initialized_in_bss, 2307 options::OPT_fno_zero_initialized_in_bss)) 2308 CmdArgs.push_back("-mno-zero-initialized-in-bss"); 2309 2310 bool OFastEnabled = isOptimizationLevelFast(Args); 2311 // If -Ofast is the optimization level, then -fstrict-aliasing should be 2312 // enabled. This alias option is being used to simplify the hasFlag logic. 2313 OptSpecifier StrictAliasingAliasOption = OFastEnabled ? options::OPT_Ofast : 2314 options::OPT_fstrict_aliasing; 2315 if (!Args.hasFlag(options::OPT_fstrict_aliasing, StrictAliasingAliasOption, 2316 options::OPT_fno_strict_aliasing, true)) 2317 CmdArgs.push_back("-relaxed-aliasing"); 2318 if (!Args.hasFlag(options::OPT_fstruct_path_tbaa, 2319 options::OPT_fno_struct_path_tbaa)) 2320 CmdArgs.push_back("-no-struct-path-tbaa"); 2321 if (Args.hasFlag(options::OPT_fstrict_enums, options::OPT_fno_strict_enums, 2322 false)) 2323 CmdArgs.push_back("-fstrict-enums"); 2324 if (!Args.hasFlag(options::OPT_foptimize_sibling_calls, 2325 options::OPT_fno_optimize_sibling_calls)) 2326 CmdArgs.push_back("-mdisable-tail-calls"); 2327 2328 // Handle segmented stacks. 2329 if (Args.hasArg(options::OPT_fsplit_stack)) 2330 CmdArgs.push_back("-split-stacks"); 2331 2332 // If -Ofast is the optimization level, then -ffast-math should be enabled. 2333 // This alias option is being used to simplify the getLastArg logic. 2334 OptSpecifier FastMathAliasOption = OFastEnabled ? options::OPT_Ofast : 2335 options::OPT_ffast_math; 2336 2337 // Handle various floating point optimization flags, mapping them to the 2338 // appropriate LLVM code generation flags. The pattern for all of these is to 2339 // default off the codegen optimizations, and if any flag enables them and no 2340 // flag disables them after the flag enabling them, enable the codegen 2341 // optimization. This is complicated by several "umbrella" flags. 2342 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption, 2343 options::OPT_fno_fast_math, 2344 options::OPT_ffinite_math_only, 2345 options::OPT_fno_finite_math_only, 2346 options::OPT_fhonor_infinities, 2347 options::OPT_fno_honor_infinities)) 2348 if (A->getOption().getID() != options::OPT_fno_fast_math && 2349 A->getOption().getID() != options::OPT_fno_finite_math_only && 2350 A->getOption().getID() != options::OPT_fhonor_infinities) 2351 CmdArgs.push_back("-menable-no-infs"); 2352 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption, 2353 options::OPT_fno_fast_math, 2354 options::OPT_ffinite_math_only, 2355 options::OPT_fno_finite_math_only, 2356 options::OPT_fhonor_nans, 2357 options::OPT_fno_honor_nans)) 2358 if (A->getOption().getID() != options::OPT_fno_fast_math && 2359 A->getOption().getID() != options::OPT_fno_finite_math_only && 2360 A->getOption().getID() != options::OPT_fhonor_nans) 2361 CmdArgs.push_back("-menable-no-nans"); 2362 2363 // -fmath-errno is the default on some platforms, e.g. BSD-derived OSes. 2364 bool MathErrno = getToolChain().IsMathErrnoDefault(); 2365 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption, 2366 options::OPT_fno_fast_math, 2367 options::OPT_fmath_errno, 2368 options::OPT_fno_math_errno)) { 2369 // Turning on -ffast_math (with either flag) removes the need for MathErrno. 2370 // However, turning *off* -ffast_math merely restores the toolchain default 2371 // (which may be false). 2372 if (A->getOption().getID() == options::OPT_fno_math_errno || 2373 A->getOption().getID() == options::OPT_ffast_math || 2374 A->getOption().getID() == options::OPT_Ofast) 2375 MathErrno = false; 2376 else if (A->getOption().getID() == options::OPT_fmath_errno) 2377 MathErrno = true; 2378 } 2379 if (MathErrno) 2380 CmdArgs.push_back("-fmath-errno"); 2381 2382 // There are several flags which require disabling very specific 2383 // optimizations. Any of these being disabled forces us to turn off the 2384 // entire set of LLVM optimizations, so collect them through all the flag 2385 // madness. 2386 bool AssociativeMath = false; 2387 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption, 2388 options::OPT_fno_fast_math, 2389 options::OPT_funsafe_math_optimizations, 2390 options::OPT_fno_unsafe_math_optimizations, 2391 options::OPT_fassociative_math, 2392 options::OPT_fno_associative_math)) 2393 if (A->getOption().getID() != options::OPT_fno_fast_math && 2394 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations && 2395 A->getOption().getID() != options::OPT_fno_associative_math) 2396 AssociativeMath = true; 2397 bool ReciprocalMath = false; 2398 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption, 2399 options::OPT_fno_fast_math, 2400 options::OPT_funsafe_math_optimizations, 2401 options::OPT_fno_unsafe_math_optimizations, 2402 options::OPT_freciprocal_math, 2403 options::OPT_fno_reciprocal_math)) 2404 if (A->getOption().getID() != options::OPT_fno_fast_math && 2405 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations && 2406 A->getOption().getID() != options::OPT_fno_reciprocal_math) 2407 ReciprocalMath = true; 2408 bool SignedZeros = true; 2409 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption, 2410 options::OPT_fno_fast_math, 2411 options::OPT_funsafe_math_optimizations, 2412 options::OPT_fno_unsafe_math_optimizations, 2413 options::OPT_fsigned_zeros, 2414 options::OPT_fno_signed_zeros)) 2415 if (A->getOption().getID() != options::OPT_fno_fast_math && 2416 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations && 2417 A->getOption().getID() != options::OPT_fsigned_zeros) 2418 SignedZeros = false; 2419 bool TrappingMath = true; 2420 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption, 2421 options::OPT_fno_fast_math, 2422 options::OPT_funsafe_math_optimizations, 2423 options::OPT_fno_unsafe_math_optimizations, 2424 options::OPT_ftrapping_math, 2425 options::OPT_fno_trapping_math)) 2426 if (A->getOption().getID() != options::OPT_fno_fast_math && 2427 A->getOption().getID() != options::OPT_fno_unsafe_math_optimizations && 2428 A->getOption().getID() != options::OPT_ftrapping_math) 2429 TrappingMath = false; 2430 if (!MathErrno && AssociativeMath && ReciprocalMath && !SignedZeros && 2431 !TrappingMath) 2432 CmdArgs.push_back("-menable-unsafe-fp-math"); 2433 2434 2435 // Validate and pass through -fp-contract option. 2436 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption, 2437 options::OPT_fno_fast_math, 2438 options::OPT_ffp_contract)) { 2439 if (A->getOption().getID() == options::OPT_ffp_contract) { 2440 StringRef Val = A->getValue(); 2441 if (Val == "fast" || Val == "on" || Val == "off") { 2442 CmdArgs.push_back(Args.MakeArgString("-ffp-contract=" + Val)); 2443 } else { 2444 D.Diag(diag::err_drv_unsupported_option_argument) 2445 << A->getOption().getName() << Val; 2446 } 2447 } else if (A->getOption().matches(options::OPT_ffast_math) || 2448 (OFastEnabled && A->getOption().matches(options::OPT_Ofast))) { 2449 // If fast-math is set then set the fp-contract mode to fast. 2450 CmdArgs.push_back(Args.MakeArgString("-ffp-contract=fast")); 2451 } 2452 } 2453 2454 // We separately look for the '-ffast-math' and '-ffinite-math-only' flags, 2455 // and if we find them, tell the frontend to provide the appropriate 2456 // preprocessor macros. This is distinct from enabling any optimizations as 2457 // these options induce language changes which must survive serialization 2458 // and deserialization, etc. 2459 if (Arg *A = Args.getLastArg(options::OPT_ffast_math, FastMathAliasOption, 2460 options::OPT_fno_fast_math)) 2461 if (!A->getOption().matches(options::OPT_fno_fast_math)) 2462 CmdArgs.push_back("-ffast-math"); 2463 if (Arg *A = Args.getLastArg(options::OPT_ffinite_math_only, options::OPT_fno_fast_math)) 2464 if (A->getOption().matches(options::OPT_ffinite_math_only)) 2465 CmdArgs.push_back("-ffinite-math-only"); 2466 2467 // Decide whether to use verbose asm. Verbose assembly is the default on 2468 // toolchains which have the integrated assembler on by default. 2469 bool IsVerboseAsmDefault = getToolChain().IsIntegratedAssemblerDefault(); 2470 if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm, 2471 IsVerboseAsmDefault) || 2472 Args.hasArg(options::OPT_dA)) 2473 CmdArgs.push_back("-masm-verbose"); 2474 2475 if (Args.hasArg(options::OPT_fdebug_pass_structure)) { 2476 CmdArgs.push_back("-mdebug-pass"); 2477 CmdArgs.push_back("Structure"); 2478 } 2479 if (Args.hasArg(options::OPT_fdebug_pass_arguments)) { 2480 CmdArgs.push_back("-mdebug-pass"); 2481 CmdArgs.push_back("Arguments"); 2482 } 2483 2484 // Enable -mconstructor-aliases except on darwin, where we have to 2485 // work around a linker bug; see <rdar://problem/7651567>. 2486 if (!getToolChain().getTriple().isOSDarwin()) 2487 CmdArgs.push_back("-mconstructor-aliases"); 2488 2489 // Darwin's kernel doesn't support guard variables; just die if we 2490 // try to use them. 2491 if (KernelOrKext && getToolChain().getTriple().isOSDarwin()) 2492 CmdArgs.push_back("-fforbid-guard-variables"); 2493 2494 if (Args.hasArg(options::OPT_mms_bitfields)) { 2495 CmdArgs.push_back("-mms-bitfields"); 2496 } 2497 2498 // This is a coarse approximation of what llvm-gcc actually does, both 2499 // -fasynchronous-unwind-tables and -fnon-call-exceptions interact in more 2500 // complicated ways. 2501 bool AsynchronousUnwindTables = 2502 Args.hasFlag(options::OPT_fasynchronous_unwind_tables, 2503 options::OPT_fno_asynchronous_unwind_tables, 2504 getToolChain().IsUnwindTablesDefault() && 2505 !KernelOrKext); 2506 if (Args.hasFlag(options::OPT_funwind_tables, options::OPT_fno_unwind_tables, 2507 AsynchronousUnwindTables)) 2508 CmdArgs.push_back("-munwind-tables"); 2509 2510 getToolChain().addClangTargetOptions(Args, CmdArgs); 2511 2512 if (Arg *A = Args.getLastArg(options::OPT_flimited_precision_EQ)) { 2513 CmdArgs.push_back("-mlimit-float-precision"); 2514 CmdArgs.push_back(A->getValue()); 2515 } 2516 2517 // FIXME: Handle -mtune=. 2518 (void) Args.hasArg(options::OPT_mtune_EQ); 2519 2520 if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) { 2521 CmdArgs.push_back("-mcode-model"); 2522 CmdArgs.push_back(A->getValue()); 2523 } 2524 2525 // Add the target cpu 2526 std::string ETripleStr = getToolChain().ComputeEffectiveClangTriple(Args); 2527 llvm::Triple ETriple(ETripleStr); 2528 std::string CPU = getCPUName(Args, ETriple); 2529 if (!CPU.empty()) { 2530 CmdArgs.push_back("-target-cpu"); 2531 CmdArgs.push_back(Args.MakeArgString(CPU)); 2532 } 2533 2534 if (const Arg *A = Args.getLastArg(options::OPT_mfpmath_EQ)) { 2535 CmdArgs.push_back("-mfpmath"); 2536 CmdArgs.push_back(A->getValue()); 2537 } 2538 2539 // Add the target features 2540 getTargetFeatures(D, ETriple, Args, CmdArgs); 2541 2542 // Add target specific flags. 2543 switch(getToolChain().getArch()) { 2544 default: 2545 break; 2546 2547 case llvm::Triple::arm: 2548 case llvm::Triple::thumb: 2549 AddARMTargetArgs(Args, CmdArgs, KernelOrKext); 2550 break; 2551 2552 case llvm::Triple::mips: 2553 case llvm::Triple::mipsel: 2554 case llvm::Triple::mips64: 2555 case llvm::Triple::mips64el: 2556 AddMIPSTargetArgs(Args, CmdArgs); 2557 break; 2558 2559 case llvm::Triple::sparc: 2560 AddSparcTargetArgs(Args, CmdArgs); 2561 break; 2562 2563 case llvm::Triple::x86: 2564 case llvm::Triple::x86_64: 2565 AddX86TargetArgs(Args, CmdArgs); 2566 break; 2567 2568 case llvm::Triple::hexagon: 2569 AddHexagonTargetArgs(Args, CmdArgs); 2570 break; 2571 } 2572 2573 // Add clang-cl arguments. 2574 if (getToolChain().getDriver().IsCLMode()) 2575 AddClangCLArgs(Args, CmdArgs); 2576 2577 // Pass the linker version in use. 2578 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) { 2579 CmdArgs.push_back("-target-linker-version"); 2580 CmdArgs.push_back(A->getValue()); 2581 } 2582 2583 if (!shouldUseLeafFramePointer(Args, getToolChain().getTriple())) 2584 CmdArgs.push_back("-momit-leaf-frame-pointer"); 2585 2586 // Explicitly error on some things we know we don't support and can't just 2587 // ignore. 2588 types::ID InputType = Inputs[0].getType(); 2589 if (!Args.hasArg(options::OPT_fallow_unsupported)) { 2590 Arg *Unsupported; 2591 if (types::isCXX(InputType) && 2592 getToolChain().getTriple().isOSDarwin() && 2593 getToolChain().getArch() == llvm::Triple::x86) { 2594 if ((Unsupported = Args.getLastArg(options::OPT_fapple_kext)) || 2595 (Unsupported = Args.getLastArg(options::OPT_mkernel))) 2596 D.Diag(diag::err_drv_clang_unsupported_opt_cxx_darwin_i386) 2597 << Unsupported->getOption().getName(); 2598 } 2599 } 2600 2601 Args.AddAllArgs(CmdArgs, options::OPT_v); 2602 Args.AddLastArg(CmdArgs, options::OPT_H); 2603 if (D.CCPrintHeaders && !D.CCGenDiagnostics) { 2604 CmdArgs.push_back("-header-include-file"); 2605 CmdArgs.push_back(D.CCPrintHeadersFilename ? 2606 D.CCPrintHeadersFilename : "-"); 2607 } 2608 Args.AddLastArg(CmdArgs, options::OPT_P); 2609 Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout); 2610 2611 if (D.CCLogDiagnostics && !D.CCGenDiagnostics) { 2612 CmdArgs.push_back("-diagnostic-log-file"); 2613 CmdArgs.push_back(D.CCLogDiagnosticsFilename ? 2614 D.CCLogDiagnosticsFilename : "-"); 2615 } 2616 2617 // Use the last option from "-g" group. "-gline-tables-only" 2618 // is preserved, all other debug options are substituted with "-g". 2619 Args.ClaimAllArgs(options::OPT_g_Group); 2620 if (Arg *A = Args.getLastArg(options::OPT_g_Group)) { 2621 if (A->getOption().matches(options::OPT_gline_tables_only)) 2622 CmdArgs.push_back("-gline-tables-only"); 2623 else if (A->getOption().matches(options::OPT_gdwarf_2)) 2624 CmdArgs.push_back("-gdwarf-2"); 2625 else if (A->getOption().matches(options::OPT_gdwarf_3)) 2626 CmdArgs.push_back("-gdwarf-3"); 2627 else if (A->getOption().matches(options::OPT_gdwarf_4)) 2628 CmdArgs.push_back("-gdwarf-4"); 2629 else if (!A->getOption().matches(options::OPT_g0) && 2630 !A->getOption().matches(options::OPT_ggdb0)) { 2631 // Default is dwarf-2 for darwin. 2632 if (getToolChain().getTriple().isOSDarwin()) 2633 CmdArgs.push_back("-gdwarf-2"); 2634 else 2635 CmdArgs.push_back("-g"); 2636 } 2637 } 2638 2639 // We ignore flags -gstrict-dwarf and -grecord-gcc-switches for now. 2640 Args.ClaimAllArgs(options::OPT_g_flags_Group); 2641 if (Args.hasArg(options::OPT_gcolumn_info)) 2642 CmdArgs.push_back("-dwarf-column-info"); 2643 2644 // FIXME: Move backend command line options to the module. 2645 // -gsplit-dwarf should turn on -g and enable the backend dwarf 2646 // splitting and extraction. 2647 // FIXME: Currently only works on Linux. 2648 if (getToolChain().getTriple().isOSLinux() && 2649 Args.hasArg(options::OPT_gsplit_dwarf)) { 2650 CmdArgs.push_back("-g"); 2651 CmdArgs.push_back("-backend-option"); 2652 CmdArgs.push_back("-split-dwarf=Enable"); 2653 } 2654 2655 // -ggnu-pubnames turns on gnu style pubnames in the backend. 2656 if (Args.hasArg(options::OPT_ggnu_pubnames)) { 2657 CmdArgs.push_back("-backend-option"); 2658 CmdArgs.push_back("-generate-gnu-dwarf-pub-sections"); 2659 } 2660 2661 Args.AddAllArgs(CmdArgs, options::OPT_fdebug_types_section); 2662 2663 Args.AddAllArgs(CmdArgs, options::OPT_ffunction_sections); 2664 Args.AddAllArgs(CmdArgs, options::OPT_fdata_sections); 2665 2666 Args.AddAllArgs(CmdArgs, options::OPT_finstrument_functions); 2667 2668 if (Args.hasArg(options::OPT_ftest_coverage) || 2669 Args.hasArg(options::OPT_coverage)) 2670 CmdArgs.push_back("-femit-coverage-notes"); 2671 if (Args.hasArg(options::OPT_fprofile_arcs) || 2672 Args.hasArg(options::OPT_coverage)) 2673 CmdArgs.push_back("-femit-coverage-data"); 2674 2675 if (C.getArgs().hasArg(options::OPT_c) || 2676 C.getArgs().hasArg(options::OPT_S)) { 2677 if (Output.isFilename()) { 2678 CmdArgs.push_back("-coverage-file"); 2679 SmallString<128> CoverageFilename(Output.getFilename()); 2680 if (llvm::sys::path::is_relative(CoverageFilename.str())) { 2681 SmallString<128> Pwd; 2682 if (!llvm::sys::fs::current_path(Pwd)) { 2683 llvm::sys::path::append(Pwd, CoverageFilename.str()); 2684 CoverageFilename.swap(Pwd); 2685 } 2686 } 2687 CmdArgs.push_back(Args.MakeArgString(CoverageFilename)); 2688 } 2689 } 2690 2691 // Pass options for controlling the default header search paths. 2692 if (Args.hasArg(options::OPT_nostdinc)) { 2693 CmdArgs.push_back("-nostdsysteminc"); 2694 CmdArgs.push_back("-nobuiltininc"); 2695 } else { 2696 if (Args.hasArg(options::OPT_nostdlibinc)) 2697 CmdArgs.push_back("-nostdsysteminc"); 2698 Args.AddLastArg(CmdArgs, options::OPT_nostdincxx); 2699 Args.AddLastArg(CmdArgs, options::OPT_nobuiltininc); 2700 } 2701 2702 // Pass the path to compiler resource files. 2703 CmdArgs.push_back("-resource-dir"); 2704 CmdArgs.push_back(D.ResourceDir.c_str()); 2705 2706 Args.AddLastArg(CmdArgs, options::OPT_working_directory); 2707 2708 bool ARCMTEnabled = false; 2709 if (!Args.hasArg(options::OPT_fno_objc_arc, options::OPT_fobjc_arc)) { 2710 if (const Arg *A = Args.getLastArg(options::OPT_ccc_arcmt_check, 2711 options::OPT_ccc_arcmt_modify, 2712 options::OPT_ccc_arcmt_migrate)) { 2713 ARCMTEnabled = true; 2714 switch (A->getOption().getID()) { 2715 default: 2716 llvm_unreachable("missed a case"); 2717 case options::OPT_ccc_arcmt_check: 2718 CmdArgs.push_back("-arcmt-check"); 2719 break; 2720 case options::OPT_ccc_arcmt_modify: 2721 CmdArgs.push_back("-arcmt-modify"); 2722 break; 2723 case options::OPT_ccc_arcmt_migrate: 2724 CmdArgs.push_back("-arcmt-migrate"); 2725 CmdArgs.push_back("-mt-migrate-directory"); 2726 CmdArgs.push_back(A->getValue()); 2727 2728 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_report_output); 2729 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_emit_arc_errors); 2730 break; 2731 } 2732 } 2733 } else { 2734 Args.ClaimAllArgs(options::OPT_ccc_arcmt_check); 2735 Args.ClaimAllArgs(options::OPT_ccc_arcmt_modify); 2736 Args.ClaimAllArgs(options::OPT_ccc_arcmt_migrate); 2737 } 2738 2739 if (const Arg *A = Args.getLastArg(options::OPT_ccc_objcmt_migrate)) { 2740 if (ARCMTEnabled) { 2741 D.Diag(diag::err_drv_argument_not_allowed_with) 2742 << A->getAsString(Args) << "-ccc-arcmt-migrate"; 2743 } 2744 CmdArgs.push_back("-mt-migrate-directory"); 2745 CmdArgs.push_back(A->getValue()); 2746 2747 if (!Args.hasArg(options::OPT_objcmt_migrate_literals, 2748 options::OPT_objcmt_migrate_subscripting, 2749 options::OPT_objcmt_migrate_property)) { 2750 // None specified, means enable them all. 2751 CmdArgs.push_back("-objcmt-migrate-literals"); 2752 CmdArgs.push_back("-objcmt-migrate-subscripting"); 2753 CmdArgs.push_back("-objcmt-migrate-property"); 2754 } else { 2755 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals); 2756 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting); 2757 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property); 2758 } 2759 } else { 2760 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals); 2761 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting); 2762 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property); 2763 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_all); 2764 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readonly_property); 2765 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readwrite_property); 2766 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_annotation); 2767 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_instancetype); 2768 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_nsmacros); 2769 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_protocol_conformance); 2770 Args.AddLastArg(CmdArgs, options::OPT_objcmt_atomic_property); 2771 Args.AddLastArg(CmdArgs, options::OPT_objcmt_returns_innerpointer_property); 2772 Args.AddLastArg(CmdArgs, options::OPT_objcmt_ns_nonatomic_iosonly); 2773 Args.AddLastArg(CmdArgs, options::OPT_objcmt_white_list_dir_path); 2774 } 2775 2776 // Add preprocessing options like -I, -D, etc. if we are using the 2777 // preprocessor. 2778 // 2779 // FIXME: Support -fpreprocessed 2780 if (types::getPreprocessedType(InputType) != types::TY_INVALID) 2781 AddPreprocessingOptions(C, JA, D, Args, CmdArgs, Output, Inputs); 2782 2783 // Don't warn about "clang -c -DPIC -fPIC test.i" because libtool.m4 assumes 2784 // that "The compiler can only warn and ignore the option if not recognized". 2785 // When building with ccache, it will pass -D options to clang even on 2786 // preprocessed inputs and configure concludes that -fPIC is not supported. 2787 Args.ClaimAllArgs(options::OPT_D); 2788 2789 // Manually translate -O4 to -O3; let clang reject others. 2790 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) { 2791 if (A->getOption().matches(options::OPT_O4)) { 2792 CmdArgs.push_back("-O3"); 2793 D.Diag(diag::warn_O4_is_O3); 2794 } else { 2795 A->render(Args, CmdArgs); 2796 } 2797 } 2798 2799 // Don't warn about unused -flto. This can happen when we're preprocessing or 2800 // precompiling. 2801 Args.ClaimAllArgs(options::OPT_flto); 2802 2803 Args.AddAllArgs(CmdArgs, options::OPT_W_Group); 2804 if (Args.hasFlag(options::OPT_pedantic, options::OPT_no_pedantic, false)) 2805 CmdArgs.push_back("-pedantic"); 2806 Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors); 2807 Args.AddLastArg(CmdArgs, options::OPT_w); 2808 2809 // Handle -{std, ansi, trigraphs} -- take the last of -{std, ansi} 2810 // (-ansi is equivalent to -std=c89 or -std=c++98). 2811 // 2812 // If a std is supplied, only add -trigraphs if it follows the 2813 // option. 2814 if (Arg *Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) { 2815 if (Std->getOption().matches(options::OPT_ansi)) 2816 if (types::isCXX(InputType)) 2817 CmdArgs.push_back("-std=c++98"); 2818 else 2819 CmdArgs.push_back("-std=c89"); 2820 else 2821 Std->render(Args, CmdArgs); 2822 2823 if (Arg *A = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi, 2824 options::OPT_trigraphs)) 2825 if (A != Std) 2826 A->render(Args, CmdArgs); 2827 } else { 2828 // Honor -std-default. 2829 // 2830 // FIXME: Clang doesn't correctly handle -std= when the input language 2831 // doesn't match. For the time being just ignore this for C++ inputs; 2832 // eventually we want to do all the standard defaulting here instead of 2833 // splitting it between the driver and clang -cc1. 2834 if (!types::isCXX(InputType)) 2835 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ, 2836 "-std=", /*Joined=*/true); 2837 else if (getToolChain().getTriple().getOS() == llvm::Triple::Win32) 2838 CmdArgs.push_back("-std=c++11"); 2839 2840 Args.AddLastArg(CmdArgs, options::OPT_trigraphs); 2841 } 2842 2843 // GCC's behavior for -Wwrite-strings is a bit strange: 2844 // * In C, this "warning flag" changes the types of string literals from 2845 // 'char[N]' to 'const char[N]', and thus triggers an unrelated warning 2846 // for the discarded qualifier. 2847 // * In C++, this is just a normal warning flag. 2848 // 2849 // Implementing this warning correctly in C is hard, so we follow GCC's 2850 // behavior for now. FIXME: Directly diagnose uses of a string literal as 2851 // a non-const char* in C, rather than using this crude hack. 2852 if (!types::isCXX(InputType)) { 2853 DiagnosticsEngine::Level DiagLevel = D.getDiags().getDiagnosticLevel( 2854 diag::warn_deprecated_string_literal_conversion_c, SourceLocation()); 2855 if (DiagLevel > DiagnosticsEngine::Ignored) 2856 CmdArgs.push_back("-fconst-strings"); 2857 } 2858 2859 // GCC provides a macro definition '__DEPRECATED' when -Wdeprecated is active 2860 // during C++ compilation, which it is by default. GCC keeps this define even 2861 // in the presence of '-w', match this behavior bug-for-bug. 2862 if (types::isCXX(InputType) && 2863 Args.hasFlag(options::OPT_Wdeprecated, options::OPT_Wno_deprecated, 2864 true)) { 2865 CmdArgs.push_back("-fdeprecated-macro"); 2866 } 2867 2868 // Translate GCC's misnamer '-fasm' arguments to '-fgnu-keywords'. 2869 if (Arg *Asm = Args.getLastArg(options::OPT_fasm, options::OPT_fno_asm)) { 2870 if (Asm->getOption().matches(options::OPT_fasm)) 2871 CmdArgs.push_back("-fgnu-keywords"); 2872 else 2873 CmdArgs.push_back("-fno-gnu-keywords"); 2874 } 2875 2876 if (ShouldDisableCFI(Args, getToolChain())) 2877 CmdArgs.push_back("-fno-dwarf2-cfi-asm"); 2878 2879 if (ShouldDisableDwarfDirectory(Args, getToolChain())) 2880 CmdArgs.push_back("-fno-dwarf-directory-asm"); 2881 2882 if (ShouldDisableAutolink(Args, getToolChain())) 2883 CmdArgs.push_back("-fno-autolink"); 2884 2885 // Add in -fdebug-compilation-dir if necessary. 2886 addDebugCompDirArg(Args, CmdArgs); 2887 2888 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_depth_, 2889 options::OPT_ftemplate_depth_EQ)) { 2890 CmdArgs.push_back("-ftemplate-depth"); 2891 CmdArgs.push_back(A->getValue()); 2892 } 2893 2894 if (Arg *A = Args.getLastArg(options::OPT_foperator_arrow_depth_EQ)) { 2895 CmdArgs.push_back("-foperator-arrow-depth"); 2896 CmdArgs.push_back(A->getValue()); 2897 } 2898 2899 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_depth_EQ)) { 2900 CmdArgs.push_back("-fconstexpr-depth"); 2901 CmdArgs.push_back(A->getValue()); 2902 } 2903 2904 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_steps_EQ)) { 2905 CmdArgs.push_back("-fconstexpr-steps"); 2906 CmdArgs.push_back(A->getValue()); 2907 } 2908 2909 if (Arg *A = Args.getLastArg(options::OPT_fbracket_depth_EQ)) { 2910 CmdArgs.push_back("-fbracket-depth"); 2911 CmdArgs.push_back(A->getValue()); 2912 } 2913 2914 if (Arg *A = Args.getLastArg(options::OPT_Wlarge_by_value_copy_EQ, 2915 options::OPT_Wlarge_by_value_copy_def)) { 2916 if (A->getNumValues()) { 2917 StringRef bytes = A->getValue(); 2918 CmdArgs.push_back(Args.MakeArgString("-Wlarge-by-value-copy=" + bytes)); 2919 } else 2920 CmdArgs.push_back("-Wlarge-by-value-copy=64"); // default value 2921 } 2922 2923 2924 if (Args.hasArg(options::OPT_relocatable_pch)) 2925 CmdArgs.push_back("-relocatable-pch"); 2926 2927 if (Arg *A = Args.getLastArg(options::OPT_fconstant_string_class_EQ)) { 2928 CmdArgs.push_back("-fconstant-string-class"); 2929 CmdArgs.push_back(A->getValue()); 2930 } 2931 2932 if (Arg *A = Args.getLastArg(options::OPT_ftabstop_EQ)) { 2933 CmdArgs.push_back("-ftabstop"); 2934 CmdArgs.push_back(A->getValue()); 2935 } 2936 2937 CmdArgs.push_back("-ferror-limit"); 2938 if (Arg *A = Args.getLastArg(options::OPT_ferror_limit_EQ)) 2939 CmdArgs.push_back(A->getValue()); 2940 else 2941 CmdArgs.push_back("19"); 2942 2943 if (Arg *A = Args.getLastArg(options::OPT_fmacro_backtrace_limit_EQ)) { 2944 CmdArgs.push_back("-fmacro-backtrace-limit"); 2945 CmdArgs.push_back(A->getValue()); 2946 } 2947 2948 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_backtrace_limit_EQ)) { 2949 CmdArgs.push_back("-ftemplate-backtrace-limit"); 2950 CmdArgs.push_back(A->getValue()); 2951 } 2952 2953 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_backtrace_limit_EQ)) { 2954 CmdArgs.push_back("-fconstexpr-backtrace-limit"); 2955 CmdArgs.push_back(A->getValue()); 2956 } 2957 2958 // Pass -fmessage-length=. 2959 CmdArgs.push_back("-fmessage-length"); 2960 if (Arg *A = Args.getLastArg(options::OPT_fmessage_length_EQ)) { 2961 CmdArgs.push_back(A->getValue()); 2962 } else { 2963 // If -fmessage-length=N was not specified, determine whether this is a 2964 // terminal and, if so, implicitly define -fmessage-length appropriately. 2965 unsigned N = llvm::sys::Process::StandardErrColumns(); 2966 CmdArgs.push_back(Args.MakeArgString(Twine(N))); 2967 } 2968 2969 // -fvisibility= and -fvisibility-ms-compat are of a piece. 2970 if (const Arg *A = Args.getLastArg(options::OPT_fvisibility_EQ, 2971 options::OPT_fvisibility_ms_compat)) { 2972 if (A->getOption().matches(options::OPT_fvisibility_EQ)) { 2973 CmdArgs.push_back("-fvisibility"); 2974 CmdArgs.push_back(A->getValue()); 2975 } else { 2976 assert(A->getOption().matches(options::OPT_fvisibility_ms_compat)); 2977 CmdArgs.push_back("-fvisibility"); 2978 CmdArgs.push_back("hidden"); 2979 CmdArgs.push_back("-ftype-visibility"); 2980 CmdArgs.push_back("default"); 2981 } 2982 } 2983 2984 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden); 2985 2986 Args.AddLastArg(CmdArgs, options::OPT_ftlsmodel_EQ); 2987 2988 // -fhosted is default. 2989 if (Args.hasFlag(options::OPT_ffreestanding, options::OPT_fhosted, false) || 2990 KernelOrKext) 2991 CmdArgs.push_back("-ffreestanding"); 2992 2993 // Forward -f (flag) options which we can pass directly. 2994 Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls); 2995 Args.AddLastArg(CmdArgs, options::OPT_fformat_extensions); 2996 Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions); 2997 Args.AddLastArg(CmdArgs, options::OPT_flimit_debug_info); 2998 Args.AddLastArg(CmdArgs, options::OPT_fno_limit_debug_info); 2999 Args.AddLastArg(CmdArgs, options::OPT_fno_operator_names); 3000 // AltiVec language extensions aren't relevant for assembling. 3001 if (!isa<PreprocessJobAction>(JA) || 3002 Output.getType() != types::TY_PP_Asm) 3003 Args.AddLastArg(CmdArgs, options::OPT_faltivec); 3004 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_show_template_tree); 3005 Args.AddLastArg(CmdArgs, options::OPT_fno_elide_type); 3006 3007 const SanitizerArgs &Sanitize = getToolChain().getSanitizerArgs(); 3008 Sanitize.addArgs(Args, CmdArgs); 3009 3010 if (!Args.hasFlag(options::OPT_fsanitize_recover, 3011 options::OPT_fno_sanitize_recover, 3012 true)) 3013 CmdArgs.push_back("-fno-sanitize-recover"); 3014 3015 if (Args.hasArg(options::OPT_fcatch_undefined_behavior) || 3016 Args.hasFlag(options::OPT_fsanitize_undefined_trap_on_error, 3017 options::OPT_fno_sanitize_undefined_trap_on_error, false)) 3018 CmdArgs.push_back("-fsanitize-undefined-trap-on-error"); 3019 3020 // Report an error for -faltivec on anything other than PowerPC. 3021 if (const Arg *A = Args.getLastArg(options::OPT_faltivec)) 3022 if (!(getToolChain().getArch() == llvm::Triple::ppc || 3023 getToolChain().getArch() == llvm::Triple::ppc64 || 3024 getToolChain().getArch() == llvm::Triple::ppc64le)) 3025 D.Diag(diag::err_drv_argument_only_allowed_with) 3026 << A->getAsString(Args) << "ppc/ppc64/ppc64le"; 3027 3028 if (getToolChain().SupportsProfiling()) 3029 Args.AddLastArg(CmdArgs, options::OPT_pg); 3030 3031 // -flax-vector-conversions is default. 3032 if (!Args.hasFlag(options::OPT_flax_vector_conversions, 3033 options::OPT_fno_lax_vector_conversions)) 3034 CmdArgs.push_back("-fno-lax-vector-conversions"); 3035 3036 if (Args.getLastArg(options::OPT_fapple_kext)) 3037 CmdArgs.push_back("-fapple-kext"); 3038 3039 if (Args.hasFlag(options::OPT_frewrite_includes, 3040 options::OPT_fno_rewrite_includes, false)) 3041 CmdArgs.push_back("-frewrite-includes"); 3042 3043 Args.AddLastArg(CmdArgs, options::OPT_fobjc_sender_dependent_dispatch); 3044 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_print_source_range_info); 3045 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_parseable_fixits); 3046 Args.AddLastArg(CmdArgs, options::OPT_ftime_report); 3047 Args.AddLastArg(CmdArgs, options::OPT_ftrapv); 3048 3049 if (Arg *A = Args.getLastArg(options::OPT_ftrapv_handler_EQ)) { 3050 CmdArgs.push_back("-ftrapv-handler"); 3051 CmdArgs.push_back(A->getValue()); 3052 } 3053 3054 Args.AddLastArg(CmdArgs, options::OPT_ftrap_function_EQ); 3055 3056 // -fno-strict-overflow implies -fwrapv if it isn't disabled, but 3057 // -fstrict-overflow won't turn off an explicitly enabled -fwrapv. 3058 if (Arg *A = Args.getLastArg(options::OPT_fwrapv, 3059 options::OPT_fno_wrapv)) { 3060 if (A->getOption().matches(options::OPT_fwrapv)) 3061 CmdArgs.push_back("-fwrapv"); 3062 } else if (Arg *A = Args.getLastArg(options::OPT_fstrict_overflow, 3063 options::OPT_fno_strict_overflow)) { 3064 if (A->getOption().matches(options::OPT_fno_strict_overflow)) 3065 CmdArgs.push_back("-fwrapv"); 3066 } 3067 3068 if (Arg *A = Args.getLastArg(options::OPT_freroll_loops, 3069 options::OPT_fno_reroll_loops)) 3070 if (A->getOption().matches(options::OPT_freroll_loops)) 3071 CmdArgs.push_back("-freroll-loops"); 3072 3073 Args.AddLastArg(CmdArgs, options::OPT_fwritable_strings); 3074 Args.AddLastArg(CmdArgs, options::OPT_funroll_loops, 3075 options::OPT_fno_unroll_loops); 3076 3077 Args.AddLastArg(CmdArgs, options::OPT_pthread); 3078 3079 3080 // -stack-protector=0 is default. 3081 unsigned StackProtectorLevel = 0; 3082 if (Arg *A = Args.getLastArg(options::OPT_fno_stack_protector, 3083 options::OPT_fstack_protector_all, 3084 options::OPT_fstack_protector)) { 3085 if (A->getOption().matches(options::OPT_fstack_protector)) 3086 StackProtectorLevel = 1; 3087 else if (A->getOption().matches(options::OPT_fstack_protector_all)) 3088 StackProtectorLevel = 2; 3089 } else { 3090 StackProtectorLevel = 3091 getToolChain().GetDefaultStackProtectorLevel(KernelOrKext); 3092 } 3093 if (StackProtectorLevel) { 3094 CmdArgs.push_back("-stack-protector"); 3095 CmdArgs.push_back(Args.MakeArgString(Twine(StackProtectorLevel))); 3096 } 3097 3098 // --param ssp-buffer-size= 3099 for (arg_iterator it = Args.filtered_begin(options::OPT__param), 3100 ie = Args.filtered_end(); it != ie; ++it) { 3101 StringRef Str((*it)->getValue()); 3102 if (Str.startswith("ssp-buffer-size=")) { 3103 if (StackProtectorLevel) { 3104 CmdArgs.push_back("-stack-protector-buffer-size"); 3105 // FIXME: Verify the argument is a valid integer. 3106 CmdArgs.push_back(Args.MakeArgString(Str.drop_front(16))); 3107 } 3108 (*it)->claim(); 3109 } 3110 } 3111 3112 // Translate -mstackrealign 3113 if (Args.hasFlag(options::OPT_mstackrealign, options::OPT_mno_stackrealign, 3114 false)) { 3115 CmdArgs.push_back("-backend-option"); 3116 CmdArgs.push_back("-force-align-stack"); 3117 } 3118 if (!Args.hasFlag(options::OPT_mno_stackrealign, options::OPT_mstackrealign, 3119 false)) { 3120 CmdArgs.push_back(Args.MakeArgString("-mstackrealign")); 3121 } 3122 3123 if (Args.hasArg(options::OPT_mstack_alignment)) { 3124 StringRef alignment = Args.getLastArgValue(options::OPT_mstack_alignment); 3125 CmdArgs.push_back(Args.MakeArgString("-mstack-alignment=" + alignment)); 3126 } 3127 // -mkernel implies -mstrict-align; don't add the redundant option. 3128 if (!KernelOrKext) { 3129 if (Arg *A = Args.getLastArg(options::OPT_mno_unaligned_access, 3130 options::OPT_munaligned_access)) { 3131 if (A->getOption().matches(options::OPT_mno_unaligned_access)) { 3132 CmdArgs.push_back("-backend-option"); 3133 CmdArgs.push_back("-arm-strict-align"); 3134 } else { 3135 CmdArgs.push_back("-backend-option"); 3136 CmdArgs.push_back("-arm-no-strict-align"); 3137 } 3138 } 3139 } 3140 3141 if (Arg *A = Args.getLastArg(options::OPT_mrestrict_it, 3142 options::OPT_mno_restrict_it)) { 3143 if (A->getOption().matches(options::OPT_mrestrict_it)) { 3144 CmdArgs.push_back("-backend-option"); 3145 CmdArgs.push_back("-arm-restrict-it"); 3146 } else { 3147 CmdArgs.push_back("-backend-option"); 3148 CmdArgs.push_back("-arm-no-restrict-it"); 3149 } 3150 } 3151 3152 // Forward -f options with positive and negative forms; we translate 3153 // these by hand. 3154 if (Arg *A = Args.getLastArg(options::OPT_fprofile_sample_use_EQ)) { 3155 StringRef fname = A->getValue(); 3156 if (!llvm::sys::fs::exists(fname)) 3157 D.Diag(diag::err_drv_no_such_file) << fname; 3158 else 3159 A->render(Args, CmdArgs); 3160 } 3161 3162 if (Args.hasArg(options::OPT_mkernel)) { 3163 if (!Args.hasArg(options::OPT_fapple_kext) && types::isCXX(InputType)) 3164 CmdArgs.push_back("-fapple-kext"); 3165 if (!Args.hasArg(options::OPT_fbuiltin)) 3166 CmdArgs.push_back("-fno-builtin"); 3167 Args.ClaimAllArgs(options::OPT_fno_builtin); 3168 } 3169 // -fbuiltin is default. 3170 else if (!Args.hasFlag(options::OPT_fbuiltin, options::OPT_fno_builtin)) 3171 CmdArgs.push_back("-fno-builtin"); 3172 3173 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new, 3174 options::OPT_fno_assume_sane_operator_new)) 3175 CmdArgs.push_back("-fno-assume-sane-operator-new"); 3176 3177 // -fblocks=0 is default. 3178 if (Args.hasFlag(options::OPT_fblocks, options::OPT_fno_blocks, 3179 getToolChain().IsBlocksDefault()) || 3180 (Args.hasArg(options::OPT_fgnu_runtime) && 3181 Args.hasArg(options::OPT_fobjc_nonfragile_abi) && 3182 !Args.hasArg(options::OPT_fno_blocks))) { 3183 CmdArgs.push_back("-fblocks"); 3184 3185 if (!Args.hasArg(options::OPT_fgnu_runtime) && 3186 !getToolChain().hasBlocksRuntime()) 3187 CmdArgs.push_back("-fblocks-runtime-optional"); 3188 } 3189 3190 // -fmodules enables modules (off by default). However, for C++/Objective-C++, 3191 // users must also pass -fcxx-modules. The latter flag will disappear once the 3192 // modules implementation is solid for C++/Objective-C++ programs as well. 3193 bool HaveModules = false; 3194 if (Args.hasFlag(options::OPT_fmodules, options::OPT_fno_modules, false)) { 3195 bool AllowedInCXX = Args.hasFlag(options::OPT_fcxx_modules, 3196 options::OPT_fno_cxx_modules, 3197 false); 3198 if (AllowedInCXX || !types::isCXX(InputType)) { 3199 CmdArgs.push_back("-fmodules"); 3200 HaveModules = true; 3201 } 3202 } 3203 3204 // -fmodule-maps enables module map processing (off by default) for header 3205 // checking. It is implied by -fmodules. 3206 if (Args.hasFlag(options::OPT_fmodule_maps, options::OPT_fno_module_maps, 3207 false)) { 3208 CmdArgs.push_back("-fmodule-maps"); 3209 } 3210 3211 // -fmodules-decluse checks that modules used are declared so (off by 3212 // default). 3213 if (Args.hasFlag(options::OPT_fmodules_decluse, 3214 options::OPT_fno_modules_decluse, 3215 false)) { 3216 CmdArgs.push_back("-fmodules-decluse"); 3217 } 3218 3219 // -fmodule-name specifies the module that is currently being built (or 3220 // used for header checking by -fmodule-maps). 3221 if (Arg *A = Args.getLastArg(options::OPT_fmodule_name)) { 3222 A->claim(); 3223 A->render(Args, CmdArgs); 3224 } 3225 3226 // -fmodule-map-file can be used to specify a file containing module 3227 // definitions. 3228 if (Arg *A = Args.getLastArg(options::OPT_fmodule_map_file)) { 3229 A->claim(); 3230 A->render(Args, CmdArgs); 3231 } 3232 3233 // If a module path was provided, pass it along. Otherwise, use a temporary 3234 // directory. 3235 if (Arg *A = Args.getLastArg(options::OPT_fmodules_cache_path)) { 3236 A->claim(); 3237 if (HaveModules) { 3238 A->render(Args, CmdArgs); 3239 } 3240 } else if (HaveModules) { 3241 SmallString<128> DefaultModuleCache; 3242 llvm::sys::path::system_temp_directory(/*erasedOnReboot=*/false, 3243 DefaultModuleCache); 3244 llvm::sys::path::append(DefaultModuleCache, "org.llvm.clang"); 3245 llvm::sys::path::append(DefaultModuleCache, "ModuleCache"); 3246 const char Arg[] = "-fmodules-cache-path="; 3247 DefaultModuleCache.insert(DefaultModuleCache.begin(), 3248 Arg, Arg + strlen(Arg)); 3249 CmdArgs.push_back(Args.MakeArgString(DefaultModuleCache)); 3250 } 3251 3252 // Pass through all -fmodules-ignore-macro arguments. 3253 Args.AddAllArgs(CmdArgs, options::OPT_fmodules_ignore_macro); 3254 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_interval); 3255 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_after); 3256 3257 // -faccess-control is default. 3258 if (Args.hasFlag(options::OPT_fno_access_control, 3259 options::OPT_faccess_control, 3260 false)) 3261 CmdArgs.push_back("-fno-access-control"); 3262 3263 // -felide-constructors is the default. 3264 if (Args.hasFlag(options::OPT_fno_elide_constructors, 3265 options::OPT_felide_constructors, 3266 false)) 3267 CmdArgs.push_back("-fno-elide-constructors"); 3268 3269 // -frtti is default. 3270 if (!Args.hasFlag(options::OPT_frtti, options::OPT_fno_rtti) || 3271 KernelOrKext) { 3272 CmdArgs.push_back("-fno-rtti"); 3273 3274 // -fno-rtti cannot usefully be combined with -fsanitize=vptr. 3275 if (Sanitize.sanitizesVptr()) { 3276 std::string NoRttiArg = 3277 Args.getLastArg(options::OPT_mkernel, 3278 options::OPT_fapple_kext, 3279 options::OPT_fno_rtti)->getAsString(Args); 3280 D.Diag(diag::err_drv_argument_not_allowed_with) 3281 << "-fsanitize=vptr" << NoRttiArg; 3282 } 3283 } 3284 3285 // -fshort-enums=0 is default for all architectures except Hexagon. 3286 if (Args.hasFlag(options::OPT_fshort_enums, 3287 options::OPT_fno_short_enums, 3288 getToolChain().getArch() == 3289 llvm::Triple::hexagon)) 3290 CmdArgs.push_back("-fshort-enums"); 3291 3292 // -fsigned-char is default. 3293 if (!Args.hasFlag(options::OPT_fsigned_char, options::OPT_funsigned_char, 3294 isSignedCharDefault(getToolChain().getTriple()))) 3295 CmdArgs.push_back("-fno-signed-char"); 3296 3297 // -fthreadsafe-static is default. 3298 if (!Args.hasFlag(options::OPT_fthreadsafe_statics, 3299 options::OPT_fno_threadsafe_statics)) 3300 CmdArgs.push_back("-fno-threadsafe-statics"); 3301 3302 // -fuse-cxa-atexit is default. 3303 if (!Args.hasFlag( 3304 options::OPT_fuse_cxa_atexit, options::OPT_fno_use_cxa_atexit, 3305 getToolChain().getTriple().getOS() != llvm::Triple::Cygwin && 3306 getToolChain().getTriple().getOS() != llvm::Triple::MinGW32 && 3307 getToolChain().getArch() != llvm::Triple::hexagon && 3308 getToolChain().getArch() != llvm::Triple::xcore) || 3309 KernelOrKext) 3310 CmdArgs.push_back("-fno-use-cxa-atexit"); 3311 3312 // -fms-extensions=0 is default. 3313 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions, 3314 getToolChain().getTriple().getOS() == llvm::Triple::Win32)) 3315 CmdArgs.push_back("-fms-extensions"); 3316 3317 // -fms-compatibility=0 is default. 3318 if (Args.hasFlag(options::OPT_fms_compatibility, 3319 options::OPT_fno_ms_compatibility, 3320 (getToolChain().getTriple().getOS() == llvm::Triple::Win32 && 3321 Args.hasFlag(options::OPT_fms_extensions, 3322 options::OPT_fno_ms_extensions, 3323 true)))) 3324 CmdArgs.push_back("-fms-compatibility"); 3325 3326 // -fmsc-version=1700 is default. 3327 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions, 3328 getToolChain().getTriple().getOS() == llvm::Triple::Win32) || 3329 Args.hasArg(options::OPT_fmsc_version)) { 3330 StringRef msc_ver = Args.getLastArgValue(options::OPT_fmsc_version); 3331 if (msc_ver.empty()) 3332 CmdArgs.push_back("-fmsc-version=1700"); 3333 else 3334 CmdArgs.push_back(Args.MakeArgString("-fmsc-version=" + msc_ver)); 3335 } 3336 3337 3338 // -fno-borland-extensions is default. 3339 if (Args.hasFlag(options::OPT_fborland_extensions, 3340 options::OPT_fno_borland_extensions, false)) 3341 CmdArgs.push_back("-fborland-extensions"); 3342 3343 // -fno-delayed-template-parsing is default, except for Windows where MSVC STL 3344 // needs it. 3345 if (Args.hasFlag(options::OPT_fdelayed_template_parsing, 3346 options::OPT_fno_delayed_template_parsing, 3347 getToolChain().getTriple().getOS() == llvm::Triple::Win32)) 3348 CmdArgs.push_back("-fdelayed-template-parsing"); 3349 3350 // -fgnu-keywords default varies depending on language; only pass if 3351 // specified. 3352 if (Arg *A = Args.getLastArg(options::OPT_fgnu_keywords, 3353 options::OPT_fno_gnu_keywords)) 3354 A->render(Args, CmdArgs); 3355 3356 if (Args.hasFlag(options::OPT_fgnu89_inline, 3357 options::OPT_fno_gnu89_inline, 3358 false)) 3359 CmdArgs.push_back("-fgnu89-inline"); 3360 3361 if (Args.hasArg(options::OPT_fno_inline)) 3362 CmdArgs.push_back("-fno-inline"); 3363 3364 if (Args.hasArg(options::OPT_fno_inline_functions)) 3365 CmdArgs.push_back("-fno-inline-functions"); 3366 3367 ObjCRuntime objcRuntime = AddObjCRuntimeArgs(Args, CmdArgs, rewriteKind); 3368 3369 // -fobjc-dispatch-method is only relevant with the nonfragile-abi, and 3370 // legacy is the default. Next runtime is always legacy dispatch and 3371 // -fno-objc-legacy-dispatch gets ignored silently. 3372 if (objcRuntime.isNonFragile() && !objcRuntime.isNeXTFamily()) { 3373 if (!Args.hasFlag(options::OPT_fobjc_legacy_dispatch, 3374 options::OPT_fno_objc_legacy_dispatch, 3375 objcRuntime.isLegacyDispatchDefaultForArch( 3376 getToolChain().getArch()))) { 3377 if (getToolChain().UseObjCMixedDispatch()) 3378 CmdArgs.push_back("-fobjc-dispatch-method=mixed"); 3379 else 3380 CmdArgs.push_back("-fobjc-dispatch-method=non-legacy"); 3381 } 3382 } 3383 3384 // When ObjectiveC legacy runtime is in effect on MacOSX, 3385 // turn on the option to do Array/Dictionary subscripting 3386 // by default. 3387 if (getToolChain().getTriple().getArch() == llvm::Triple::x86 && 3388 getToolChain().getTriple().isMacOSX() && 3389 !getToolChain().getTriple().isMacOSXVersionLT(10, 7) && 3390 objcRuntime.getKind() == ObjCRuntime::FragileMacOSX && 3391 objcRuntime.isNeXTFamily()) 3392 CmdArgs.push_back("-fobjc-subscripting-legacy-runtime"); 3393 3394 // -fencode-extended-block-signature=1 is default. 3395 if (getToolChain().IsEncodeExtendedBlockSignatureDefault()) { 3396 CmdArgs.push_back("-fencode-extended-block-signature"); 3397 } 3398 3399 // Allow -fno-objc-arr to trump -fobjc-arr/-fobjc-arc. 3400 // NOTE: This logic is duplicated in ToolChains.cpp. 3401 bool ARC = isObjCAutoRefCount(Args); 3402 if (ARC) { 3403 getToolChain().CheckObjCARC(); 3404 3405 CmdArgs.push_back("-fobjc-arc"); 3406 3407 // FIXME: It seems like this entire block, and several around it should be 3408 // wrapped in isObjC, but for now we just use it here as this is where it 3409 // was being used previously. 3410 if (types::isCXX(InputType) && types::isObjC(InputType)) { 3411 if (getToolChain().GetCXXStdlibType(Args) == ToolChain::CST_Libcxx) 3412 CmdArgs.push_back("-fobjc-arc-cxxlib=libc++"); 3413 else 3414 CmdArgs.push_back("-fobjc-arc-cxxlib=libstdc++"); 3415 } 3416 3417 // Allow the user to enable full exceptions code emission. 3418 // We define off for Objective-CC, on for Objective-C++. 3419 if (Args.hasFlag(options::OPT_fobjc_arc_exceptions, 3420 options::OPT_fno_objc_arc_exceptions, 3421 /*default*/ types::isCXX(InputType))) 3422 CmdArgs.push_back("-fobjc-arc-exceptions"); 3423 } 3424 3425 // -fobjc-infer-related-result-type is the default, except in the Objective-C 3426 // rewriter. 3427 if (rewriteKind != RK_None) 3428 CmdArgs.push_back("-fno-objc-infer-related-result-type"); 3429 3430 // Handle -fobjc-gc and -fobjc-gc-only. They are exclusive, and -fobjc-gc-only 3431 // takes precedence. 3432 const Arg *GCArg = Args.getLastArg(options::OPT_fobjc_gc_only); 3433 if (!GCArg) 3434 GCArg = Args.getLastArg(options::OPT_fobjc_gc); 3435 if (GCArg) { 3436 if (ARC) { 3437 D.Diag(diag::err_drv_objc_gc_arr) 3438 << GCArg->getAsString(Args); 3439 } else if (getToolChain().SupportsObjCGC()) { 3440 GCArg->render(Args, CmdArgs); 3441 } else { 3442 // FIXME: We should move this to a hard error. 3443 D.Diag(diag::warn_drv_objc_gc_unsupported) 3444 << GCArg->getAsString(Args); 3445 } 3446 } 3447 3448 // Add exception args. 3449 addExceptionArgs(Args, InputType, getToolChain().getTriple(), 3450 KernelOrKext, objcRuntime, CmdArgs); 3451 3452 if (getToolChain().UseSjLjExceptions()) 3453 CmdArgs.push_back("-fsjlj-exceptions"); 3454 3455 // C++ "sane" operator new. 3456 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new, 3457 options::OPT_fno_assume_sane_operator_new)) 3458 CmdArgs.push_back("-fno-assume-sane-operator-new"); 3459 3460 // -fconstant-cfstrings is default, and may be subject to argument translation 3461 // on Darwin. 3462 if (!Args.hasFlag(options::OPT_fconstant_cfstrings, 3463 options::OPT_fno_constant_cfstrings) || 3464 !Args.hasFlag(options::OPT_mconstant_cfstrings, 3465 options::OPT_mno_constant_cfstrings)) 3466 CmdArgs.push_back("-fno-constant-cfstrings"); 3467 3468 // -fshort-wchar default varies depending on platform; only 3469 // pass if specified. 3470 if (Arg *A = Args.getLastArg(options::OPT_fshort_wchar)) 3471 A->render(Args, CmdArgs); 3472 3473 // -fno-pascal-strings is default, only pass non-default. 3474 if (Args.hasFlag(options::OPT_fpascal_strings, 3475 options::OPT_fno_pascal_strings, 3476 false)) 3477 CmdArgs.push_back("-fpascal-strings"); 3478 3479 // Honor -fpack-struct= and -fpack-struct, if given. Note that 3480 // -fno-pack-struct doesn't apply to -fpack-struct=. 3481 if (Arg *A = Args.getLastArg(options::OPT_fpack_struct_EQ)) { 3482 std::string PackStructStr = "-fpack-struct="; 3483 PackStructStr += A->getValue(); 3484 CmdArgs.push_back(Args.MakeArgString(PackStructStr)); 3485 } else if (Args.hasFlag(options::OPT_fpack_struct, 3486 options::OPT_fno_pack_struct, false)) { 3487 CmdArgs.push_back("-fpack-struct=1"); 3488 } 3489 3490 if (KernelOrKext || isNoCommonDefault(getToolChain().getTriple())) { 3491 if (!Args.hasArg(options::OPT_fcommon)) 3492 CmdArgs.push_back("-fno-common"); 3493 Args.ClaimAllArgs(options::OPT_fno_common); 3494 } 3495 3496 // -fcommon is default, only pass non-default. 3497 else if (!Args.hasFlag(options::OPT_fcommon, options::OPT_fno_common)) 3498 CmdArgs.push_back("-fno-common"); 3499 3500 // -fsigned-bitfields is default, and clang doesn't yet support 3501 // -funsigned-bitfields. 3502 if (!Args.hasFlag(options::OPT_fsigned_bitfields, 3503 options::OPT_funsigned_bitfields)) 3504 D.Diag(diag::warn_drv_clang_unsupported) 3505 << Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args); 3506 3507 // -fsigned-bitfields is default, and clang doesn't support -fno-for-scope. 3508 if (!Args.hasFlag(options::OPT_ffor_scope, 3509 options::OPT_fno_for_scope)) 3510 D.Diag(diag::err_drv_clang_unsupported) 3511 << Args.getLastArg(options::OPT_fno_for_scope)->getAsString(Args); 3512 3513 // -fcaret-diagnostics is default. 3514 if (!Args.hasFlag(options::OPT_fcaret_diagnostics, 3515 options::OPT_fno_caret_diagnostics, true)) 3516 CmdArgs.push_back("-fno-caret-diagnostics"); 3517 3518 // -fdiagnostics-fixit-info is default, only pass non-default. 3519 if (!Args.hasFlag(options::OPT_fdiagnostics_fixit_info, 3520 options::OPT_fno_diagnostics_fixit_info)) 3521 CmdArgs.push_back("-fno-diagnostics-fixit-info"); 3522 3523 // Enable -fdiagnostics-show-option by default. 3524 if (Args.hasFlag(options::OPT_fdiagnostics_show_option, 3525 options::OPT_fno_diagnostics_show_option)) 3526 CmdArgs.push_back("-fdiagnostics-show-option"); 3527 3528 if (const Arg *A = 3529 Args.getLastArg(options::OPT_fdiagnostics_show_category_EQ)) { 3530 CmdArgs.push_back("-fdiagnostics-show-category"); 3531 CmdArgs.push_back(A->getValue()); 3532 } 3533 3534 if (const Arg *A = 3535 Args.getLastArg(options::OPT_fdiagnostics_format_EQ)) { 3536 CmdArgs.push_back("-fdiagnostics-format"); 3537 CmdArgs.push_back(A->getValue()); 3538 } 3539 3540 if (Arg *A = Args.getLastArg( 3541 options::OPT_fdiagnostics_show_note_include_stack, 3542 options::OPT_fno_diagnostics_show_note_include_stack)) { 3543 if (A->getOption().matches( 3544 options::OPT_fdiagnostics_show_note_include_stack)) 3545 CmdArgs.push_back("-fdiagnostics-show-note-include-stack"); 3546 else 3547 CmdArgs.push_back("-fno-diagnostics-show-note-include-stack"); 3548 } 3549 3550 // Color diagnostics are the default, unless the terminal doesn't support 3551 // them. 3552 // Support both clang's -f[no-]color-diagnostics and gcc's 3553 // -f[no-]diagnostics-colors[=never|always|auto]. 3554 enum { Colors_On, Colors_Off, Colors_Auto } ShowColors = Colors_Auto; 3555 for (ArgList::const_iterator it = Args.begin(), ie = Args.end(); 3556 it != ie; ++it) { 3557 const Option &O = (*it)->getOption(); 3558 if (!O.matches(options::OPT_fcolor_diagnostics) && 3559 !O.matches(options::OPT_fdiagnostics_color) && 3560 !O.matches(options::OPT_fno_color_diagnostics) && 3561 !O.matches(options::OPT_fno_diagnostics_color) && 3562 !O.matches(options::OPT_fdiagnostics_color_EQ)) 3563 continue; 3564 3565 (*it)->claim(); 3566 if (O.matches(options::OPT_fcolor_diagnostics) || 3567 O.matches(options::OPT_fdiagnostics_color)) { 3568 ShowColors = Colors_On; 3569 } else if (O.matches(options::OPT_fno_color_diagnostics) || 3570 O.matches(options::OPT_fno_diagnostics_color)) { 3571 ShowColors = Colors_Off; 3572 } else { 3573 assert(O.matches(options::OPT_fdiagnostics_color_EQ)); 3574 StringRef value((*it)->getValue()); 3575 if (value == "always") 3576 ShowColors = Colors_On; 3577 else if (value == "never") 3578 ShowColors = Colors_Off; 3579 else if (value == "auto") 3580 ShowColors = Colors_Auto; 3581 else 3582 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported) 3583 << ("-fdiagnostics-color=" + value).str(); 3584 } 3585 } 3586 if (ShowColors == Colors_On || 3587 (ShowColors == Colors_Auto && llvm::sys::Process::StandardErrHasColors())) 3588 CmdArgs.push_back("-fcolor-diagnostics"); 3589 3590 if (Args.hasArg(options::OPT_fansi_escape_codes)) 3591 CmdArgs.push_back("-fansi-escape-codes"); 3592 3593 if (!Args.hasFlag(options::OPT_fshow_source_location, 3594 options::OPT_fno_show_source_location)) 3595 CmdArgs.push_back("-fno-show-source-location"); 3596 3597 if (!Args.hasFlag(options::OPT_fshow_column, 3598 options::OPT_fno_show_column, 3599 true)) 3600 CmdArgs.push_back("-fno-show-column"); 3601 3602 if (!Args.hasFlag(options::OPT_fspell_checking, 3603 options::OPT_fno_spell_checking)) 3604 CmdArgs.push_back("-fno-spell-checking"); 3605 3606 3607 // -fno-asm-blocks is default. 3608 if (Args.hasFlag(options::OPT_fasm_blocks, options::OPT_fno_asm_blocks, 3609 false)) 3610 CmdArgs.push_back("-fasm-blocks"); 3611 3612 // Enable vectorization per default according to the optimization level 3613 // selected. For optimization levels that want vectorization we use the alias 3614 // option to simplify the hasFlag logic. 3615 bool EnableVec = shouldEnableVectorizerAtOLevel(Args); 3616 OptSpecifier VectorizeAliasOption = EnableVec ? options::OPT_O_Group : 3617 options::OPT_fvectorize; 3618 if (Args.hasFlag(options::OPT_fvectorize, VectorizeAliasOption, 3619 options::OPT_fno_vectorize, EnableVec)) 3620 CmdArgs.push_back("-vectorize-loops"); 3621 3622 // -fslp-vectorize is default. 3623 if (Args.hasFlag(options::OPT_fslp_vectorize, 3624 options::OPT_fno_slp_vectorize, true)) 3625 CmdArgs.push_back("-vectorize-slp"); 3626 3627 // -fno-slp-vectorize-aggressive is default. 3628 if (Args.hasFlag(options::OPT_fslp_vectorize_aggressive, 3629 options::OPT_fno_slp_vectorize_aggressive, false)) 3630 CmdArgs.push_back("-vectorize-slp-aggressive"); 3631 3632 if (Arg *A = Args.getLastArg(options::OPT_fshow_overloads_EQ)) 3633 A->render(Args, CmdArgs); 3634 3635 // -fdollars-in-identifiers default varies depending on platform and 3636 // language; only pass if specified. 3637 if (Arg *A = Args.getLastArg(options::OPT_fdollars_in_identifiers, 3638 options::OPT_fno_dollars_in_identifiers)) { 3639 if (A->getOption().matches(options::OPT_fdollars_in_identifiers)) 3640 CmdArgs.push_back("-fdollars-in-identifiers"); 3641 else 3642 CmdArgs.push_back("-fno-dollars-in-identifiers"); 3643 } 3644 3645 // -funit-at-a-time is default, and we don't support -fno-unit-at-a-time for 3646 // practical purposes. 3647 if (Arg *A = Args.getLastArg(options::OPT_funit_at_a_time, 3648 options::OPT_fno_unit_at_a_time)) { 3649 if (A->getOption().matches(options::OPT_fno_unit_at_a_time)) 3650 D.Diag(diag::warn_drv_clang_unsupported) << A->getAsString(Args); 3651 } 3652 3653 if (Args.hasFlag(options::OPT_fapple_pragma_pack, 3654 options::OPT_fno_apple_pragma_pack, false)) 3655 CmdArgs.push_back("-fapple-pragma-pack"); 3656 3657 // le32-specific flags: 3658 // -fno-math-builtin: clang should not convert math builtins to intrinsics 3659 // by default. 3660 if (getToolChain().getArch() == llvm::Triple::le32) { 3661 CmdArgs.push_back("-fno-math-builtin"); 3662 } 3663 3664 // Default to -fno-builtin-str{cat,cpy} on Darwin for ARM. 3665 // 3666 // FIXME: This is disabled until clang -cc1 supports -fno-builtin-foo. PR4941. 3667#if 0 3668 if (getToolChain().getTriple().isOSDarwin() && 3669 (getToolChain().getArch() == llvm::Triple::arm || 3670 getToolChain().getArch() == llvm::Triple::thumb)) { 3671 if (!Args.hasArg(options::OPT_fbuiltin_strcat)) 3672 CmdArgs.push_back("-fno-builtin-strcat"); 3673 if (!Args.hasArg(options::OPT_fbuiltin_strcpy)) 3674 CmdArgs.push_back("-fno-builtin-strcpy"); 3675 } 3676#endif 3677 3678 // Only allow -traditional or -traditional-cpp outside in preprocessing modes. 3679 if (Arg *A = Args.getLastArg(options::OPT_traditional, 3680 options::OPT_traditional_cpp)) { 3681 if (isa<PreprocessJobAction>(JA)) 3682 CmdArgs.push_back("-traditional-cpp"); 3683 else 3684 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args); 3685 } 3686 3687 Args.AddLastArg(CmdArgs, options::OPT_dM); 3688 Args.AddLastArg(CmdArgs, options::OPT_dD); 3689 3690 // Handle serialized diagnostics. 3691 if (Arg *A = Args.getLastArg(options::OPT__serialize_diags)) { 3692 CmdArgs.push_back("-serialize-diagnostic-file"); 3693 CmdArgs.push_back(Args.MakeArgString(A->getValue())); 3694 } 3695 3696 if (Args.hasArg(options::OPT_fretain_comments_from_system_headers)) 3697 CmdArgs.push_back("-fretain-comments-from-system-headers"); 3698 3699 // Forward -fcomment-block-commands to -cc1. 3700 Args.AddAllArgs(CmdArgs, options::OPT_fcomment_block_commands); 3701 // Forward -fparse-all-comments to -cc1. 3702 Args.AddAllArgs(CmdArgs, options::OPT_fparse_all_comments); 3703 3704 // Forward -Xclang arguments to -cc1, and -mllvm arguments to the LLVM option 3705 // parser. 3706 Args.AddAllArgValues(CmdArgs, options::OPT_Xclang); 3707 for (arg_iterator it = Args.filtered_begin(options::OPT_mllvm), 3708 ie = Args.filtered_end(); it != ie; ++it) { 3709 (*it)->claim(); 3710 3711 // We translate this by hand to the -cc1 argument, since nightly test uses 3712 // it and developers have been trained to spell it with -mllvm. 3713 if (StringRef((*it)->getValue(0)) == "-disable-llvm-optzns") 3714 CmdArgs.push_back("-disable-llvm-optzns"); 3715 else 3716 (*it)->render(Args, CmdArgs); 3717 } 3718 3719 if (Output.getType() == types::TY_Dependencies) { 3720 // Handled with other dependency code. 3721 } else if (Output.isFilename()) { 3722 CmdArgs.push_back("-o"); 3723 CmdArgs.push_back(Output.getFilename()); 3724 } else { 3725 assert(Output.isNothing() && "Invalid output."); 3726 } 3727 3728 for (InputInfoList::const_iterator 3729 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 3730 const InputInfo &II = *it; 3731 CmdArgs.push_back("-x"); 3732 if (Args.hasArg(options::OPT_rewrite_objc)) 3733 CmdArgs.push_back(types::getTypeName(types::TY_PP_ObjCXX)); 3734 else 3735 CmdArgs.push_back(types::getTypeName(II.getType())); 3736 if (II.isFilename()) 3737 CmdArgs.push_back(II.getFilename()); 3738 else 3739 II.getInputArg().renderAsInput(Args, CmdArgs); 3740 } 3741 3742 Args.AddAllArgs(CmdArgs, options::OPT_undef); 3743 3744 const char *Exec = getToolChain().getDriver().getClangProgramPath(); 3745 3746 // Optionally embed the -cc1 level arguments into the debug info, for build 3747 // analysis. 3748 if (getToolChain().UseDwarfDebugFlags()) { 3749 ArgStringList OriginalArgs; 3750 for (ArgList::const_iterator it = Args.begin(), 3751 ie = Args.end(); it != ie; ++it) 3752 (*it)->render(Args, OriginalArgs); 3753 3754 SmallString<256> Flags; 3755 Flags += Exec; 3756 for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) { 3757 Flags += " "; 3758 Flags += OriginalArgs[i]; 3759 } 3760 CmdArgs.push_back("-dwarf-debug-flags"); 3761 CmdArgs.push_back(Args.MakeArgString(Flags.str())); 3762 } 3763 3764 // Add the split debug info name to the command lines here so we 3765 // can propagate it to the backend. 3766 bool SplitDwarf = Args.hasArg(options::OPT_gsplit_dwarf) && 3767 getToolChain().getTriple().isOSLinux() && 3768 (isa<AssembleJobAction>(JA) || isa<CompileJobAction>(JA)); 3769 const char *SplitDwarfOut; 3770 if (SplitDwarf) { 3771 CmdArgs.push_back("-split-dwarf-file"); 3772 SplitDwarfOut = SplitDebugName(Args, Inputs); 3773 CmdArgs.push_back(SplitDwarfOut); 3774 } 3775 3776 // Finally add the compile command to the compilation. 3777 if (Args.hasArg(options::OPT__SLASH_fallback)) { 3778 tools::visualstudio::Compile CL(getToolChain()); 3779 Command *CLCommand = CL.GetCommand(C, JA, Output, Inputs, Args, 3780 LinkingOutput); 3781 C.addCommand(new FallbackCommand(JA, *this, Exec, CmdArgs, CLCommand)); 3782 } else { 3783 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 3784 } 3785 3786 3787 // Handle the debug info splitting at object creation time if we're 3788 // creating an object. 3789 // TODO: Currently only works on linux with newer objcopy. 3790 if (SplitDwarf && !isa<CompileJobAction>(JA)) 3791 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output, SplitDwarfOut); 3792 3793 if (Arg *A = Args.getLastArg(options::OPT_pg)) 3794 if (Args.hasArg(options::OPT_fomit_frame_pointer)) 3795 D.Diag(diag::err_drv_argument_not_allowed_with) 3796 << "-fomit-frame-pointer" << A->getAsString(Args); 3797 3798 // Claim some arguments which clang supports automatically. 3799 3800 // -fpch-preprocess is used with gcc to add a special marker in the output to 3801 // include the PCH file. Clang's PTH solution is completely transparent, so we 3802 // do not need to deal with it at all. 3803 Args.ClaimAllArgs(options::OPT_fpch_preprocess); 3804 3805 // Claim some arguments which clang doesn't support, but we don't 3806 // care to warn the user about. 3807 Args.ClaimAllArgs(options::OPT_clang_ignored_f_Group); 3808 Args.ClaimAllArgs(options::OPT_clang_ignored_m_Group); 3809 3810 // Disable warnings for clang -E -emit-llvm foo.c 3811 Args.ClaimAllArgs(options::OPT_emit_llvm); 3812} 3813 3814/// Add options related to the Objective-C runtime/ABI. 3815/// 3816/// Returns true if the runtime is non-fragile. 3817ObjCRuntime Clang::AddObjCRuntimeArgs(const ArgList &args, 3818 ArgStringList &cmdArgs, 3819 RewriteKind rewriteKind) const { 3820 // Look for the controlling runtime option. 3821 Arg *runtimeArg = args.getLastArg(options::OPT_fnext_runtime, 3822 options::OPT_fgnu_runtime, 3823 options::OPT_fobjc_runtime_EQ); 3824 3825 // Just forward -fobjc-runtime= to the frontend. This supercedes 3826 // options about fragility. 3827 if (runtimeArg && 3828 runtimeArg->getOption().matches(options::OPT_fobjc_runtime_EQ)) { 3829 ObjCRuntime runtime; 3830 StringRef value = runtimeArg->getValue(); 3831 if (runtime.tryParse(value)) { 3832 getToolChain().getDriver().Diag(diag::err_drv_unknown_objc_runtime) 3833 << value; 3834 } 3835 3836 runtimeArg->render(args, cmdArgs); 3837 return runtime; 3838 } 3839 3840 // Otherwise, we'll need the ABI "version". Version numbers are 3841 // slightly confusing for historical reasons: 3842 // 1 - Traditional "fragile" ABI 3843 // 2 - Non-fragile ABI, version 1 3844 // 3 - Non-fragile ABI, version 2 3845 unsigned objcABIVersion = 1; 3846 // If -fobjc-abi-version= is present, use that to set the version. 3847 if (Arg *abiArg = args.getLastArg(options::OPT_fobjc_abi_version_EQ)) { 3848 StringRef value = abiArg->getValue(); 3849 if (value == "1") 3850 objcABIVersion = 1; 3851 else if (value == "2") 3852 objcABIVersion = 2; 3853 else if (value == "3") 3854 objcABIVersion = 3; 3855 else 3856 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported) 3857 << value; 3858 } else { 3859 // Otherwise, determine if we are using the non-fragile ABI. 3860 bool nonFragileABIIsDefault = 3861 (rewriteKind == RK_NonFragile || 3862 (rewriteKind == RK_None && 3863 getToolChain().IsObjCNonFragileABIDefault())); 3864 if (args.hasFlag(options::OPT_fobjc_nonfragile_abi, 3865 options::OPT_fno_objc_nonfragile_abi, 3866 nonFragileABIIsDefault)) { 3867 // Determine the non-fragile ABI version to use. 3868#ifdef DISABLE_DEFAULT_NONFRAGILEABI_TWO 3869 unsigned nonFragileABIVersion = 1; 3870#else 3871 unsigned nonFragileABIVersion = 2; 3872#endif 3873 3874 if (Arg *abiArg = args.getLastArg( 3875 options::OPT_fobjc_nonfragile_abi_version_EQ)) { 3876 StringRef value = abiArg->getValue(); 3877 if (value == "1") 3878 nonFragileABIVersion = 1; 3879 else if (value == "2") 3880 nonFragileABIVersion = 2; 3881 else 3882 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported) 3883 << value; 3884 } 3885 3886 objcABIVersion = 1 + nonFragileABIVersion; 3887 } else { 3888 objcABIVersion = 1; 3889 } 3890 } 3891 3892 // We don't actually care about the ABI version other than whether 3893 // it's non-fragile. 3894 bool isNonFragile = objcABIVersion != 1; 3895 3896 // If we have no runtime argument, ask the toolchain for its default runtime. 3897 // However, the rewriter only really supports the Mac runtime, so assume that. 3898 ObjCRuntime runtime; 3899 if (!runtimeArg) { 3900 switch (rewriteKind) { 3901 case RK_None: 3902 runtime = getToolChain().getDefaultObjCRuntime(isNonFragile); 3903 break; 3904 case RK_Fragile: 3905 runtime = ObjCRuntime(ObjCRuntime::FragileMacOSX, VersionTuple()); 3906 break; 3907 case RK_NonFragile: 3908 runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple()); 3909 break; 3910 } 3911 3912 // -fnext-runtime 3913 } else if (runtimeArg->getOption().matches(options::OPT_fnext_runtime)) { 3914 // On Darwin, make this use the default behavior for the toolchain. 3915 if (getToolChain().getTriple().isOSDarwin()) { 3916 runtime = getToolChain().getDefaultObjCRuntime(isNonFragile); 3917 3918 // Otherwise, build for a generic macosx port. 3919 } else { 3920 runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple()); 3921 } 3922 3923 // -fgnu-runtime 3924 } else { 3925 assert(runtimeArg->getOption().matches(options::OPT_fgnu_runtime)); 3926 // Legacy behaviour is to target the gnustep runtime if we are i 3927 // non-fragile mode or the GCC runtime in fragile mode. 3928 if (isNonFragile) 3929 runtime = ObjCRuntime(ObjCRuntime::GNUstep, VersionTuple(1,6)); 3930 else 3931 runtime = ObjCRuntime(ObjCRuntime::GCC, VersionTuple()); 3932 } 3933 3934 cmdArgs.push_back(args.MakeArgString( 3935 "-fobjc-runtime=" + runtime.getAsString())); 3936 return runtime; 3937} 3938 3939void Clang::AddClangCLArgs(const ArgList &Args, ArgStringList &CmdArgs) const { 3940 unsigned RTOptionID = options::OPT__SLASH_MT; 3941 3942 if (Args.hasArg(options::OPT__SLASH_LDd)) 3943 // The /LDd option implies /MTd. The dependent lib part can be overridden, 3944 // but defining _DEBUG is sticky. 3945 RTOptionID = options::OPT__SLASH_MTd; 3946 3947 if (Arg *A = Args.getLastArg(options::OPT__SLASH_M_Group)) 3948 RTOptionID = A->getOption().getID(); 3949 3950 switch(RTOptionID) { 3951 case options::OPT__SLASH_MD: 3952 if (Args.hasArg(options::OPT__SLASH_LDd)) 3953 CmdArgs.push_back("-D_DEBUG"); 3954 CmdArgs.push_back("-D_MT"); 3955 CmdArgs.push_back("-D_DLL"); 3956 CmdArgs.push_back("--dependent-lib=msvcrt"); 3957 break; 3958 case options::OPT__SLASH_MDd: 3959 CmdArgs.push_back("-D_DEBUG"); 3960 CmdArgs.push_back("-D_MT"); 3961 CmdArgs.push_back("-D_DLL"); 3962 CmdArgs.push_back("--dependent-lib=msvcrtd"); 3963 break; 3964 case options::OPT__SLASH_MT: 3965 if (Args.hasArg(options::OPT__SLASH_LDd)) 3966 CmdArgs.push_back("-D_DEBUG"); 3967 CmdArgs.push_back("-D_MT"); 3968 CmdArgs.push_back("--dependent-lib=libcmt"); 3969 break; 3970 case options::OPT__SLASH_MTd: 3971 CmdArgs.push_back("-D_DEBUG"); 3972 CmdArgs.push_back("-D_MT"); 3973 CmdArgs.push_back("--dependent-lib=libcmtd"); 3974 break; 3975 default: 3976 llvm_unreachable("Unexpected option ID."); 3977 } 3978 3979 // This provides POSIX compatibility (maps 'open' to '_open'), which most 3980 // users want. The /Za flag to cl.exe turns this off, but it's not 3981 // implemented in clang. 3982 CmdArgs.push_back("--dependent-lib=oldnames"); 3983 3984 // FIXME: Make this default for the win32 triple. 3985 CmdArgs.push_back("-cxx-abi"); 3986 CmdArgs.push_back("microsoft"); 3987 3988 if (Arg *A = Args.getLastArg(options::OPT_show_includes)) 3989 A->render(Args, CmdArgs); 3990 3991 if (!Args.hasArg(options::OPT_fdiagnostics_format_EQ)) { 3992 CmdArgs.push_back("-fdiagnostics-format"); 3993 if (Args.hasArg(options::OPT__SLASH_fallback)) 3994 CmdArgs.push_back("msvc-fallback"); 3995 else 3996 CmdArgs.push_back("msvc"); 3997 } 3998} 3999 4000void ClangAs::ConstructJob(Compilation &C, const JobAction &JA, 4001 const InputInfo &Output, 4002 const InputInfoList &Inputs, 4003 const ArgList &Args, 4004 const char *LinkingOutput) const { 4005 ArgStringList CmdArgs; 4006 4007 assert(Inputs.size() == 1 && "Unexpected number of inputs."); 4008 const InputInfo &Input = Inputs[0]; 4009 4010 // Don't warn about "clang -w -c foo.s" 4011 Args.ClaimAllArgs(options::OPT_w); 4012 // and "clang -emit-llvm -c foo.s" 4013 Args.ClaimAllArgs(options::OPT_emit_llvm); 4014 4015 // Invoke ourselves in -cc1as mode. 4016 // 4017 // FIXME: Implement custom jobs for internal actions. 4018 CmdArgs.push_back("-cc1as"); 4019 4020 // Add the "effective" target triple. 4021 CmdArgs.push_back("-triple"); 4022 std::string TripleStr = 4023 getToolChain().ComputeEffectiveClangTriple(Args, Input.getType()); 4024 CmdArgs.push_back(Args.MakeArgString(TripleStr)); 4025 4026 // Set the output mode, we currently only expect to be used as a real 4027 // assembler. 4028 CmdArgs.push_back("-filetype"); 4029 CmdArgs.push_back("obj"); 4030 4031 // Set the main file name, so that debug info works even with 4032 // -save-temps or preprocessed assembly. 4033 CmdArgs.push_back("-main-file-name"); 4034 CmdArgs.push_back(Clang::getBaseInputName(Args, Inputs)); 4035 4036 // Add the target cpu 4037 const llvm::Triple &Triple = getToolChain().getTriple(); 4038 std::string CPU = getCPUName(Args, Triple); 4039 if (!CPU.empty()) { 4040 CmdArgs.push_back("-target-cpu"); 4041 CmdArgs.push_back(Args.MakeArgString(CPU)); 4042 } 4043 4044 // Add the target features 4045 const Driver &D = getToolChain().getDriver(); 4046 getTargetFeatures(D, Triple, Args, CmdArgs); 4047 4048 // Ignore explicit -force_cpusubtype_ALL option. 4049 (void) Args.hasArg(options::OPT_force__cpusubtype__ALL); 4050 4051 // Determine the original source input. 4052 const Action *SourceAction = &JA; 4053 while (SourceAction->getKind() != Action::InputClass) { 4054 assert(!SourceAction->getInputs().empty() && "unexpected root action!"); 4055 SourceAction = SourceAction->getInputs()[0]; 4056 } 4057 4058 // Forward -g and handle debug info related flags, assuming we are dealing 4059 // with an actual assembly file. 4060 if (SourceAction->getType() == types::TY_Asm || 4061 SourceAction->getType() == types::TY_PP_Asm) { 4062 Args.ClaimAllArgs(options::OPT_g_Group); 4063 if (Arg *A = Args.getLastArg(options::OPT_g_Group)) 4064 if (!A->getOption().matches(options::OPT_g0)) 4065 CmdArgs.push_back("-g"); 4066 4067 // Add the -fdebug-compilation-dir flag if needed. 4068 addDebugCompDirArg(Args, CmdArgs); 4069 4070 // Set the AT_producer to the clang version when using the integrated 4071 // assembler on assembly source files. 4072 CmdArgs.push_back("-dwarf-debug-producer"); 4073 CmdArgs.push_back(Args.MakeArgString(getClangFullVersion())); 4074 } 4075 4076 // Optionally embed the -cc1as level arguments into the debug info, for build 4077 // analysis. 4078 if (getToolChain().UseDwarfDebugFlags()) { 4079 ArgStringList OriginalArgs; 4080 for (ArgList::const_iterator it = Args.begin(), 4081 ie = Args.end(); it != ie; ++it) 4082 (*it)->render(Args, OriginalArgs); 4083 4084 SmallString<256> Flags; 4085 const char *Exec = getToolChain().getDriver().getClangProgramPath(); 4086 Flags += Exec; 4087 for (unsigned i = 0, e = OriginalArgs.size(); i != e; ++i) { 4088 Flags += " "; 4089 Flags += OriginalArgs[i]; 4090 } 4091 CmdArgs.push_back("-dwarf-debug-flags"); 4092 CmdArgs.push_back(Args.MakeArgString(Flags.str())); 4093 } 4094 4095 // FIXME: Add -static support, once we have it. 4096 4097 CollectArgsForIntegratedAssembler(C, Args, CmdArgs, 4098 getToolChain().getDriver()); 4099 4100 Args.AddAllArgs(CmdArgs, options::OPT_mllvm); 4101 4102 assert(Output.isFilename() && "Unexpected lipo output."); 4103 CmdArgs.push_back("-o"); 4104 CmdArgs.push_back(Output.getFilename()); 4105 4106 assert(Input.isFilename() && "Invalid input."); 4107 CmdArgs.push_back(Input.getFilename()); 4108 4109 const char *Exec = getToolChain().getDriver().getClangProgramPath(); 4110 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 4111 4112 // Handle the debug info splitting at object creation time if we're 4113 // creating an object. 4114 // TODO: Currently only works on linux with newer objcopy. 4115 if (Args.hasArg(options::OPT_gsplit_dwarf) && 4116 getToolChain().getTriple().isOSLinux()) 4117 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output, 4118 SplitDebugName(Args, Inputs)); 4119} 4120 4121void gcc::Common::ConstructJob(Compilation &C, const JobAction &JA, 4122 const InputInfo &Output, 4123 const InputInfoList &Inputs, 4124 const ArgList &Args, 4125 const char *LinkingOutput) const { 4126 const Driver &D = getToolChain().getDriver(); 4127 ArgStringList CmdArgs; 4128 4129 for (ArgList::const_iterator 4130 it = Args.begin(), ie = Args.end(); it != ie; ++it) { 4131 Arg *A = *it; 4132 if (forwardToGCC(A->getOption())) { 4133 // Don't forward any -g arguments to assembly steps. 4134 if (isa<AssembleJobAction>(JA) && 4135 A->getOption().matches(options::OPT_g_Group)) 4136 continue; 4137 4138 // Don't forward any -W arguments to assembly and link steps. 4139 if ((isa<AssembleJobAction>(JA) || isa<LinkJobAction>(JA)) && 4140 A->getOption().matches(options::OPT_W_Group)) 4141 continue; 4142 4143 // It is unfortunate that we have to claim here, as this means 4144 // we will basically never report anything interesting for 4145 // platforms using a generic gcc, even if we are just using gcc 4146 // to get to the assembler. 4147 A->claim(); 4148 A->render(Args, CmdArgs); 4149 } 4150 } 4151 4152 RenderExtraToolArgs(JA, CmdArgs); 4153 4154 // If using a driver driver, force the arch. 4155 llvm::Triple::ArchType Arch = getToolChain().getArch(); 4156 if (getToolChain().getTriple().isOSDarwin()) { 4157 CmdArgs.push_back("-arch"); 4158 4159 // FIXME: Remove these special cases. 4160 if (Arch == llvm::Triple::ppc) 4161 CmdArgs.push_back("ppc"); 4162 else if (Arch == llvm::Triple::ppc64) 4163 CmdArgs.push_back("ppc64"); 4164 else if (Arch == llvm::Triple::ppc64le) 4165 CmdArgs.push_back("ppc64le"); 4166 else 4167 CmdArgs.push_back(Args.MakeArgString(getToolChain().getArchName())); 4168 } 4169 4170 // Try to force gcc to match the tool chain we want, if we recognize 4171 // the arch. 4172 // 4173 // FIXME: The triple class should directly provide the information we want 4174 // here. 4175 if (Arch == llvm::Triple::x86 || Arch == llvm::Triple::ppc) 4176 CmdArgs.push_back("-m32"); 4177 else if (Arch == llvm::Triple::x86_64 || Arch == llvm::Triple::ppc64 || 4178 Arch == llvm::Triple::ppc64le) 4179 CmdArgs.push_back("-m64"); 4180 4181 if (Output.isFilename()) { 4182 CmdArgs.push_back("-o"); 4183 CmdArgs.push_back(Output.getFilename()); 4184 } else { 4185 assert(Output.isNothing() && "Unexpected output"); 4186 CmdArgs.push_back("-fsyntax-only"); 4187 } 4188 4189 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, 4190 options::OPT_Xassembler); 4191 4192 // Only pass -x if gcc will understand it; otherwise hope gcc 4193 // understands the suffix correctly. The main use case this would go 4194 // wrong in is for linker inputs if they happened to have an odd 4195 // suffix; really the only way to get this to happen is a command 4196 // like '-x foobar a.c' which will treat a.c like a linker input. 4197 // 4198 // FIXME: For the linker case specifically, can we safely convert 4199 // inputs into '-Wl,' options? 4200 for (InputInfoList::const_iterator 4201 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 4202 const InputInfo &II = *it; 4203 4204 // Don't try to pass LLVM or AST inputs to a generic gcc. 4205 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR || 4206 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC) 4207 D.Diag(diag::err_drv_no_linker_llvm_support) 4208 << getToolChain().getTripleString(); 4209 else if (II.getType() == types::TY_AST) 4210 D.Diag(diag::err_drv_no_ast_support) 4211 << getToolChain().getTripleString(); 4212 else if (II.getType() == types::TY_ModuleFile) 4213 D.Diag(diag::err_drv_no_module_support) 4214 << getToolChain().getTripleString(); 4215 4216 if (types::canTypeBeUserSpecified(II.getType())) { 4217 CmdArgs.push_back("-x"); 4218 CmdArgs.push_back(types::getTypeName(II.getType())); 4219 } 4220 4221 if (II.isFilename()) 4222 CmdArgs.push_back(II.getFilename()); 4223 else { 4224 const Arg &A = II.getInputArg(); 4225 4226 // Reverse translate some rewritten options. 4227 if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx)) { 4228 CmdArgs.push_back("-lstdc++"); 4229 continue; 4230 } 4231 4232 // Don't render as input, we need gcc to do the translations. 4233 A.render(Args, CmdArgs); 4234 } 4235 } 4236 4237 const std::string customGCCName = D.getCCCGenericGCCName(); 4238 const char *GCCName; 4239 if (!customGCCName.empty()) 4240 GCCName = customGCCName.c_str(); 4241 else if (D.CCCIsCXX()) { 4242 GCCName = "g++"; 4243 } else 4244 GCCName = "gcc"; 4245 4246 const char *Exec = 4247 Args.MakeArgString(getToolChain().GetProgramPath(GCCName)); 4248 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 4249} 4250 4251void gcc::Preprocess::RenderExtraToolArgs(const JobAction &JA, 4252 ArgStringList &CmdArgs) const { 4253 CmdArgs.push_back("-E"); 4254} 4255 4256void gcc::Precompile::RenderExtraToolArgs(const JobAction &JA, 4257 ArgStringList &CmdArgs) const { 4258 // The type is good enough. 4259} 4260 4261void gcc::Compile::RenderExtraToolArgs(const JobAction &JA, 4262 ArgStringList &CmdArgs) const { 4263 const Driver &D = getToolChain().getDriver(); 4264 4265 // If -flto, etc. are present then make sure not to force assembly output. 4266 if (JA.getType() == types::TY_LLVM_IR || JA.getType() == types::TY_LTO_IR || 4267 JA.getType() == types::TY_LLVM_BC || JA.getType() == types::TY_LTO_BC) 4268 CmdArgs.push_back("-c"); 4269 else { 4270 if (JA.getType() != types::TY_PP_Asm) 4271 D.Diag(diag::err_drv_invalid_gcc_output_type) 4272 << getTypeName(JA.getType()); 4273 4274 CmdArgs.push_back("-S"); 4275 } 4276} 4277 4278void gcc::Assemble::RenderExtraToolArgs(const JobAction &JA, 4279 ArgStringList &CmdArgs) const { 4280 CmdArgs.push_back("-c"); 4281} 4282 4283void gcc::Link::RenderExtraToolArgs(const JobAction &JA, 4284 ArgStringList &CmdArgs) const { 4285 // The types are (hopefully) good enough. 4286} 4287 4288// Hexagon tools start. 4289void hexagon::Assemble::RenderExtraToolArgs(const JobAction &JA, 4290 ArgStringList &CmdArgs) const { 4291 4292} 4293void hexagon::Assemble::ConstructJob(Compilation &C, const JobAction &JA, 4294 const InputInfo &Output, 4295 const InputInfoList &Inputs, 4296 const ArgList &Args, 4297 const char *LinkingOutput) const { 4298 4299 const Driver &D = getToolChain().getDriver(); 4300 ArgStringList CmdArgs; 4301 4302 std::string MarchString = "-march="; 4303 MarchString += toolchains::Hexagon_TC::GetTargetCPU(Args); 4304 CmdArgs.push_back(Args.MakeArgString(MarchString)); 4305 4306 RenderExtraToolArgs(JA, CmdArgs); 4307 4308 if (Output.isFilename()) { 4309 CmdArgs.push_back("-o"); 4310 CmdArgs.push_back(Output.getFilename()); 4311 } else { 4312 assert(Output.isNothing() && "Unexpected output"); 4313 CmdArgs.push_back("-fsyntax-only"); 4314 } 4315 4316 std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args); 4317 if (!SmallDataThreshold.empty()) 4318 CmdArgs.push_back( 4319 Args.MakeArgString(std::string("-G") + SmallDataThreshold)); 4320 4321 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, 4322 options::OPT_Xassembler); 4323 4324 // Only pass -x if gcc will understand it; otherwise hope gcc 4325 // understands the suffix correctly. The main use case this would go 4326 // wrong in is for linker inputs if they happened to have an odd 4327 // suffix; really the only way to get this to happen is a command 4328 // like '-x foobar a.c' which will treat a.c like a linker input. 4329 // 4330 // FIXME: For the linker case specifically, can we safely convert 4331 // inputs into '-Wl,' options? 4332 for (InputInfoList::const_iterator 4333 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 4334 const InputInfo &II = *it; 4335 4336 // Don't try to pass LLVM or AST inputs to a generic gcc. 4337 if (II.getType() == types::TY_LLVM_IR || II.getType() == types::TY_LTO_IR || 4338 II.getType() == types::TY_LLVM_BC || II.getType() == types::TY_LTO_BC) 4339 D.Diag(clang::diag::err_drv_no_linker_llvm_support) 4340 << getToolChain().getTripleString(); 4341 else if (II.getType() == types::TY_AST) 4342 D.Diag(clang::diag::err_drv_no_ast_support) 4343 << getToolChain().getTripleString(); 4344 else if (II.getType() == types::TY_ModuleFile) 4345 D.Diag(diag::err_drv_no_module_support) 4346 << getToolChain().getTripleString(); 4347 4348 if (II.isFilename()) 4349 CmdArgs.push_back(II.getFilename()); 4350 else 4351 // Don't render as input, we need gcc to do the translations. FIXME: Pranav: What is this ? 4352 II.getInputArg().render(Args, CmdArgs); 4353 } 4354 4355 const char *GCCName = "hexagon-as"; 4356 const char *Exec = 4357 Args.MakeArgString(getToolChain().GetProgramPath(GCCName)); 4358 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 4359 4360} 4361void hexagon::Link::RenderExtraToolArgs(const JobAction &JA, 4362 ArgStringList &CmdArgs) const { 4363 // The types are (hopefully) good enough. 4364} 4365 4366void hexagon::Link::ConstructJob(Compilation &C, const JobAction &JA, 4367 const InputInfo &Output, 4368 const InputInfoList &Inputs, 4369 const ArgList &Args, 4370 const char *LinkingOutput) const { 4371 4372 const toolchains::Hexagon_TC& ToolChain = 4373 static_cast<const toolchains::Hexagon_TC&>(getToolChain()); 4374 const Driver &D = ToolChain.getDriver(); 4375 4376 ArgStringList CmdArgs; 4377 4378 //---------------------------------------------------------------------------- 4379 // 4380 //---------------------------------------------------------------------------- 4381 bool hasStaticArg = Args.hasArg(options::OPT_static); 4382 bool buildingLib = Args.hasArg(options::OPT_shared); 4383 bool buildPIE = Args.hasArg(options::OPT_pie); 4384 bool incStdLib = !Args.hasArg(options::OPT_nostdlib); 4385 bool incStartFiles = !Args.hasArg(options::OPT_nostartfiles); 4386 bool incDefLibs = !Args.hasArg(options::OPT_nodefaultlibs); 4387 bool useShared = buildingLib && !hasStaticArg; 4388 4389 //---------------------------------------------------------------------------- 4390 // Silence warnings for various options 4391 //---------------------------------------------------------------------------- 4392 4393 Args.ClaimAllArgs(options::OPT_g_Group); 4394 Args.ClaimAllArgs(options::OPT_emit_llvm); 4395 Args.ClaimAllArgs(options::OPT_w); // Other warning options are already 4396 // handled somewhere else. 4397 Args.ClaimAllArgs(options::OPT_static_libgcc); 4398 4399 //---------------------------------------------------------------------------- 4400 // 4401 //---------------------------------------------------------------------------- 4402 for (std::vector<std::string>::const_iterator i = ToolChain.ExtraOpts.begin(), 4403 e = ToolChain.ExtraOpts.end(); 4404 i != e; ++i) 4405 CmdArgs.push_back(i->c_str()); 4406 4407 std::string MarchString = toolchains::Hexagon_TC::GetTargetCPU(Args); 4408 CmdArgs.push_back(Args.MakeArgString("-m" + MarchString)); 4409 4410 if (buildingLib) { 4411 CmdArgs.push_back("-shared"); 4412 CmdArgs.push_back("-call_shared"); // should be the default, but doing as 4413 // hexagon-gcc does 4414 } 4415 4416 if (hasStaticArg) 4417 CmdArgs.push_back("-static"); 4418 4419 if (buildPIE && !buildingLib) 4420 CmdArgs.push_back("-pie"); 4421 4422 std::string SmallDataThreshold = GetHexagonSmallDataThresholdValue(Args); 4423 if (!SmallDataThreshold.empty()) { 4424 CmdArgs.push_back( 4425 Args.MakeArgString(std::string("-G") + SmallDataThreshold)); 4426 } 4427 4428 //---------------------------------------------------------------------------- 4429 // 4430 //---------------------------------------------------------------------------- 4431 CmdArgs.push_back("-o"); 4432 CmdArgs.push_back(Output.getFilename()); 4433 4434 const std::string MarchSuffix = "/" + MarchString; 4435 const std::string G0Suffix = "/G0"; 4436 const std::string MarchG0Suffix = MarchSuffix + G0Suffix; 4437 const std::string RootDir = toolchains::Hexagon_TC::GetGnuDir(D.InstalledDir) 4438 + "/"; 4439 const std::string StartFilesDir = RootDir 4440 + "hexagon/lib" 4441 + (buildingLib 4442 ? MarchG0Suffix : MarchSuffix); 4443 4444 //---------------------------------------------------------------------------- 4445 // moslib 4446 //---------------------------------------------------------------------------- 4447 std::vector<std::string> oslibs; 4448 bool hasStandalone= false; 4449 4450 for (arg_iterator it = Args.filtered_begin(options::OPT_moslib_EQ), 4451 ie = Args.filtered_end(); it != ie; ++it) { 4452 (*it)->claim(); 4453 oslibs.push_back((*it)->getValue()); 4454 hasStandalone = hasStandalone || (oslibs.back() == "standalone"); 4455 } 4456 if (oslibs.empty()) { 4457 oslibs.push_back("standalone"); 4458 hasStandalone = true; 4459 } 4460 4461 //---------------------------------------------------------------------------- 4462 // Start Files 4463 //---------------------------------------------------------------------------- 4464 if (incStdLib && incStartFiles) { 4465 4466 if (!buildingLib) { 4467 if (hasStandalone) { 4468 CmdArgs.push_back( 4469 Args.MakeArgString(StartFilesDir + "/crt0_standalone.o")); 4470 } 4471 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + "/crt0.o")); 4472 } 4473 std::string initObj = useShared ? "/initS.o" : "/init.o"; 4474 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + initObj)); 4475 } 4476 4477 //---------------------------------------------------------------------------- 4478 // Library Search Paths 4479 //---------------------------------------------------------------------------- 4480 const ToolChain::path_list &LibPaths = ToolChain.getFilePaths(); 4481 for (ToolChain::path_list::const_iterator 4482 i = LibPaths.begin(), 4483 e = LibPaths.end(); 4484 i != e; 4485 ++i) 4486 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + *i)); 4487 4488 //---------------------------------------------------------------------------- 4489 // 4490 //---------------------------------------------------------------------------- 4491 Args.AddAllArgs(CmdArgs, options::OPT_T_Group); 4492 Args.AddAllArgs(CmdArgs, options::OPT_e); 4493 Args.AddAllArgs(CmdArgs, options::OPT_s); 4494 Args.AddAllArgs(CmdArgs, options::OPT_t); 4495 Args.AddAllArgs(CmdArgs, options::OPT_u_Group); 4496 4497 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs); 4498 4499 //---------------------------------------------------------------------------- 4500 // Libraries 4501 //---------------------------------------------------------------------------- 4502 if (incStdLib && incDefLibs) { 4503 if (D.CCCIsCXX()) { 4504 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs); 4505 CmdArgs.push_back("-lm"); 4506 } 4507 4508 CmdArgs.push_back("--start-group"); 4509 4510 if (!buildingLib) { 4511 for(std::vector<std::string>::iterator i = oslibs.begin(), 4512 e = oslibs.end(); i != e; ++i) 4513 CmdArgs.push_back(Args.MakeArgString("-l" + *i)); 4514 CmdArgs.push_back("-lc"); 4515 } 4516 CmdArgs.push_back("-lgcc"); 4517 4518 CmdArgs.push_back("--end-group"); 4519 } 4520 4521 //---------------------------------------------------------------------------- 4522 // End files 4523 //---------------------------------------------------------------------------- 4524 if (incStdLib && incStartFiles) { 4525 std::string finiObj = useShared ? "/finiS.o" : "/fini.o"; 4526 CmdArgs.push_back(Args.MakeArgString(StartFilesDir + finiObj)); 4527 } 4528 4529 std::string Linker = ToolChain.GetProgramPath("hexagon-ld"); 4530 C.addCommand(new Command(JA, *this, Args.MakeArgString(Linker), CmdArgs)); 4531} 4532// Hexagon tools end. 4533 4534llvm::Triple::ArchType darwin::getArchTypeForDarwinArchName(StringRef Str) { 4535 // See arch(3) and llvm-gcc's driver-driver.c. We don't implement support for 4536 // archs which Darwin doesn't use. 4537 4538 // The matching this routine does is fairly pointless, since it is neither the 4539 // complete architecture list, nor a reasonable subset. The problem is that 4540 // historically the driver driver accepts this and also ties its -march= 4541 // handling to the architecture name, so we need to be careful before removing 4542 // support for it. 4543 4544 // This code must be kept in sync with Clang's Darwin specific argument 4545 // translation. 4546 4547 return llvm::StringSwitch<llvm::Triple::ArchType>(Str) 4548 .Cases("ppc", "ppc601", "ppc603", "ppc604", "ppc604e", llvm::Triple::ppc) 4549 .Cases("ppc750", "ppc7400", "ppc7450", "ppc970", llvm::Triple::ppc) 4550 .Case("ppc64", llvm::Triple::ppc64) 4551 .Cases("i386", "i486", "i486SX", "i586", "i686", llvm::Triple::x86) 4552 .Cases("pentium", "pentpro", "pentIIm3", "pentIIm5", "pentium4", 4553 llvm::Triple::x86) 4554 .Cases("x86_64", "x86_64h", llvm::Triple::x86_64) 4555 // This is derived from the driver driver. 4556 .Cases("arm", "armv4t", "armv5", "armv6", "armv6m", llvm::Triple::arm) 4557 .Cases("armv7", "armv7em", "armv7f", "armv7k", "armv7m", llvm::Triple::arm) 4558 .Cases("armv7s", "xscale", llvm::Triple::arm) 4559 .Case("r600", llvm::Triple::r600) 4560 .Case("nvptx", llvm::Triple::nvptx) 4561 .Case("nvptx64", llvm::Triple::nvptx64) 4562 .Case("amdil", llvm::Triple::amdil) 4563 .Case("spir", llvm::Triple::spir) 4564 .Default(llvm::Triple::UnknownArch); 4565} 4566 4567const char *Clang::getBaseInputName(const ArgList &Args, 4568 const InputInfoList &Inputs) { 4569 return Args.MakeArgString( 4570 llvm::sys::path::filename(Inputs[0].getBaseInput())); 4571} 4572 4573const char *Clang::getBaseInputStem(const ArgList &Args, 4574 const InputInfoList &Inputs) { 4575 const char *Str = getBaseInputName(Args, Inputs); 4576 4577 if (const char *End = strrchr(Str, '.')) 4578 return Args.MakeArgString(std::string(Str, End)); 4579 4580 return Str; 4581} 4582 4583const char *Clang::getDependencyFileName(const ArgList &Args, 4584 const InputInfoList &Inputs) { 4585 // FIXME: Think about this more. 4586 std::string Res; 4587 4588 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) { 4589 std::string Str(OutputOpt->getValue()); 4590 Res = Str.substr(0, Str.rfind('.')); 4591 } else { 4592 Res = getBaseInputStem(Args, Inputs); 4593 } 4594 return Args.MakeArgString(Res + ".d"); 4595} 4596 4597void darwin::Assemble::ConstructJob(Compilation &C, const JobAction &JA, 4598 const InputInfo &Output, 4599 const InputInfoList &Inputs, 4600 const ArgList &Args, 4601 const char *LinkingOutput) const { 4602 ArgStringList CmdArgs; 4603 4604 assert(Inputs.size() == 1 && "Unexpected number of inputs."); 4605 const InputInfo &Input = Inputs[0]; 4606 4607 // Determine the original source input. 4608 const Action *SourceAction = &JA; 4609 while (SourceAction->getKind() != Action::InputClass) { 4610 assert(!SourceAction->getInputs().empty() && "unexpected root action!"); 4611 SourceAction = SourceAction->getInputs()[0]; 4612 } 4613 4614 // If -no_integrated_as is used add -Q to the darwin assember driver to make 4615 // sure it runs its system assembler not clang's integrated assembler. 4616 if (Args.hasArg(options::OPT_no_integrated_as)) 4617 CmdArgs.push_back("-Q"); 4618 4619 // Forward -g, assuming we are dealing with an actual assembly file. 4620 if (SourceAction->getType() == types::TY_Asm || 4621 SourceAction->getType() == types::TY_PP_Asm) { 4622 if (Args.hasArg(options::OPT_gstabs)) 4623 CmdArgs.push_back("--gstabs"); 4624 else if (Args.hasArg(options::OPT_g_Group)) 4625 CmdArgs.push_back("-g"); 4626 } 4627 4628 // Derived from asm spec. 4629 AddDarwinArch(Args, CmdArgs); 4630 4631 // Use -force_cpusubtype_ALL on x86 by default. 4632 if (getToolChain().getArch() == llvm::Triple::x86 || 4633 getToolChain().getArch() == llvm::Triple::x86_64 || 4634 Args.hasArg(options::OPT_force__cpusubtype__ALL)) 4635 CmdArgs.push_back("-force_cpusubtype_ALL"); 4636 4637 if (getToolChain().getArch() != llvm::Triple::x86_64 && 4638 (((Args.hasArg(options::OPT_mkernel) || 4639 Args.hasArg(options::OPT_fapple_kext)) && 4640 (!getDarwinToolChain().isTargetIPhoneOS() || 4641 getDarwinToolChain().isIPhoneOSVersionLT(6, 0))) || 4642 Args.hasArg(options::OPT_static))) 4643 CmdArgs.push_back("-static"); 4644 4645 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, 4646 options::OPT_Xassembler); 4647 4648 assert(Output.isFilename() && "Unexpected lipo output."); 4649 CmdArgs.push_back("-o"); 4650 CmdArgs.push_back(Output.getFilename()); 4651 4652 assert(Input.isFilename() && "Invalid input."); 4653 CmdArgs.push_back(Input.getFilename()); 4654 4655 // asm_final spec is empty. 4656 4657 const char *Exec = 4658 Args.MakeArgString(getToolChain().GetProgramPath("as")); 4659 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 4660} 4661 4662void darwin::DarwinTool::anchor() {} 4663 4664void darwin::DarwinTool::AddDarwinArch(const ArgList &Args, 4665 ArgStringList &CmdArgs) const { 4666 StringRef ArchName = getDarwinToolChain().getDarwinArchName(Args); 4667 4668 // Derived from darwin_arch spec. 4669 CmdArgs.push_back("-arch"); 4670 CmdArgs.push_back(Args.MakeArgString(ArchName)); 4671 4672 // FIXME: Is this needed anymore? 4673 if (ArchName == "arm") 4674 CmdArgs.push_back("-force_cpusubtype_ALL"); 4675} 4676 4677bool darwin::Link::NeedsTempPath(const InputInfoList &Inputs) const { 4678 // We only need to generate a temp path for LTO if we aren't compiling object 4679 // files. When compiling source files, we run 'dsymutil' after linking. We 4680 // don't run 'dsymutil' when compiling object files. 4681 for (InputInfoList::const_iterator 4682 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) 4683 if (it->getType() != types::TY_Object) 4684 return true; 4685 4686 return false; 4687} 4688 4689void darwin::Link::AddLinkArgs(Compilation &C, 4690 const ArgList &Args, 4691 ArgStringList &CmdArgs, 4692 const InputInfoList &Inputs) const { 4693 const Driver &D = getToolChain().getDriver(); 4694 const toolchains::Darwin &DarwinTC = getDarwinToolChain(); 4695 4696 unsigned Version[3] = { 0, 0, 0 }; 4697 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) { 4698 bool HadExtra; 4699 if (!Driver::GetReleaseVersion(A->getValue(), Version[0], 4700 Version[1], Version[2], HadExtra) || 4701 HadExtra) 4702 D.Diag(diag::err_drv_invalid_version_number) 4703 << A->getAsString(Args); 4704 } 4705 4706 // Newer linkers support -demangle, pass it if supported and not disabled by 4707 // the user. 4708 if (Version[0] >= 100 && !Args.hasArg(options::OPT_Z_Xlinker__no_demangle)) { 4709 // Don't pass -demangle to ld_classic. 4710 // 4711 // FIXME: This is a temporary workaround, ld should be handling this. 4712 bool UsesLdClassic = (getToolChain().getArch() == llvm::Triple::x86 && 4713 Args.hasArg(options::OPT_static)); 4714 if (getToolChain().getArch() == llvm::Triple::x86) { 4715 for (arg_iterator it = Args.filtered_begin(options::OPT_Xlinker, 4716 options::OPT_Wl_COMMA), 4717 ie = Args.filtered_end(); it != ie; ++it) { 4718 const Arg *A = *it; 4719 for (unsigned i = 0, e = A->getNumValues(); i != e; ++i) 4720 if (StringRef(A->getValue(i)) == "-kext") 4721 UsesLdClassic = true; 4722 } 4723 } 4724 if (!UsesLdClassic) 4725 CmdArgs.push_back("-demangle"); 4726 } 4727 4728 if (Args.hasArg(options::OPT_rdynamic) && Version[0] >= 137) 4729 CmdArgs.push_back("-export_dynamic"); 4730 4731 // If we are using LTO, then automatically create a temporary file path for 4732 // the linker to use, so that it's lifetime will extend past a possible 4733 // dsymutil step. 4734 if (Version[0] >= 116 && D.IsUsingLTO(Args) && NeedsTempPath(Inputs)) { 4735 const char *TmpPath = C.getArgs().MakeArgString( 4736 D.GetTemporaryPath("cc", types::getTypeTempSuffix(types::TY_Object))); 4737 C.addTempFile(TmpPath); 4738 CmdArgs.push_back("-object_path_lto"); 4739 CmdArgs.push_back(TmpPath); 4740 } 4741 4742 // Derived from the "link" spec. 4743 Args.AddAllArgs(CmdArgs, options::OPT_static); 4744 if (!Args.hasArg(options::OPT_static)) 4745 CmdArgs.push_back("-dynamic"); 4746 if (Args.hasArg(options::OPT_fgnu_runtime)) { 4747 // FIXME: gcc replaces -lobjc in forward args with -lobjc-gnu 4748 // here. How do we wish to handle such things? 4749 } 4750 4751 if (!Args.hasArg(options::OPT_dynamiclib)) { 4752 AddDarwinArch(Args, CmdArgs); 4753 // FIXME: Why do this only on this path? 4754 Args.AddLastArg(CmdArgs, options::OPT_force__cpusubtype__ALL); 4755 4756 Args.AddLastArg(CmdArgs, options::OPT_bundle); 4757 Args.AddAllArgs(CmdArgs, options::OPT_bundle__loader); 4758 Args.AddAllArgs(CmdArgs, options::OPT_client__name); 4759 4760 Arg *A; 4761 if ((A = Args.getLastArg(options::OPT_compatibility__version)) || 4762 (A = Args.getLastArg(options::OPT_current__version)) || 4763 (A = Args.getLastArg(options::OPT_install__name))) 4764 D.Diag(diag::err_drv_argument_only_allowed_with) 4765 << A->getAsString(Args) << "-dynamiclib"; 4766 4767 Args.AddLastArg(CmdArgs, options::OPT_force__flat__namespace); 4768 Args.AddLastArg(CmdArgs, options::OPT_keep__private__externs); 4769 Args.AddLastArg(CmdArgs, options::OPT_private__bundle); 4770 } else { 4771 CmdArgs.push_back("-dylib"); 4772 4773 Arg *A; 4774 if ((A = Args.getLastArg(options::OPT_bundle)) || 4775 (A = Args.getLastArg(options::OPT_bundle__loader)) || 4776 (A = Args.getLastArg(options::OPT_client__name)) || 4777 (A = Args.getLastArg(options::OPT_force__flat__namespace)) || 4778 (A = Args.getLastArg(options::OPT_keep__private__externs)) || 4779 (A = Args.getLastArg(options::OPT_private__bundle))) 4780 D.Diag(diag::err_drv_argument_not_allowed_with) 4781 << A->getAsString(Args) << "-dynamiclib"; 4782 4783 Args.AddAllArgsTranslated(CmdArgs, options::OPT_compatibility__version, 4784 "-dylib_compatibility_version"); 4785 Args.AddAllArgsTranslated(CmdArgs, options::OPT_current__version, 4786 "-dylib_current_version"); 4787 4788 AddDarwinArch(Args, CmdArgs); 4789 4790 Args.AddAllArgsTranslated(CmdArgs, options::OPT_install__name, 4791 "-dylib_install_name"); 4792 } 4793 4794 Args.AddLastArg(CmdArgs, options::OPT_all__load); 4795 Args.AddAllArgs(CmdArgs, options::OPT_allowable__client); 4796 Args.AddLastArg(CmdArgs, options::OPT_bind__at__load); 4797 if (DarwinTC.isTargetIPhoneOS()) 4798 Args.AddLastArg(CmdArgs, options::OPT_arch__errors__fatal); 4799 Args.AddLastArg(CmdArgs, options::OPT_dead__strip); 4800 Args.AddLastArg(CmdArgs, options::OPT_no__dead__strip__inits__and__terms); 4801 Args.AddAllArgs(CmdArgs, options::OPT_dylib__file); 4802 Args.AddLastArg(CmdArgs, options::OPT_dynamic); 4803 Args.AddAllArgs(CmdArgs, options::OPT_exported__symbols__list); 4804 Args.AddLastArg(CmdArgs, options::OPT_flat__namespace); 4805 Args.AddAllArgs(CmdArgs, options::OPT_force__load); 4806 Args.AddAllArgs(CmdArgs, options::OPT_headerpad__max__install__names); 4807 Args.AddAllArgs(CmdArgs, options::OPT_image__base); 4808 Args.AddAllArgs(CmdArgs, options::OPT_init); 4809 4810 // Add the deployment target. 4811 VersionTuple TargetVersion = DarwinTC.getTargetVersion(); 4812 4813 // If we had an explicit -mios-simulator-version-min argument, honor that, 4814 // otherwise use the traditional deployment targets. We can't just check the 4815 // is-sim attribute because existing code follows this path, and the linker 4816 // may not handle the argument. 4817 // 4818 // FIXME: We may be able to remove this, once we can verify no one depends on 4819 // it. 4820 if (Args.hasArg(options::OPT_mios_simulator_version_min_EQ)) 4821 CmdArgs.push_back("-ios_simulator_version_min"); 4822 else if (DarwinTC.isTargetIPhoneOS()) 4823 CmdArgs.push_back("-iphoneos_version_min"); 4824 else 4825 CmdArgs.push_back("-macosx_version_min"); 4826 CmdArgs.push_back(Args.MakeArgString(TargetVersion.getAsString())); 4827 4828 Args.AddLastArg(CmdArgs, options::OPT_nomultidefs); 4829 Args.AddLastArg(CmdArgs, options::OPT_multi__module); 4830 Args.AddLastArg(CmdArgs, options::OPT_single__module); 4831 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined); 4832 Args.AddAllArgs(CmdArgs, options::OPT_multiply__defined__unused); 4833 4834 if (const Arg *A = Args.getLastArg(options::OPT_fpie, options::OPT_fPIE, 4835 options::OPT_fno_pie, 4836 options::OPT_fno_PIE)) { 4837 if (A->getOption().matches(options::OPT_fpie) || 4838 A->getOption().matches(options::OPT_fPIE)) 4839 CmdArgs.push_back("-pie"); 4840 else 4841 CmdArgs.push_back("-no_pie"); 4842 } 4843 4844 Args.AddLastArg(CmdArgs, options::OPT_prebind); 4845 Args.AddLastArg(CmdArgs, options::OPT_noprebind); 4846 Args.AddLastArg(CmdArgs, options::OPT_nofixprebinding); 4847 Args.AddLastArg(CmdArgs, options::OPT_prebind__all__twolevel__modules); 4848 Args.AddLastArg(CmdArgs, options::OPT_read__only__relocs); 4849 Args.AddAllArgs(CmdArgs, options::OPT_sectcreate); 4850 Args.AddAllArgs(CmdArgs, options::OPT_sectorder); 4851 Args.AddAllArgs(CmdArgs, options::OPT_seg1addr); 4852 Args.AddAllArgs(CmdArgs, options::OPT_segprot); 4853 Args.AddAllArgs(CmdArgs, options::OPT_segaddr); 4854 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__only__addr); 4855 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__write__addr); 4856 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table); 4857 Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table__filename); 4858 Args.AddAllArgs(CmdArgs, options::OPT_sub__library); 4859 Args.AddAllArgs(CmdArgs, options::OPT_sub__umbrella); 4860 4861 // Give --sysroot= preference, over the Apple specific behavior to also use 4862 // --isysroot as the syslibroot. 4863 StringRef sysroot = C.getSysRoot(); 4864 if (sysroot != "") { 4865 CmdArgs.push_back("-syslibroot"); 4866 CmdArgs.push_back(C.getArgs().MakeArgString(sysroot)); 4867 } else if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) { 4868 CmdArgs.push_back("-syslibroot"); 4869 CmdArgs.push_back(A->getValue()); 4870 } 4871 4872 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace); 4873 Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace__hints); 4874 Args.AddAllArgs(CmdArgs, options::OPT_umbrella); 4875 Args.AddAllArgs(CmdArgs, options::OPT_undefined); 4876 Args.AddAllArgs(CmdArgs, options::OPT_unexported__symbols__list); 4877 Args.AddAllArgs(CmdArgs, options::OPT_weak__reference__mismatches); 4878 Args.AddLastArg(CmdArgs, options::OPT_X_Flag); 4879 Args.AddAllArgs(CmdArgs, options::OPT_y); 4880 Args.AddLastArg(CmdArgs, options::OPT_w); 4881 Args.AddAllArgs(CmdArgs, options::OPT_pagezero__size); 4882 Args.AddAllArgs(CmdArgs, options::OPT_segs__read__); 4883 Args.AddLastArg(CmdArgs, options::OPT_seglinkedit); 4884 Args.AddLastArg(CmdArgs, options::OPT_noseglinkedit); 4885 Args.AddAllArgs(CmdArgs, options::OPT_sectalign); 4886 Args.AddAllArgs(CmdArgs, options::OPT_sectobjectsymbols); 4887 Args.AddAllArgs(CmdArgs, options::OPT_segcreate); 4888 Args.AddLastArg(CmdArgs, options::OPT_whyload); 4889 Args.AddLastArg(CmdArgs, options::OPT_whatsloaded); 4890 Args.AddAllArgs(CmdArgs, options::OPT_dylinker__install__name); 4891 Args.AddLastArg(CmdArgs, options::OPT_dylinker); 4892 Args.AddLastArg(CmdArgs, options::OPT_Mach); 4893} 4894 4895void darwin::Link::ConstructJob(Compilation &C, const JobAction &JA, 4896 const InputInfo &Output, 4897 const InputInfoList &Inputs, 4898 const ArgList &Args, 4899 const char *LinkingOutput) const { 4900 assert(Output.getType() == types::TY_Image && "Invalid linker output type."); 4901 4902 // The logic here is derived from gcc's behavior; most of which 4903 // comes from specs (starting with link_command). Consult gcc for 4904 // more information. 4905 ArgStringList CmdArgs; 4906 4907 /// Hack(tm) to ignore linking errors when we are doing ARC migration. 4908 if (Args.hasArg(options::OPT_ccc_arcmt_check, 4909 options::OPT_ccc_arcmt_migrate)) { 4910 for (ArgList::const_iterator I = Args.begin(), E = Args.end(); I != E; ++I) 4911 (*I)->claim(); 4912 const char *Exec = 4913 Args.MakeArgString(getToolChain().GetProgramPath("touch")); 4914 CmdArgs.push_back(Output.getFilename()); 4915 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 4916 return; 4917 } 4918 4919 // I'm not sure why this particular decomposition exists in gcc, but 4920 // we follow suite for ease of comparison. 4921 AddLinkArgs(C, Args, CmdArgs, Inputs); 4922 4923 Args.AddAllArgs(CmdArgs, options::OPT_d_Flag); 4924 Args.AddAllArgs(CmdArgs, options::OPT_s); 4925 Args.AddAllArgs(CmdArgs, options::OPT_t); 4926 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag); 4927 Args.AddAllArgs(CmdArgs, options::OPT_u_Group); 4928 Args.AddLastArg(CmdArgs, options::OPT_e); 4929 Args.AddAllArgs(CmdArgs, options::OPT_r); 4930 4931 // Forward -ObjC when either -ObjC or -ObjC++ is used, to force loading 4932 // members of static archive libraries which implement Objective-C classes or 4933 // categories. 4934 if (Args.hasArg(options::OPT_ObjC) || Args.hasArg(options::OPT_ObjCXX)) 4935 CmdArgs.push_back("-ObjC"); 4936 4937 CmdArgs.push_back("-o"); 4938 CmdArgs.push_back(Output.getFilename()); 4939 4940 if (!Args.hasArg(options::OPT_nostdlib) && 4941 !Args.hasArg(options::OPT_nostartfiles)) { 4942 // Derived from startfile spec. 4943 if (Args.hasArg(options::OPT_dynamiclib)) { 4944 // Derived from darwin_dylib1 spec. 4945 if (getDarwinToolChain().isTargetIOSSimulator()) { 4946 // The simulator doesn't have a versioned crt1 file. 4947 CmdArgs.push_back("-ldylib1.o"); 4948 } else if (getDarwinToolChain().isTargetIPhoneOS()) { 4949 if (getDarwinToolChain().isIPhoneOSVersionLT(3, 1)) 4950 CmdArgs.push_back("-ldylib1.o"); 4951 } else { 4952 if (getDarwinToolChain().isMacosxVersionLT(10, 5)) 4953 CmdArgs.push_back("-ldylib1.o"); 4954 else if (getDarwinToolChain().isMacosxVersionLT(10, 6)) 4955 CmdArgs.push_back("-ldylib1.10.5.o"); 4956 } 4957 } else { 4958 if (Args.hasArg(options::OPT_bundle)) { 4959 if (!Args.hasArg(options::OPT_static)) { 4960 // Derived from darwin_bundle1 spec. 4961 if (getDarwinToolChain().isTargetIOSSimulator()) { 4962 // The simulator doesn't have a versioned crt1 file. 4963 CmdArgs.push_back("-lbundle1.o"); 4964 } else if (getDarwinToolChain().isTargetIPhoneOS()) { 4965 if (getDarwinToolChain().isIPhoneOSVersionLT(3, 1)) 4966 CmdArgs.push_back("-lbundle1.o"); 4967 } else { 4968 if (getDarwinToolChain().isMacosxVersionLT(10, 6)) 4969 CmdArgs.push_back("-lbundle1.o"); 4970 } 4971 } 4972 } else { 4973 if (Args.hasArg(options::OPT_pg) && 4974 getToolChain().SupportsProfiling()) { 4975 if (Args.hasArg(options::OPT_static) || 4976 Args.hasArg(options::OPT_object) || 4977 Args.hasArg(options::OPT_preload)) { 4978 CmdArgs.push_back("-lgcrt0.o"); 4979 } else { 4980 CmdArgs.push_back("-lgcrt1.o"); 4981 4982 // darwin_crt2 spec is empty. 4983 } 4984 // By default on OS X 10.8 and later, we don't link with a crt1.o 4985 // file and the linker knows to use _main as the entry point. But, 4986 // when compiling with -pg, we need to link with the gcrt1.o file, 4987 // so pass the -no_new_main option to tell the linker to use the 4988 // "start" symbol as the entry point. 4989 if (getDarwinToolChain().isTargetMacOS() && 4990 !getDarwinToolChain().isMacosxVersionLT(10, 8)) 4991 CmdArgs.push_back("-no_new_main"); 4992 } else { 4993 if (Args.hasArg(options::OPT_static) || 4994 Args.hasArg(options::OPT_object) || 4995 Args.hasArg(options::OPT_preload)) { 4996 CmdArgs.push_back("-lcrt0.o"); 4997 } else { 4998 // Derived from darwin_crt1 spec. 4999 if (getDarwinToolChain().isTargetIOSSimulator()) { 5000 // The simulator doesn't have a versioned crt1 file. 5001 CmdArgs.push_back("-lcrt1.o"); 5002 } else if (getDarwinToolChain().isTargetIPhoneOS()) { 5003 if (getDarwinToolChain().isIPhoneOSVersionLT(3, 1)) 5004 CmdArgs.push_back("-lcrt1.o"); 5005 else if (getDarwinToolChain().isIPhoneOSVersionLT(6, 0)) 5006 CmdArgs.push_back("-lcrt1.3.1.o"); 5007 } else { 5008 if (getDarwinToolChain().isMacosxVersionLT(10, 5)) 5009 CmdArgs.push_back("-lcrt1.o"); 5010 else if (getDarwinToolChain().isMacosxVersionLT(10, 6)) 5011 CmdArgs.push_back("-lcrt1.10.5.o"); 5012 else if (getDarwinToolChain().isMacosxVersionLT(10, 8)) 5013 CmdArgs.push_back("-lcrt1.10.6.o"); 5014 5015 // darwin_crt2 spec is empty. 5016 } 5017 } 5018 } 5019 } 5020 } 5021 5022 if (!getDarwinToolChain().isTargetIPhoneOS() && 5023 Args.hasArg(options::OPT_shared_libgcc) && 5024 getDarwinToolChain().isMacosxVersionLT(10, 5)) { 5025 const char *Str = 5026 Args.MakeArgString(getToolChain().GetFilePath("crt3.o")); 5027 CmdArgs.push_back(Str); 5028 } 5029 } 5030 5031 Args.AddAllArgs(CmdArgs, options::OPT_L); 5032 5033 if (Args.hasArg(options::OPT_fopenmp)) 5034 // This is more complicated in gcc... 5035 CmdArgs.push_back("-lgomp"); 5036 5037 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs); 5038 5039 if (isObjCRuntimeLinked(Args) && 5040 !Args.hasArg(options::OPT_nostdlib) && 5041 !Args.hasArg(options::OPT_nodefaultlibs)) { 5042 // Avoid linking compatibility stubs on i386 mac. 5043 if (!getDarwinToolChain().isTargetMacOS() || 5044 getDarwinToolChain().getArch() != llvm::Triple::x86) { 5045 // If we don't have ARC or subscripting runtime support, link in the 5046 // runtime stubs. We have to do this *before* adding any of the normal 5047 // linker inputs so that its initializer gets run first. 5048 ObjCRuntime runtime = 5049 getDarwinToolChain().getDefaultObjCRuntime(/*nonfragile*/ true); 5050 // We use arclite library for both ARC and subscripting support. 5051 if ((!runtime.hasNativeARC() && isObjCAutoRefCount(Args)) || 5052 !runtime.hasSubscripting()) 5053 getDarwinToolChain().AddLinkARCArgs(Args, CmdArgs); 5054 } 5055 CmdArgs.push_back("-framework"); 5056 CmdArgs.push_back("Foundation"); 5057 // Link libobj. 5058 CmdArgs.push_back("-lobjc"); 5059 } 5060 5061 if (LinkingOutput) { 5062 CmdArgs.push_back("-arch_multiple"); 5063 CmdArgs.push_back("-final_output"); 5064 CmdArgs.push_back(LinkingOutput); 5065 } 5066 5067 if (Args.hasArg(options::OPT_fnested_functions)) 5068 CmdArgs.push_back("-allow_stack_execute"); 5069 5070 if (!Args.hasArg(options::OPT_nostdlib) && 5071 !Args.hasArg(options::OPT_nodefaultlibs)) { 5072 if (getToolChain().getDriver().CCCIsCXX()) 5073 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs); 5074 5075 // link_ssp spec is empty. 5076 5077 // Let the tool chain choose which runtime library to link. 5078 getDarwinToolChain().AddLinkRuntimeLibArgs(Args, CmdArgs); 5079 } 5080 5081 if (!Args.hasArg(options::OPT_nostdlib) && 5082 !Args.hasArg(options::OPT_nostartfiles)) { 5083 // endfile_spec is empty. 5084 } 5085 5086 Args.AddAllArgs(CmdArgs, options::OPT_T_Group); 5087 Args.AddAllArgs(CmdArgs, options::OPT_F); 5088 5089 const char *Exec = 5090 Args.MakeArgString(getToolChain().GetProgramPath("ld")); 5091 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 5092} 5093 5094void darwin::Lipo::ConstructJob(Compilation &C, const JobAction &JA, 5095 const InputInfo &Output, 5096 const InputInfoList &Inputs, 5097 const ArgList &Args, 5098 const char *LinkingOutput) const { 5099 ArgStringList CmdArgs; 5100 5101 CmdArgs.push_back("-create"); 5102 assert(Output.isFilename() && "Unexpected lipo output."); 5103 5104 CmdArgs.push_back("-output"); 5105 CmdArgs.push_back(Output.getFilename()); 5106 5107 for (InputInfoList::const_iterator 5108 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 5109 const InputInfo &II = *it; 5110 assert(II.isFilename() && "Unexpected lipo input."); 5111 CmdArgs.push_back(II.getFilename()); 5112 } 5113 const char *Exec = 5114 Args.MakeArgString(getToolChain().GetProgramPath("lipo")); 5115 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 5116} 5117 5118void darwin::Dsymutil::ConstructJob(Compilation &C, const JobAction &JA, 5119 const InputInfo &Output, 5120 const InputInfoList &Inputs, 5121 const ArgList &Args, 5122 const char *LinkingOutput) const { 5123 ArgStringList CmdArgs; 5124 5125 CmdArgs.push_back("-o"); 5126 CmdArgs.push_back(Output.getFilename()); 5127 5128 assert(Inputs.size() == 1 && "Unable to handle multiple inputs."); 5129 const InputInfo &Input = Inputs[0]; 5130 assert(Input.isFilename() && "Unexpected dsymutil input."); 5131 CmdArgs.push_back(Input.getFilename()); 5132 5133 const char *Exec = 5134 Args.MakeArgString(getToolChain().GetProgramPath("dsymutil")); 5135 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 5136} 5137 5138void darwin::VerifyDebug::ConstructJob(Compilation &C, const JobAction &JA, 5139 const InputInfo &Output, 5140 const InputInfoList &Inputs, 5141 const ArgList &Args, 5142 const char *LinkingOutput) const { 5143 ArgStringList CmdArgs; 5144 CmdArgs.push_back("--verify"); 5145 CmdArgs.push_back("--debug-info"); 5146 CmdArgs.push_back("--eh-frame"); 5147 CmdArgs.push_back("--quiet"); 5148 5149 assert(Inputs.size() == 1 && "Unable to handle multiple inputs."); 5150 const InputInfo &Input = Inputs[0]; 5151 assert(Input.isFilename() && "Unexpected verify input"); 5152 5153 // Grabbing the output of the earlier dsymutil run. 5154 CmdArgs.push_back(Input.getFilename()); 5155 5156 const char *Exec = 5157 Args.MakeArgString(getToolChain().GetProgramPath("dwarfdump")); 5158 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 5159} 5160 5161void solaris::Assemble::ConstructJob(Compilation &C, const JobAction &JA, 5162 const InputInfo &Output, 5163 const InputInfoList &Inputs, 5164 const ArgList &Args, 5165 const char *LinkingOutput) const { 5166 ArgStringList CmdArgs; 5167 5168 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, 5169 options::OPT_Xassembler); 5170 5171 CmdArgs.push_back("-o"); 5172 CmdArgs.push_back(Output.getFilename()); 5173 5174 for (InputInfoList::const_iterator 5175 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 5176 const InputInfo &II = *it; 5177 CmdArgs.push_back(II.getFilename()); 5178 } 5179 5180 const char *Exec = 5181 Args.MakeArgString(getToolChain().GetProgramPath("as")); 5182 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 5183} 5184 5185 5186void solaris::Link::ConstructJob(Compilation &C, const JobAction &JA, 5187 const InputInfo &Output, 5188 const InputInfoList &Inputs, 5189 const ArgList &Args, 5190 const char *LinkingOutput) const { 5191 // FIXME: Find a real GCC, don't hard-code versions here 5192 std::string GCCLibPath = "/usr/gcc/4.5/lib/gcc/"; 5193 const llvm::Triple &T = getToolChain().getTriple(); 5194 std::string LibPath = "/usr/lib/"; 5195 llvm::Triple::ArchType Arch = T.getArch(); 5196 switch (Arch) { 5197 case llvm::Triple::x86: 5198 GCCLibPath += 5199 ("i386-" + T.getVendorName() + "-" + T.getOSName()).str() + "/4.5.2/"; 5200 break; 5201 case llvm::Triple::x86_64: 5202 GCCLibPath += ("i386-" + T.getVendorName() + "-" + T.getOSName()).str(); 5203 GCCLibPath += "/4.5.2/amd64/"; 5204 LibPath += "amd64/"; 5205 break; 5206 default: 5207 llvm_unreachable("Unsupported architecture"); 5208 } 5209 5210 ArgStringList CmdArgs; 5211 5212 // Demangle C++ names in errors 5213 CmdArgs.push_back("-C"); 5214 5215 if ((!Args.hasArg(options::OPT_nostdlib)) && 5216 (!Args.hasArg(options::OPT_shared))) { 5217 CmdArgs.push_back("-e"); 5218 CmdArgs.push_back("_start"); 5219 } 5220 5221 if (Args.hasArg(options::OPT_static)) { 5222 CmdArgs.push_back("-Bstatic"); 5223 CmdArgs.push_back("-dn"); 5224 } else { 5225 CmdArgs.push_back("-Bdynamic"); 5226 if (Args.hasArg(options::OPT_shared)) { 5227 CmdArgs.push_back("-shared"); 5228 } else { 5229 CmdArgs.push_back("--dynamic-linker"); 5230 CmdArgs.push_back(Args.MakeArgString(LibPath + "ld.so.1")); 5231 } 5232 } 5233 5234 if (Output.isFilename()) { 5235 CmdArgs.push_back("-o"); 5236 CmdArgs.push_back(Output.getFilename()); 5237 } else { 5238 assert(Output.isNothing() && "Invalid output."); 5239 } 5240 5241 if (!Args.hasArg(options::OPT_nostdlib) && 5242 !Args.hasArg(options::OPT_nostartfiles)) { 5243 if (!Args.hasArg(options::OPT_shared)) { 5244 CmdArgs.push_back(Args.MakeArgString(LibPath + "crt1.o")); 5245 CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o")); 5246 CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o")); 5247 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o")); 5248 } else { 5249 CmdArgs.push_back(Args.MakeArgString(LibPath + "crti.o")); 5250 CmdArgs.push_back(Args.MakeArgString(LibPath + "values-Xa.o")); 5251 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtbegin.o")); 5252 } 5253 if (getToolChain().getDriver().CCCIsCXX()) 5254 CmdArgs.push_back(Args.MakeArgString(LibPath + "cxa_finalize.o")); 5255 } 5256 5257 CmdArgs.push_back(Args.MakeArgString("-L" + GCCLibPath)); 5258 5259 Args.AddAllArgs(CmdArgs, options::OPT_L); 5260 Args.AddAllArgs(CmdArgs, options::OPT_T_Group); 5261 Args.AddAllArgs(CmdArgs, options::OPT_e); 5262 Args.AddAllArgs(CmdArgs, options::OPT_r); 5263 5264 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs); 5265 5266 if (!Args.hasArg(options::OPT_nostdlib) && 5267 !Args.hasArg(options::OPT_nodefaultlibs)) { 5268 if (getToolChain().getDriver().CCCIsCXX()) 5269 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs); 5270 CmdArgs.push_back("-lgcc_s"); 5271 if (!Args.hasArg(options::OPT_shared)) { 5272 CmdArgs.push_back("-lgcc"); 5273 CmdArgs.push_back("-lc"); 5274 CmdArgs.push_back("-lm"); 5275 } 5276 } 5277 5278 if (!Args.hasArg(options::OPT_nostdlib) && 5279 !Args.hasArg(options::OPT_nostartfiles)) { 5280 CmdArgs.push_back(Args.MakeArgString(GCCLibPath + "crtend.o")); 5281 } 5282 CmdArgs.push_back(Args.MakeArgString(LibPath + "crtn.o")); 5283 5284 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple()); 5285 5286 const char *Exec = 5287 Args.MakeArgString(getToolChain().GetProgramPath("ld")); 5288 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 5289} 5290 5291void auroraux::Assemble::ConstructJob(Compilation &C, const JobAction &JA, 5292 const InputInfo &Output, 5293 const InputInfoList &Inputs, 5294 const ArgList &Args, 5295 const char *LinkingOutput) const { 5296 ArgStringList CmdArgs; 5297 5298 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, 5299 options::OPT_Xassembler); 5300 5301 CmdArgs.push_back("-o"); 5302 CmdArgs.push_back(Output.getFilename()); 5303 5304 for (InputInfoList::const_iterator 5305 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 5306 const InputInfo &II = *it; 5307 CmdArgs.push_back(II.getFilename()); 5308 } 5309 5310 const char *Exec = 5311 Args.MakeArgString(getToolChain().GetProgramPath("gas")); 5312 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 5313} 5314 5315void auroraux::Link::ConstructJob(Compilation &C, const JobAction &JA, 5316 const InputInfo &Output, 5317 const InputInfoList &Inputs, 5318 const ArgList &Args, 5319 const char *LinkingOutput) const { 5320 ArgStringList CmdArgs; 5321 5322 if ((!Args.hasArg(options::OPT_nostdlib)) && 5323 (!Args.hasArg(options::OPT_shared))) { 5324 CmdArgs.push_back("-e"); 5325 CmdArgs.push_back("_start"); 5326 } 5327 5328 if (Args.hasArg(options::OPT_static)) { 5329 CmdArgs.push_back("-Bstatic"); 5330 CmdArgs.push_back("-dn"); 5331 } else { 5332// CmdArgs.push_back("--eh-frame-hdr"); 5333 CmdArgs.push_back("-Bdynamic"); 5334 if (Args.hasArg(options::OPT_shared)) { 5335 CmdArgs.push_back("-shared"); 5336 } else { 5337 CmdArgs.push_back("--dynamic-linker"); 5338 CmdArgs.push_back("/lib/ld.so.1"); // 64Bit Path /lib/amd64/ld.so.1 5339 } 5340 } 5341 5342 if (Output.isFilename()) { 5343 CmdArgs.push_back("-o"); 5344 CmdArgs.push_back(Output.getFilename()); 5345 } else { 5346 assert(Output.isNothing() && "Invalid output."); 5347 } 5348 5349 if (!Args.hasArg(options::OPT_nostdlib) && 5350 !Args.hasArg(options::OPT_nostartfiles)) { 5351 if (!Args.hasArg(options::OPT_shared)) { 5352 CmdArgs.push_back(Args.MakeArgString( 5353 getToolChain().GetFilePath("crt1.o"))); 5354 CmdArgs.push_back(Args.MakeArgString( 5355 getToolChain().GetFilePath("crti.o"))); 5356 CmdArgs.push_back(Args.MakeArgString( 5357 getToolChain().GetFilePath("crtbegin.o"))); 5358 } else { 5359 CmdArgs.push_back(Args.MakeArgString( 5360 getToolChain().GetFilePath("crti.o"))); 5361 } 5362 CmdArgs.push_back(Args.MakeArgString( 5363 getToolChain().GetFilePath("crtn.o"))); 5364 } 5365 5366 CmdArgs.push_back(Args.MakeArgString("-L/opt/gcc4/lib/gcc/" 5367 + getToolChain().getTripleString() 5368 + "/4.2.4")); 5369 5370 Args.AddAllArgs(CmdArgs, options::OPT_L); 5371 Args.AddAllArgs(CmdArgs, options::OPT_T_Group); 5372 Args.AddAllArgs(CmdArgs, options::OPT_e); 5373 5374 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs); 5375 5376 if (!Args.hasArg(options::OPT_nostdlib) && 5377 !Args.hasArg(options::OPT_nodefaultlibs)) { 5378 // FIXME: For some reason GCC passes -lgcc before adding 5379 // the default system libraries. Just mimic this for now. 5380 CmdArgs.push_back("-lgcc"); 5381 5382 if (Args.hasArg(options::OPT_pthread)) 5383 CmdArgs.push_back("-pthread"); 5384 if (!Args.hasArg(options::OPT_shared)) 5385 CmdArgs.push_back("-lc"); 5386 CmdArgs.push_back("-lgcc"); 5387 } 5388 5389 if (!Args.hasArg(options::OPT_nostdlib) && 5390 !Args.hasArg(options::OPT_nostartfiles)) { 5391 if (!Args.hasArg(options::OPT_shared)) 5392 CmdArgs.push_back(Args.MakeArgString( 5393 getToolChain().GetFilePath("crtend.o"))); 5394 } 5395 5396 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple()); 5397 5398 const char *Exec = 5399 Args.MakeArgString(getToolChain().GetProgramPath("ld")); 5400 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 5401} 5402 5403void openbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA, 5404 const InputInfo &Output, 5405 const InputInfoList &Inputs, 5406 const ArgList &Args, 5407 const char *LinkingOutput) const { 5408 ArgStringList CmdArgs; 5409 5410 // When building 32-bit code on OpenBSD/amd64, we have to explicitly 5411 // instruct as in the base system to assemble 32-bit code. 5412 if (getToolChain().getArch() == llvm::Triple::x86) 5413 CmdArgs.push_back("--32"); 5414 else if (getToolChain().getArch() == llvm::Triple::ppc) { 5415 CmdArgs.push_back("-mppc"); 5416 CmdArgs.push_back("-many"); 5417 } else if (getToolChain().getArch() == llvm::Triple::mips64 || 5418 getToolChain().getArch() == llvm::Triple::mips64el) { 5419 StringRef CPUName; 5420 StringRef ABIName; 5421 getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName); 5422 5423 CmdArgs.push_back("-mabi"); 5424 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data()); 5425 5426 if (getToolChain().getArch() == llvm::Triple::mips64) 5427 CmdArgs.push_back("-EB"); 5428 else 5429 CmdArgs.push_back("-EL"); 5430 5431 Arg *LastPICArg = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC, 5432 options::OPT_fpic, options::OPT_fno_pic, 5433 options::OPT_fPIE, options::OPT_fno_PIE, 5434 options::OPT_fpie, options::OPT_fno_pie); 5435 if (LastPICArg && 5436 (LastPICArg->getOption().matches(options::OPT_fPIC) || 5437 LastPICArg->getOption().matches(options::OPT_fpic) || 5438 LastPICArg->getOption().matches(options::OPT_fPIE) || 5439 LastPICArg->getOption().matches(options::OPT_fpie))) { 5440 CmdArgs.push_back("-KPIC"); 5441 } 5442 } 5443 5444 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, 5445 options::OPT_Xassembler); 5446 5447 CmdArgs.push_back("-o"); 5448 CmdArgs.push_back(Output.getFilename()); 5449 5450 for (InputInfoList::const_iterator 5451 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 5452 const InputInfo &II = *it; 5453 CmdArgs.push_back(II.getFilename()); 5454 } 5455 5456 const char *Exec = 5457 Args.MakeArgString(getToolChain().GetProgramPath("as")); 5458 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 5459} 5460 5461void openbsd::Link::ConstructJob(Compilation &C, const JobAction &JA, 5462 const InputInfo &Output, 5463 const InputInfoList &Inputs, 5464 const ArgList &Args, 5465 const char *LinkingOutput) const { 5466 const Driver &D = getToolChain().getDriver(); 5467 ArgStringList CmdArgs; 5468 5469 // Silence warning for "clang -g foo.o -o foo" 5470 Args.ClaimAllArgs(options::OPT_g_Group); 5471 // and "clang -emit-llvm foo.o -o foo" 5472 Args.ClaimAllArgs(options::OPT_emit_llvm); 5473 // and for "clang -w foo.o -o foo". Other warning options are already 5474 // handled somewhere else. 5475 Args.ClaimAllArgs(options::OPT_w); 5476 5477 if (getToolChain().getArch() == llvm::Triple::mips64) 5478 CmdArgs.push_back("-EB"); 5479 else if (getToolChain().getArch() == llvm::Triple::mips64el) 5480 CmdArgs.push_back("-EL"); 5481 5482 if ((!Args.hasArg(options::OPT_nostdlib)) && 5483 (!Args.hasArg(options::OPT_shared))) { 5484 CmdArgs.push_back("-e"); 5485 CmdArgs.push_back("__start"); 5486 } 5487 5488 if (Args.hasArg(options::OPT_static)) { 5489 CmdArgs.push_back("-Bstatic"); 5490 } else { 5491 if (Args.hasArg(options::OPT_rdynamic)) 5492 CmdArgs.push_back("-export-dynamic"); 5493 CmdArgs.push_back("--eh-frame-hdr"); 5494 CmdArgs.push_back("-Bdynamic"); 5495 if (Args.hasArg(options::OPT_shared)) { 5496 CmdArgs.push_back("-shared"); 5497 } else { 5498 CmdArgs.push_back("-dynamic-linker"); 5499 CmdArgs.push_back("/usr/libexec/ld.so"); 5500 } 5501 } 5502 5503 if (Args.hasArg(options::OPT_nopie)) 5504 CmdArgs.push_back("-nopie"); 5505 5506 if (Output.isFilename()) { 5507 CmdArgs.push_back("-o"); 5508 CmdArgs.push_back(Output.getFilename()); 5509 } else { 5510 assert(Output.isNothing() && "Invalid output."); 5511 } 5512 5513 if (!Args.hasArg(options::OPT_nostdlib) && 5514 !Args.hasArg(options::OPT_nostartfiles)) { 5515 if (!Args.hasArg(options::OPT_shared)) { 5516 if (Args.hasArg(options::OPT_pg)) 5517 CmdArgs.push_back(Args.MakeArgString( 5518 getToolChain().GetFilePath("gcrt0.o"))); 5519 else 5520 CmdArgs.push_back(Args.MakeArgString( 5521 getToolChain().GetFilePath("crt0.o"))); 5522 CmdArgs.push_back(Args.MakeArgString( 5523 getToolChain().GetFilePath("crtbegin.o"))); 5524 } else { 5525 CmdArgs.push_back(Args.MakeArgString( 5526 getToolChain().GetFilePath("crtbeginS.o"))); 5527 } 5528 } 5529 5530 std::string Triple = getToolChain().getTripleString(); 5531 if (Triple.substr(0, 6) == "x86_64") 5532 Triple.replace(0, 6, "amd64"); 5533 CmdArgs.push_back(Args.MakeArgString("-L/usr/lib/gcc-lib/" + Triple + 5534 "/4.2.1")); 5535 5536 Args.AddAllArgs(CmdArgs, options::OPT_L); 5537 Args.AddAllArgs(CmdArgs, options::OPT_T_Group); 5538 Args.AddAllArgs(CmdArgs, options::OPT_e); 5539 Args.AddAllArgs(CmdArgs, options::OPT_s); 5540 Args.AddAllArgs(CmdArgs, options::OPT_t); 5541 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag); 5542 Args.AddAllArgs(CmdArgs, options::OPT_r); 5543 5544 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs); 5545 5546 if (!Args.hasArg(options::OPT_nostdlib) && 5547 !Args.hasArg(options::OPT_nodefaultlibs)) { 5548 if (D.CCCIsCXX()) { 5549 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs); 5550 if (Args.hasArg(options::OPT_pg)) 5551 CmdArgs.push_back("-lm_p"); 5552 else 5553 CmdArgs.push_back("-lm"); 5554 } 5555 5556 // FIXME: For some reason GCC passes -lgcc before adding 5557 // the default system libraries. Just mimic this for now. 5558 CmdArgs.push_back("-lgcc"); 5559 5560 if (Args.hasArg(options::OPT_pthread)) { 5561 if (!Args.hasArg(options::OPT_shared) && 5562 Args.hasArg(options::OPT_pg)) 5563 CmdArgs.push_back("-lpthread_p"); 5564 else 5565 CmdArgs.push_back("-lpthread"); 5566 } 5567 5568 if (!Args.hasArg(options::OPT_shared)) { 5569 if (Args.hasArg(options::OPT_pg)) 5570 CmdArgs.push_back("-lc_p"); 5571 else 5572 CmdArgs.push_back("-lc"); 5573 } 5574 5575 CmdArgs.push_back("-lgcc"); 5576 } 5577 5578 if (!Args.hasArg(options::OPT_nostdlib) && 5579 !Args.hasArg(options::OPT_nostartfiles)) { 5580 if (!Args.hasArg(options::OPT_shared)) 5581 CmdArgs.push_back(Args.MakeArgString( 5582 getToolChain().GetFilePath("crtend.o"))); 5583 else 5584 CmdArgs.push_back(Args.MakeArgString( 5585 getToolChain().GetFilePath("crtendS.o"))); 5586 } 5587 5588 const char *Exec = 5589 Args.MakeArgString(getToolChain().GetProgramPath("ld")); 5590 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 5591} 5592 5593void bitrig::Assemble::ConstructJob(Compilation &C, const JobAction &JA, 5594 const InputInfo &Output, 5595 const InputInfoList &Inputs, 5596 const ArgList &Args, 5597 const char *LinkingOutput) const { 5598 ArgStringList CmdArgs; 5599 5600 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, 5601 options::OPT_Xassembler); 5602 5603 CmdArgs.push_back("-o"); 5604 CmdArgs.push_back(Output.getFilename()); 5605 5606 for (InputInfoList::const_iterator 5607 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 5608 const InputInfo &II = *it; 5609 CmdArgs.push_back(II.getFilename()); 5610 } 5611 5612 const char *Exec = 5613 Args.MakeArgString(getToolChain().GetProgramPath("as")); 5614 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 5615} 5616 5617void bitrig::Link::ConstructJob(Compilation &C, const JobAction &JA, 5618 const InputInfo &Output, 5619 const InputInfoList &Inputs, 5620 const ArgList &Args, 5621 const char *LinkingOutput) const { 5622 const Driver &D = getToolChain().getDriver(); 5623 ArgStringList CmdArgs; 5624 5625 if ((!Args.hasArg(options::OPT_nostdlib)) && 5626 (!Args.hasArg(options::OPT_shared))) { 5627 CmdArgs.push_back("-e"); 5628 CmdArgs.push_back("__start"); 5629 } 5630 5631 if (Args.hasArg(options::OPT_static)) { 5632 CmdArgs.push_back("-Bstatic"); 5633 } else { 5634 if (Args.hasArg(options::OPT_rdynamic)) 5635 CmdArgs.push_back("-export-dynamic"); 5636 CmdArgs.push_back("--eh-frame-hdr"); 5637 CmdArgs.push_back("-Bdynamic"); 5638 if (Args.hasArg(options::OPT_shared)) { 5639 CmdArgs.push_back("-shared"); 5640 } else { 5641 CmdArgs.push_back("-dynamic-linker"); 5642 CmdArgs.push_back("/usr/libexec/ld.so"); 5643 } 5644 } 5645 5646 if (Output.isFilename()) { 5647 CmdArgs.push_back("-o"); 5648 CmdArgs.push_back(Output.getFilename()); 5649 } else { 5650 assert(Output.isNothing() && "Invalid output."); 5651 } 5652 5653 if (!Args.hasArg(options::OPT_nostdlib) && 5654 !Args.hasArg(options::OPT_nostartfiles)) { 5655 if (!Args.hasArg(options::OPT_shared)) { 5656 if (Args.hasArg(options::OPT_pg)) 5657 CmdArgs.push_back(Args.MakeArgString( 5658 getToolChain().GetFilePath("gcrt0.o"))); 5659 else 5660 CmdArgs.push_back(Args.MakeArgString( 5661 getToolChain().GetFilePath("crt0.o"))); 5662 CmdArgs.push_back(Args.MakeArgString( 5663 getToolChain().GetFilePath("crtbegin.o"))); 5664 } else { 5665 CmdArgs.push_back(Args.MakeArgString( 5666 getToolChain().GetFilePath("crtbeginS.o"))); 5667 } 5668 } 5669 5670 Args.AddAllArgs(CmdArgs, options::OPT_L); 5671 Args.AddAllArgs(CmdArgs, options::OPT_T_Group); 5672 Args.AddAllArgs(CmdArgs, options::OPT_e); 5673 5674 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs); 5675 5676 if (!Args.hasArg(options::OPT_nostdlib) && 5677 !Args.hasArg(options::OPT_nodefaultlibs)) { 5678 if (D.CCCIsCXX()) { 5679 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs); 5680 if (Args.hasArg(options::OPT_pg)) 5681 CmdArgs.push_back("-lm_p"); 5682 else 5683 CmdArgs.push_back("-lm"); 5684 } 5685 5686 if (Args.hasArg(options::OPT_pthread)) { 5687 if (!Args.hasArg(options::OPT_shared) && 5688 Args.hasArg(options::OPT_pg)) 5689 CmdArgs.push_back("-lpthread_p"); 5690 else 5691 CmdArgs.push_back("-lpthread"); 5692 } 5693 5694 if (!Args.hasArg(options::OPT_shared)) { 5695 if (Args.hasArg(options::OPT_pg)) 5696 CmdArgs.push_back("-lc_p"); 5697 else 5698 CmdArgs.push_back("-lc"); 5699 } 5700 5701 StringRef MyArch; 5702 switch (getToolChain().getTriple().getArch()) { 5703 case llvm::Triple::arm: 5704 MyArch = "arm"; 5705 break; 5706 case llvm::Triple::x86: 5707 MyArch = "i386"; 5708 break; 5709 case llvm::Triple::x86_64: 5710 MyArch = "amd64"; 5711 break; 5712 default: 5713 llvm_unreachable("Unsupported architecture"); 5714 } 5715 CmdArgs.push_back(Args.MakeArgString("-lclang_rt." + MyArch)); 5716 } 5717 5718 if (!Args.hasArg(options::OPT_nostdlib) && 5719 !Args.hasArg(options::OPT_nostartfiles)) { 5720 if (!Args.hasArg(options::OPT_shared)) 5721 CmdArgs.push_back(Args.MakeArgString( 5722 getToolChain().GetFilePath("crtend.o"))); 5723 else 5724 CmdArgs.push_back(Args.MakeArgString( 5725 getToolChain().GetFilePath("crtendS.o"))); 5726 } 5727 5728 const char *Exec = 5729 Args.MakeArgString(getToolChain().GetProgramPath("ld")); 5730 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 5731} 5732 5733void freebsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA, 5734 const InputInfo &Output, 5735 const InputInfoList &Inputs, 5736 const ArgList &Args, 5737 const char *LinkingOutput) const { 5738 ArgStringList CmdArgs; 5739 5740 // When building 32-bit code on FreeBSD/amd64, we have to explicitly 5741 // instruct as in the base system to assemble 32-bit code. 5742 if (getToolChain().getArch() == llvm::Triple::x86) 5743 CmdArgs.push_back("--32"); 5744 else if (getToolChain().getArch() == llvm::Triple::ppc) 5745 CmdArgs.push_back("-a32"); 5746 else if (getToolChain().getArch() == llvm::Triple::mips || 5747 getToolChain().getArch() == llvm::Triple::mipsel || 5748 getToolChain().getArch() == llvm::Triple::mips64 || 5749 getToolChain().getArch() == llvm::Triple::mips64el) { 5750 StringRef CPUName; 5751 StringRef ABIName; 5752 getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName); 5753 5754 CmdArgs.push_back("-march"); 5755 CmdArgs.push_back(CPUName.data()); 5756 5757 CmdArgs.push_back("-mabi"); 5758 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data()); 5759 5760 if (getToolChain().getArch() == llvm::Triple::mips || 5761 getToolChain().getArch() == llvm::Triple::mips64) 5762 CmdArgs.push_back("-EB"); 5763 else 5764 CmdArgs.push_back("-EL"); 5765 5766 Arg *LastPICArg = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC, 5767 options::OPT_fpic, options::OPT_fno_pic, 5768 options::OPT_fPIE, options::OPT_fno_PIE, 5769 options::OPT_fpie, options::OPT_fno_pie); 5770 if (LastPICArg && 5771 (LastPICArg->getOption().matches(options::OPT_fPIC) || 5772 LastPICArg->getOption().matches(options::OPT_fpic) || 5773 LastPICArg->getOption().matches(options::OPT_fPIE) || 5774 LastPICArg->getOption().matches(options::OPT_fpie))) { 5775 CmdArgs.push_back("-KPIC"); 5776 } 5777 } else if (getToolChain().getArch() == llvm::Triple::arm || 5778 getToolChain().getArch() == llvm::Triple::thumb) { 5779 CmdArgs.push_back("-mfpu=softvfp"); 5780 switch(getToolChain().getTriple().getEnvironment()) { 5781 case llvm::Triple::GNUEABI: 5782 case llvm::Triple::EABI: 5783 CmdArgs.push_back("-meabi=5"); 5784 break; 5785 5786 default: 5787 CmdArgs.push_back("-matpcs"); 5788 } 5789 } else if (getToolChain().getArch() == llvm::Triple::sparc || 5790 getToolChain().getArch() == llvm::Triple::sparcv9) { 5791 if (getToolChain().getArch() == llvm::Triple::sparc) 5792 CmdArgs.push_back("-Av8plusa"); 5793 else 5794 CmdArgs.push_back("-Av9a"); 5795 5796 Arg *LastPICArg = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC, 5797 options::OPT_fpic, options::OPT_fno_pic, 5798 options::OPT_fPIE, options::OPT_fno_PIE, 5799 options::OPT_fpie, options::OPT_fno_pie); 5800 if (LastPICArg && 5801 (LastPICArg->getOption().matches(options::OPT_fPIC) || 5802 LastPICArg->getOption().matches(options::OPT_fpic) || 5803 LastPICArg->getOption().matches(options::OPT_fPIE) || 5804 LastPICArg->getOption().matches(options::OPT_fpie))) { 5805 CmdArgs.push_back("-KPIC"); 5806 } 5807 } 5808 5809 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, 5810 options::OPT_Xassembler); 5811 5812 CmdArgs.push_back("-o"); 5813 CmdArgs.push_back(Output.getFilename()); 5814 5815 for (InputInfoList::const_iterator 5816 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 5817 const InputInfo &II = *it; 5818 CmdArgs.push_back(II.getFilename()); 5819 } 5820 5821 const char *Exec = 5822 Args.MakeArgString(getToolChain().GetProgramPath("as")); 5823 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 5824} 5825 5826void freebsd::Link::ConstructJob(Compilation &C, const JobAction &JA, 5827 const InputInfo &Output, 5828 const InputInfoList &Inputs, 5829 const ArgList &Args, 5830 const char *LinkingOutput) const { 5831 const toolchains::FreeBSD& ToolChain = 5832 static_cast<const toolchains::FreeBSD&>(getToolChain()); 5833 const Driver &D = ToolChain.getDriver(); 5834 ArgStringList CmdArgs; 5835 5836 // Silence warning for "clang -g foo.o -o foo" 5837 Args.ClaimAllArgs(options::OPT_g_Group); 5838 // and "clang -emit-llvm foo.o -o foo" 5839 Args.ClaimAllArgs(options::OPT_emit_llvm); 5840 // and for "clang -w foo.o -o foo". Other warning options are already 5841 // handled somewhere else. 5842 Args.ClaimAllArgs(options::OPT_w); 5843 5844 if (!D.SysRoot.empty()) 5845 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot)); 5846 5847 if (Args.hasArg(options::OPT_pie)) 5848 CmdArgs.push_back("-pie"); 5849 5850 if (Args.hasArg(options::OPT_static)) { 5851 CmdArgs.push_back("-Bstatic"); 5852 } else { 5853 if (Args.hasArg(options::OPT_rdynamic)) 5854 CmdArgs.push_back("-export-dynamic"); 5855 CmdArgs.push_back("--eh-frame-hdr"); 5856 if (Args.hasArg(options::OPT_shared)) { 5857 CmdArgs.push_back("-Bshareable"); 5858 } else { 5859 CmdArgs.push_back("-dynamic-linker"); 5860 CmdArgs.push_back("/libexec/ld-elf.so.1"); 5861 } 5862 if (ToolChain.getTriple().getOSMajorVersion() >= 9) { 5863 llvm::Triple::ArchType Arch = ToolChain.getArch(); 5864 if (Arch == llvm::Triple::arm || Arch == llvm::Triple::sparc || 5865 Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64) { 5866 CmdArgs.push_back("--hash-style=both"); 5867 } 5868 } 5869 CmdArgs.push_back("--enable-new-dtags"); 5870 } 5871 5872 // When building 32-bit code on FreeBSD/amd64, we have to explicitly 5873 // instruct ld in the base system to link 32-bit code. 5874 if (ToolChain.getArch() == llvm::Triple::x86) { 5875 CmdArgs.push_back("-m"); 5876 CmdArgs.push_back("elf_i386_fbsd"); 5877 } 5878 5879 if (ToolChain.getArch() == llvm::Triple::ppc) { 5880 CmdArgs.push_back("-m"); 5881 CmdArgs.push_back("elf32ppc_fbsd"); 5882 } 5883 5884 if (Output.isFilename()) { 5885 CmdArgs.push_back("-o"); 5886 CmdArgs.push_back(Output.getFilename()); 5887 } else { 5888 assert(Output.isNothing() && "Invalid output."); 5889 } 5890 5891 if (!Args.hasArg(options::OPT_nostdlib) && 5892 !Args.hasArg(options::OPT_nostartfiles)) { 5893 const char *crt1 = NULL; 5894 if (!Args.hasArg(options::OPT_shared)) { 5895 if (Args.hasArg(options::OPT_pg)) 5896 crt1 = "gcrt1.o"; 5897 else if (Args.hasArg(options::OPT_pie)) 5898 crt1 = "Scrt1.o"; 5899 else 5900 crt1 = "crt1.o"; 5901 } 5902 if (crt1) 5903 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1))); 5904 5905 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o"))); 5906 5907 const char *crtbegin = NULL; 5908 if (Args.hasArg(options::OPT_static)) 5909 crtbegin = "crtbeginT.o"; 5910 else if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie)) 5911 crtbegin = "crtbeginS.o"; 5912 else 5913 crtbegin = "crtbegin.o"; 5914 5915 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin))); 5916 } 5917 5918 Args.AddAllArgs(CmdArgs, options::OPT_L); 5919 const ToolChain::path_list Paths = ToolChain.getFilePaths(); 5920 for (ToolChain::path_list::const_iterator i = Paths.begin(), e = Paths.end(); 5921 i != e; ++i) 5922 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + *i)); 5923 Args.AddAllArgs(CmdArgs, options::OPT_T_Group); 5924 Args.AddAllArgs(CmdArgs, options::OPT_e); 5925 Args.AddAllArgs(CmdArgs, options::OPT_s); 5926 Args.AddAllArgs(CmdArgs, options::OPT_t); 5927 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag); 5928 Args.AddAllArgs(CmdArgs, options::OPT_r); 5929 5930 // Tell the linker to load the plugin. This has to come before AddLinkerInputs 5931 // as gold requires -plugin to come before any -plugin-opt that -Wl might 5932 // forward. 5933 if (D.IsUsingLTO(Args)) { 5934 CmdArgs.push_back("-plugin"); 5935 std::string Plugin = ToolChain.getDriver().Dir + "/../lib/LLVMgold.so"; 5936 CmdArgs.push_back(Args.MakeArgString(Plugin)); 5937 5938 // Try to pass driver level flags relevant to LTO code generation down to 5939 // the plugin. 5940 5941 // Handle flags for selecting CPU variants. 5942 std::string CPU = getCPUName(Args, ToolChain.getTriple()); 5943 if (!CPU.empty()) { 5944 CmdArgs.push_back( 5945 Args.MakeArgString(Twine("-plugin-opt=mcpu=") + 5946 CPU)); 5947 } 5948 } 5949 5950 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs); 5951 5952 if (!Args.hasArg(options::OPT_nostdlib) && 5953 !Args.hasArg(options::OPT_nodefaultlibs)) { 5954 if (D.CCCIsCXX()) { 5955 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs); 5956 if (Args.hasArg(options::OPT_pg)) 5957 CmdArgs.push_back("-lm_p"); 5958 else 5959 CmdArgs.push_back("-lm"); 5960 } 5961 // FIXME: For some reason GCC passes -lgcc and -lgcc_s before adding 5962 // the default system libraries. Just mimic this for now. 5963 if (Args.hasArg(options::OPT_pg)) 5964 CmdArgs.push_back("-lgcc_p"); 5965 else 5966 CmdArgs.push_back("-lgcc"); 5967 if (Args.hasArg(options::OPT_static)) { 5968 CmdArgs.push_back("-lgcc_eh"); 5969 } else if (Args.hasArg(options::OPT_pg)) { 5970 CmdArgs.push_back("-lgcc_eh_p"); 5971 } else { 5972 CmdArgs.push_back("--as-needed"); 5973 CmdArgs.push_back("-lgcc_s"); 5974 CmdArgs.push_back("--no-as-needed"); 5975 } 5976 5977 if (Args.hasArg(options::OPT_pthread)) { 5978 if (Args.hasArg(options::OPT_pg)) 5979 CmdArgs.push_back("-lpthread_p"); 5980 else 5981 CmdArgs.push_back("-lpthread"); 5982 } 5983 5984 if (Args.hasArg(options::OPT_pg)) { 5985 if (Args.hasArg(options::OPT_shared)) 5986 CmdArgs.push_back("-lc"); 5987 else 5988 CmdArgs.push_back("-lc_p"); 5989 CmdArgs.push_back("-lgcc_p"); 5990 } else { 5991 CmdArgs.push_back("-lc"); 5992 CmdArgs.push_back("-lgcc"); 5993 } 5994 5995 if (Args.hasArg(options::OPT_static)) { 5996 CmdArgs.push_back("-lgcc_eh"); 5997 } else if (Args.hasArg(options::OPT_pg)) { 5998 CmdArgs.push_back("-lgcc_eh_p"); 5999 } else { 6000 CmdArgs.push_back("--as-needed"); 6001 CmdArgs.push_back("-lgcc_s"); 6002 CmdArgs.push_back("--no-as-needed"); 6003 } 6004 } 6005 6006 if (!Args.hasArg(options::OPT_nostdlib) && 6007 !Args.hasArg(options::OPT_nostartfiles)) { 6008 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie)) 6009 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtendS.o"))); 6010 else 6011 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtend.o"))); 6012 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o"))); 6013 } 6014 6015 addProfileRT(ToolChain, Args, CmdArgs, ToolChain.getTriple()); 6016 6017 const char *Exec = 6018 Args.MakeArgString(ToolChain.GetProgramPath("ld")); 6019 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 6020} 6021 6022void netbsd::Assemble::ConstructJob(Compilation &C, const JobAction &JA, 6023 const InputInfo &Output, 6024 const InputInfoList &Inputs, 6025 const ArgList &Args, 6026 const char *LinkingOutput) const { 6027 ArgStringList CmdArgs; 6028 6029 // When building 32-bit code on NetBSD/amd64, we have to explicitly 6030 // instruct as in the base system to assemble 32-bit code. 6031 if (getToolChain().getArch() == llvm::Triple::x86) 6032 CmdArgs.push_back("--32"); 6033 6034 // Pass the target CPU to GNU as for ARM, since the source code might 6035 // not have the correct .cpu annotation. 6036 if (getToolChain().getArch() == llvm::Triple::arm) { 6037 std::string MArch(getARMTargetCPU(Args, getToolChain().getTriple())); 6038 CmdArgs.push_back(Args.MakeArgString("-mcpu=" + MArch)); 6039 } 6040 6041 if (getToolChain().getArch() == llvm::Triple::mips || 6042 getToolChain().getArch() == llvm::Triple::mipsel || 6043 getToolChain().getArch() == llvm::Triple::mips64 || 6044 getToolChain().getArch() == llvm::Triple::mips64el) { 6045 StringRef CPUName; 6046 StringRef ABIName; 6047 getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName); 6048 6049 CmdArgs.push_back("-march"); 6050 CmdArgs.push_back(CPUName.data()); 6051 6052 CmdArgs.push_back("-mabi"); 6053 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data()); 6054 6055 if (getToolChain().getArch() == llvm::Triple::mips || 6056 getToolChain().getArch() == llvm::Triple::mips64) 6057 CmdArgs.push_back("-EB"); 6058 else 6059 CmdArgs.push_back("-EL"); 6060 6061 Arg *LastPICArg = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC, 6062 options::OPT_fpic, options::OPT_fno_pic, 6063 options::OPT_fPIE, options::OPT_fno_PIE, 6064 options::OPT_fpie, options::OPT_fno_pie); 6065 if (LastPICArg && 6066 (LastPICArg->getOption().matches(options::OPT_fPIC) || 6067 LastPICArg->getOption().matches(options::OPT_fpic) || 6068 LastPICArg->getOption().matches(options::OPT_fPIE) || 6069 LastPICArg->getOption().matches(options::OPT_fpie))) { 6070 CmdArgs.push_back("-KPIC"); 6071 } 6072 } 6073 6074 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, 6075 options::OPT_Xassembler); 6076 6077 CmdArgs.push_back("-o"); 6078 CmdArgs.push_back(Output.getFilename()); 6079 6080 for (InputInfoList::const_iterator 6081 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 6082 const InputInfo &II = *it; 6083 CmdArgs.push_back(II.getFilename()); 6084 } 6085 6086 const char *Exec = Args.MakeArgString((getToolChain().GetProgramPath("as"))); 6087 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 6088} 6089 6090void netbsd::Link::ConstructJob(Compilation &C, const JobAction &JA, 6091 const InputInfo &Output, 6092 const InputInfoList &Inputs, 6093 const ArgList &Args, 6094 const char *LinkingOutput) const { 6095 const Driver &D = getToolChain().getDriver(); 6096 ArgStringList CmdArgs; 6097 6098 if (!D.SysRoot.empty()) 6099 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot)); 6100 6101 if (Args.hasArg(options::OPT_static)) { 6102 CmdArgs.push_back("-Bstatic"); 6103 } else { 6104 if (Args.hasArg(options::OPT_rdynamic)) 6105 CmdArgs.push_back("-export-dynamic"); 6106 CmdArgs.push_back("--eh-frame-hdr"); 6107 if (Args.hasArg(options::OPT_shared)) { 6108 CmdArgs.push_back("-Bshareable"); 6109 } else { 6110 CmdArgs.push_back("-dynamic-linker"); 6111 CmdArgs.push_back("/libexec/ld.elf_so"); 6112 } 6113 } 6114 6115 // When building 32-bit code on NetBSD/amd64, we have to explicitly 6116 // instruct ld in the base system to link 32-bit code. 6117 if (getToolChain().getArch() == llvm::Triple::x86) { 6118 CmdArgs.push_back("-m"); 6119 CmdArgs.push_back("elf_i386"); 6120 } 6121 6122 if (Output.isFilename()) { 6123 CmdArgs.push_back("-o"); 6124 CmdArgs.push_back(Output.getFilename()); 6125 } else { 6126 assert(Output.isNothing() && "Invalid output."); 6127 } 6128 6129 if (!Args.hasArg(options::OPT_nostdlib) && 6130 !Args.hasArg(options::OPT_nostartfiles)) { 6131 if (!Args.hasArg(options::OPT_shared)) { 6132 CmdArgs.push_back(Args.MakeArgString( 6133 getToolChain().GetFilePath("crt0.o"))); 6134 CmdArgs.push_back(Args.MakeArgString( 6135 getToolChain().GetFilePath("crti.o"))); 6136 CmdArgs.push_back(Args.MakeArgString( 6137 getToolChain().GetFilePath("crtbegin.o"))); 6138 } else { 6139 CmdArgs.push_back(Args.MakeArgString( 6140 getToolChain().GetFilePath("crti.o"))); 6141 CmdArgs.push_back(Args.MakeArgString( 6142 getToolChain().GetFilePath("crtbeginS.o"))); 6143 } 6144 } 6145 6146 Args.AddAllArgs(CmdArgs, options::OPT_L); 6147 Args.AddAllArgs(CmdArgs, options::OPT_T_Group); 6148 Args.AddAllArgs(CmdArgs, options::OPT_e); 6149 Args.AddAllArgs(CmdArgs, options::OPT_s); 6150 Args.AddAllArgs(CmdArgs, options::OPT_t); 6151 Args.AddAllArgs(CmdArgs, options::OPT_Z_Flag); 6152 Args.AddAllArgs(CmdArgs, options::OPT_r); 6153 6154 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs); 6155 6156 unsigned Major, Minor, Micro; 6157 getToolChain().getTriple().getOSVersion(Major, Minor, Micro); 6158 bool useLibgcc = true; 6159 if (Major >= 7 || (Major == 6 && Minor == 99 && Micro >= 23) || Major == 0) { 6160 if (getToolChain().getArch() == llvm::Triple::x86 || 6161 getToolChain().getArch() == llvm::Triple::x86_64) 6162 useLibgcc = false; 6163 } 6164 6165 if (!Args.hasArg(options::OPT_nostdlib) && 6166 !Args.hasArg(options::OPT_nodefaultlibs)) { 6167 if (D.CCCIsCXX()) { 6168 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs); 6169 CmdArgs.push_back("-lm"); 6170 } 6171 if (Args.hasArg(options::OPT_pthread)) 6172 CmdArgs.push_back("-lpthread"); 6173 CmdArgs.push_back("-lc"); 6174 6175 if (useLibgcc) { 6176 if (Args.hasArg(options::OPT_static)) { 6177 // libgcc_eh depends on libc, so resolve as much as possible, 6178 // pull in any new requirements from libc and then get the rest 6179 // of libgcc. 6180 CmdArgs.push_back("-lgcc_eh"); 6181 CmdArgs.push_back("-lc"); 6182 CmdArgs.push_back("-lgcc"); 6183 } else { 6184 CmdArgs.push_back("-lgcc"); 6185 CmdArgs.push_back("--as-needed"); 6186 CmdArgs.push_back("-lgcc_s"); 6187 CmdArgs.push_back("--no-as-needed"); 6188 } 6189 } 6190 } 6191 6192 if (!Args.hasArg(options::OPT_nostdlib) && 6193 !Args.hasArg(options::OPT_nostartfiles)) { 6194 if (!Args.hasArg(options::OPT_shared)) 6195 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath( 6196 "crtend.o"))); 6197 else 6198 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath( 6199 "crtendS.o"))); 6200 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath( 6201 "crtn.o"))); 6202 } 6203 6204 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple()); 6205 6206 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("ld")); 6207 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 6208} 6209 6210void gnutools::Assemble::ConstructJob(Compilation &C, const JobAction &JA, 6211 const InputInfo &Output, 6212 const InputInfoList &Inputs, 6213 const ArgList &Args, 6214 const char *LinkingOutput) const { 6215 ArgStringList CmdArgs; 6216 bool NeedsKPIC = false; 6217 6218 // Add --32/--64 to make sure we get the format we want. 6219 // This is incomplete 6220 if (getToolChain().getArch() == llvm::Triple::x86) { 6221 CmdArgs.push_back("--32"); 6222 } else if (getToolChain().getArch() == llvm::Triple::x86_64) { 6223 CmdArgs.push_back("--64"); 6224 } else if (getToolChain().getArch() == llvm::Triple::ppc) { 6225 CmdArgs.push_back("-a32"); 6226 CmdArgs.push_back("-mppc"); 6227 CmdArgs.push_back("-many"); 6228 } else if (getToolChain().getArch() == llvm::Triple::ppc64) { 6229 CmdArgs.push_back("-a64"); 6230 CmdArgs.push_back("-mppc64"); 6231 CmdArgs.push_back("-many"); 6232 } else if (getToolChain().getArch() == llvm::Triple::ppc64le) { 6233 CmdArgs.push_back("-a64"); 6234 CmdArgs.push_back("-mppc64le"); 6235 CmdArgs.push_back("-many"); 6236 } else if (getToolChain().getArch() == llvm::Triple::sparc) { 6237 CmdArgs.push_back("-32"); 6238 CmdArgs.push_back("-Av8plusa"); 6239 NeedsKPIC = true; 6240 } else if (getToolChain().getArch() == llvm::Triple::sparcv9) { 6241 CmdArgs.push_back("-64"); 6242 CmdArgs.push_back("-Av9a"); 6243 NeedsKPIC = true; 6244 } else if (getToolChain().getArch() == llvm::Triple::arm) { 6245 StringRef MArch = getToolChain().getArchName(); 6246 if (MArch == "armv7" || MArch == "armv7a" || MArch == "armv7-a") 6247 CmdArgs.push_back("-mfpu=neon"); 6248 if (MArch == "armv8" || MArch == "armv8a" || MArch == "armv8-a") 6249 CmdArgs.push_back("-mfpu=crypto-neon-fp-armv8"); 6250 6251 StringRef ARMFloatABI = getARMFloatABI(getToolChain().getDriver(), Args, 6252 getToolChain().getTriple()); 6253 CmdArgs.push_back(Args.MakeArgString("-mfloat-abi=" + ARMFloatABI)); 6254 6255 Args.AddLastArg(CmdArgs, options::OPT_march_EQ); 6256 Args.AddLastArg(CmdArgs, options::OPT_mcpu_EQ); 6257 Args.AddLastArg(CmdArgs, options::OPT_mfpu_EQ); 6258 } else if (getToolChain().getArch() == llvm::Triple::mips || 6259 getToolChain().getArch() == llvm::Triple::mipsel || 6260 getToolChain().getArch() == llvm::Triple::mips64 || 6261 getToolChain().getArch() == llvm::Triple::mips64el) { 6262 StringRef CPUName; 6263 StringRef ABIName; 6264 getMipsCPUAndABI(Args, getToolChain().getTriple(), CPUName, ABIName); 6265 6266 CmdArgs.push_back("-march"); 6267 CmdArgs.push_back(CPUName.data()); 6268 6269 CmdArgs.push_back("-mabi"); 6270 CmdArgs.push_back(getGnuCompatibleMipsABIName(ABIName).data()); 6271 6272 if (getToolChain().getArch() == llvm::Triple::mips || 6273 getToolChain().getArch() == llvm::Triple::mips64) 6274 CmdArgs.push_back("-EB"); 6275 else 6276 CmdArgs.push_back("-EL"); 6277 6278 if (Arg *A = Args.getLastArg(options::OPT_mnan_EQ)) { 6279 if (StringRef(A->getValue()) == "2008") 6280 CmdArgs.push_back(Args.MakeArgString("-mnan=2008")); 6281 } 6282 6283 if (Arg *A = Args.getLastArg(options::OPT_mfp32, options::OPT_mfp64)) { 6284 if (A->getOption().matches(options::OPT_mfp32)) 6285 CmdArgs.push_back(Args.MakeArgString("-mfp32")); 6286 else 6287 CmdArgs.push_back(Args.MakeArgString("-mfp64")); 6288 } 6289 6290 Args.AddLastArg(CmdArgs, options::OPT_mips16, options::OPT_mno_mips16); 6291 Args.AddLastArg(CmdArgs, options::OPT_mmicromips, 6292 options::OPT_mno_micromips); 6293 Args.AddLastArg(CmdArgs, options::OPT_mdsp, options::OPT_mno_dsp); 6294 Args.AddLastArg(CmdArgs, options::OPT_mdspr2, options::OPT_mno_dspr2); 6295 6296 if (Arg *A = Args.getLastArg(options::OPT_mmsa, options::OPT_mno_msa)) { 6297 // Do not use AddLastArg because not all versions of MIPS assembler 6298 // support -mmsa / -mno-msa options. 6299 if (A->getOption().matches(options::OPT_mmsa)) 6300 CmdArgs.push_back(Args.MakeArgString("-mmsa")); 6301 } 6302 6303 NeedsKPIC = true; 6304 } else if (getToolChain().getArch() == llvm::Triple::systemz) { 6305 // Always pass an -march option, since our default of z10 is later 6306 // than the GNU assembler's default. 6307 StringRef CPUName = getSystemZTargetCPU(Args); 6308 CmdArgs.push_back(Args.MakeArgString("-march=" + CPUName)); 6309 } 6310 6311 if (NeedsKPIC) { 6312 Arg *LastPICArg = Args.getLastArg(options::OPT_fPIC, options::OPT_fno_PIC, 6313 options::OPT_fpic, options::OPT_fno_pic, 6314 options::OPT_fPIE, options::OPT_fno_PIE, 6315 options::OPT_fpie, options::OPT_fno_pie); 6316 if (LastPICArg && 6317 (LastPICArg->getOption().matches(options::OPT_fPIC) || 6318 LastPICArg->getOption().matches(options::OPT_fpic) || 6319 LastPICArg->getOption().matches(options::OPT_fPIE) || 6320 LastPICArg->getOption().matches(options::OPT_fpie))) { 6321 CmdArgs.push_back("-KPIC"); 6322 } 6323 } 6324 6325 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, 6326 options::OPT_Xassembler); 6327 6328 CmdArgs.push_back("-o"); 6329 CmdArgs.push_back(Output.getFilename()); 6330 6331 for (InputInfoList::const_iterator 6332 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 6333 const InputInfo &II = *it; 6334 CmdArgs.push_back(II.getFilename()); 6335 } 6336 6337 const char *Exec = 6338 Args.MakeArgString(getToolChain().GetProgramPath("as")); 6339 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 6340 6341 // Handle the debug info splitting at object creation time if we're 6342 // creating an object. 6343 // TODO: Currently only works on linux with newer objcopy. 6344 if (Args.hasArg(options::OPT_gsplit_dwarf) && 6345 getToolChain().getTriple().isOSLinux()) 6346 SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output, 6347 SplitDebugName(Args, Inputs)); 6348} 6349 6350static void AddLibgcc(llvm::Triple Triple, const Driver &D, 6351 ArgStringList &CmdArgs, const ArgList &Args) { 6352 bool isAndroid = Triple.getEnvironment() == llvm::Triple::Android; 6353 bool StaticLibgcc = Args.hasArg(options::OPT_static_libgcc) || 6354 Args.hasArg(options::OPT_static); 6355 if (!D.CCCIsCXX()) 6356 CmdArgs.push_back("-lgcc"); 6357 6358 if (StaticLibgcc || isAndroid) { 6359 if (D.CCCIsCXX()) 6360 CmdArgs.push_back("-lgcc"); 6361 } else { 6362 if (!D.CCCIsCXX()) 6363 CmdArgs.push_back("--as-needed"); 6364 CmdArgs.push_back("-lgcc_s"); 6365 if (!D.CCCIsCXX()) 6366 CmdArgs.push_back("--no-as-needed"); 6367 } 6368 6369 if (StaticLibgcc && !isAndroid) 6370 CmdArgs.push_back("-lgcc_eh"); 6371 else if (!Args.hasArg(options::OPT_shared) && D.CCCIsCXX()) 6372 CmdArgs.push_back("-lgcc"); 6373 6374 // According to Android ABI, we have to link with libdl if we are 6375 // linking with non-static libgcc. 6376 // 6377 // NOTE: This fixes a link error on Android MIPS as well. The non-static 6378 // libgcc for MIPS relies on _Unwind_Find_FDE and dl_iterate_phdr from libdl. 6379 if (isAndroid && !StaticLibgcc) 6380 CmdArgs.push_back("-ldl"); 6381} 6382 6383static bool hasMipsN32ABIArg(const ArgList &Args) { 6384 Arg *A = Args.getLastArg(options::OPT_mabi_EQ); 6385 return A && (A->getValue() == StringRef("n32")); 6386} 6387 6388static StringRef getLinuxDynamicLinker(const ArgList &Args, 6389 const toolchains::Linux &ToolChain) { 6390 if (ToolChain.getTriple().getEnvironment() == llvm::Triple::Android) 6391 return "/system/bin/linker"; 6392 else if (ToolChain.getArch() == llvm::Triple::x86 || 6393 ToolChain.getArch() == llvm::Triple::sparc) 6394 return "/lib/ld-linux.so.2"; 6395 else if (ToolChain.getArch() == llvm::Triple::aarch64) 6396 return "/lib/ld-linux-aarch64.so.1"; 6397 else if (ToolChain.getArch() == llvm::Triple::arm || 6398 ToolChain.getArch() == llvm::Triple::thumb) { 6399 if (ToolChain.getTriple().getEnvironment() == llvm::Triple::GNUEABIHF) 6400 return "/lib/ld-linux-armhf.so.3"; 6401 else 6402 return "/lib/ld-linux.so.3"; 6403 } else if (ToolChain.getArch() == llvm::Triple::mips || 6404 ToolChain.getArch() == llvm::Triple::mipsel) 6405 return "/lib/ld.so.1"; 6406 else if (ToolChain.getArch() == llvm::Triple::mips64 || 6407 ToolChain.getArch() == llvm::Triple::mips64el) { 6408 if (hasMipsN32ABIArg(Args)) 6409 return "/lib32/ld.so.1"; 6410 else 6411 return "/lib64/ld.so.1"; 6412 } else if (ToolChain.getArch() == llvm::Triple::ppc) 6413 return "/lib/ld.so.1"; 6414 else if (ToolChain.getArch() == llvm::Triple::ppc64 || 6415 ToolChain.getArch() == llvm::Triple::ppc64le || 6416 ToolChain.getArch() == llvm::Triple::systemz) 6417 return "/lib64/ld64.so.1"; 6418 else if (ToolChain.getArch() == llvm::Triple::sparcv9) 6419 return "/lib64/ld-linux.so.2"; 6420 else 6421 return "/lib64/ld-linux-x86-64.so.2"; 6422} 6423 6424void gnutools::Link::ConstructJob(Compilation &C, const JobAction &JA, 6425 const InputInfo &Output, 6426 const InputInfoList &Inputs, 6427 const ArgList &Args, 6428 const char *LinkingOutput) const { 6429 const toolchains::Linux& ToolChain = 6430 static_cast<const toolchains::Linux&>(getToolChain()); 6431 const Driver &D = ToolChain.getDriver(); 6432 const bool isAndroid = 6433 ToolChain.getTriple().getEnvironment() == llvm::Triple::Android; 6434 const SanitizerArgs &Sanitize = ToolChain.getSanitizerArgs(); 6435 const bool IsPIE = 6436 !Args.hasArg(options::OPT_shared) && 6437 (Args.hasArg(options::OPT_pie) || Sanitize.hasZeroBaseShadow()); 6438 6439 ArgStringList CmdArgs; 6440 6441 // Silence warning for "clang -g foo.o -o foo" 6442 Args.ClaimAllArgs(options::OPT_g_Group); 6443 // and "clang -emit-llvm foo.o -o foo" 6444 Args.ClaimAllArgs(options::OPT_emit_llvm); 6445 // and for "clang -w foo.o -o foo". Other warning options are already 6446 // handled somewhere else. 6447 Args.ClaimAllArgs(options::OPT_w); 6448 6449 if (!D.SysRoot.empty()) 6450 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot)); 6451 6452 if (IsPIE) 6453 CmdArgs.push_back("-pie"); 6454 6455 if (Args.hasArg(options::OPT_rdynamic)) 6456 CmdArgs.push_back("-export-dynamic"); 6457 6458 if (Args.hasArg(options::OPT_s)) 6459 CmdArgs.push_back("-s"); 6460 6461 for (std::vector<std::string>::const_iterator i = ToolChain.ExtraOpts.begin(), 6462 e = ToolChain.ExtraOpts.end(); 6463 i != e; ++i) 6464 CmdArgs.push_back(i->c_str()); 6465 6466 if (!Args.hasArg(options::OPT_static)) { 6467 CmdArgs.push_back("--eh-frame-hdr"); 6468 } 6469 6470 CmdArgs.push_back("-m"); 6471 if (ToolChain.getArch() == llvm::Triple::x86) 6472 CmdArgs.push_back("elf_i386"); 6473 else if (ToolChain.getArch() == llvm::Triple::aarch64) 6474 CmdArgs.push_back("aarch64linux"); 6475 else if (ToolChain.getArch() == llvm::Triple::arm 6476 || ToolChain.getArch() == llvm::Triple::thumb) 6477 CmdArgs.push_back("armelf_linux_eabi"); 6478 else if (ToolChain.getArch() == llvm::Triple::ppc) 6479 CmdArgs.push_back("elf32ppclinux"); 6480 else if (ToolChain.getArch() == llvm::Triple::ppc64) 6481 CmdArgs.push_back("elf64ppc"); 6482 else if (ToolChain.getArch() == llvm::Triple::sparc) 6483 CmdArgs.push_back("elf32_sparc"); 6484 else if (ToolChain.getArch() == llvm::Triple::sparcv9) 6485 CmdArgs.push_back("elf64_sparc"); 6486 else if (ToolChain.getArch() == llvm::Triple::mips) 6487 CmdArgs.push_back("elf32btsmip"); 6488 else if (ToolChain.getArch() == llvm::Triple::mipsel) 6489 CmdArgs.push_back("elf32ltsmip"); 6490 else if (ToolChain.getArch() == llvm::Triple::mips64) { 6491 if (hasMipsN32ABIArg(Args)) 6492 CmdArgs.push_back("elf32btsmipn32"); 6493 else 6494 CmdArgs.push_back("elf64btsmip"); 6495 } 6496 else if (ToolChain.getArch() == llvm::Triple::mips64el) { 6497 if (hasMipsN32ABIArg(Args)) 6498 CmdArgs.push_back("elf32ltsmipn32"); 6499 else 6500 CmdArgs.push_back("elf64ltsmip"); 6501 } 6502 else if (ToolChain.getArch() == llvm::Triple::systemz) 6503 CmdArgs.push_back("elf64_s390"); 6504 else 6505 CmdArgs.push_back("elf_x86_64"); 6506 6507 if (Args.hasArg(options::OPT_static)) { 6508 if (ToolChain.getArch() == llvm::Triple::arm 6509 || ToolChain.getArch() == llvm::Triple::thumb) 6510 CmdArgs.push_back("-Bstatic"); 6511 else 6512 CmdArgs.push_back("-static"); 6513 } else if (Args.hasArg(options::OPT_shared)) { 6514 CmdArgs.push_back("-shared"); 6515 if (isAndroid) { 6516 CmdArgs.push_back("-Bsymbolic"); 6517 } 6518 } 6519 6520 if (ToolChain.getArch() == llvm::Triple::arm || 6521 ToolChain.getArch() == llvm::Triple::thumb || 6522 (!Args.hasArg(options::OPT_static) && 6523 !Args.hasArg(options::OPT_shared))) { 6524 CmdArgs.push_back("-dynamic-linker"); 6525 CmdArgs.push_back(Args.MakeArgString( 6526 D.DyldPrefix + getLinuxDynamicLinker(Args, ToolChain))); 6527 } 6528 6529 CmdArgs.push_back("-o"); 6530 CmdArgs.push_back(Output.getFilename()); 6531 6532 if (!Args.hasArg(options::OPT_nostdlib) && 6533 !Args.hasArg(options::OPT_nostartfiles)) { 6534 if (!isAndroid) { 6535 const char *crt1 = NULL; 6536 if (!Args.hasArg(options::OPT_shared)){ 6537 if (Args.hasArg(options::OPT_pg)) 6538 crt1 = "gcrt1.o"; 6539 else if (IsPIE) 6540 crt1 = "Scrt1.o"; 6541 else 6542 crt1 = "crt1.o"; 6543 } 6544 if (crt1) 6545 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crt1))); 6546 6547 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crti.o"))); 6548 } 6549 6550 const char *crtbegin; 6551 if (Args.hasArg(options::OPT_static)) 6552 crtbegin = isAndroid ? "crtbegin_static.o" : "crtbeginT.o"; 6553 else if (Args.hasArg(options::OPT_shared)) 6554 crtbegin = isAndroid ? "crtbegin_so.o" : "crtbeginS.o"; 6555 else if (IsPIE) 6556 crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbeginS.o"; 6557 else 6558 crtbegin = isAndroid ? "crtbegin_dynamic.o" : "crtbegin.o"; 6559 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtbegin))); 6560 6561 // Add crtfastmath.o if available and fast math is enabled. 6562 ToolChain.AddFastMathRuntimeIfAvailable(Args, CmdArgs); 6563 } 6564 6565 Args.AddAllArgs(CmdArgs, options::OPT_L); 6566 6567 const ToolChain::path_list Paths = ToolChain.getFilePaths(); 6568 6569 for (ToolChain::path_list::const_iterator i = Paths.begin(), e = Paths.end(); 6570 i != e; ++i) 6571 CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + *i)); 6572 6573 // Tell the linker to load the plugin. This has to come before AddLinkerInputs 6574 // as gold requires -plugin to come before any -plugin-opt that -Wl might 6575 // forward. 6576 if (D.IsUsingLTO(Args)) { 6577 CmdArgs.push_back("-plugin"); 6578 std::string Plugin = ToolChain.getDriver().Dir + "/../lib/LLVMgold.so"; 6579 CmdArgs.push_back(Args.MakeArgString(Plugin)); 6580 6581 // Try to pass driver level flags relevant to LTO code generation down to 6582 // the plugin. 6583 6584 // Handle flags for selecting CPU variants. 6585 std::string CPU = getCPUName(Args, ToolChain.getTriple()); 6586 if (!CPU.empty()) { 6587 CmdArgs.push_back( 6588 Args.MakeArgString(Twine("-plugin-opt=mcpu=") + 6589 CPU)); 6590 } 6591 } 6592 6593 6594 if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle)) 6595 CmdArgs.push_back("--no-demangle"); 6596 6597 AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs); 6598 6599 // Call these before we add the C++ ABI library. 6600 if (Sanitize.needsUbsanRt()) 6601 addUbsanRTLinux(getToolChain(), Args, CmdArgs, D.CCCIsCXX(), 6602 Sanitize.needsAsanRt() || Sanitize.needsTsanRt() || 6603 Sanitize.needsMsanRt() || Sanitize.needsLsanRt()); 6604 if (Sanitize.needsAsanRt()) 6605 addAsanRTLinux(getToolChain(), Args, CmdArgs); 6606 if (Sanitize.needsTsanRt()) 6607 addTsanRTLinux(getToolChain(), Args, CmdArgs); 6608 if (Sanitize.needsMsanRt()) 6609 addMsanRTLinux(getToolChain(), Args, CmdArgs); 6610 if (Sanitize.needsLsanRt()) 6611 addLsanRTLinux(getToolChain(), Args, CmdArgs); 6612 if (Sanitize.needsDfsanRt()) 6613 addDfsanRTLinux(getToolChain(), Args, CmdArgs); 6614 6615 // The profile runtime also needs access to system libraries. 6616 addProfileRTLinux(getToolChain(), Args, CmdArgs); 6617 6618 if (D.CCCIsCXX() && 6619 !Args.hasArg(options::OPT_nostdlib) && 6620 !Args.hasArg(options::OPT_nodefaultlibs)) { 6621 bool OnlyLibstdcxxStatic = Args.hasArg(options::OPT_static_libstdcxx) && 6622 !Args.hasArg(options::OPT_static); 6623 if (OnlyLibstdcxxStatic) 6624 CmdArgs.push_back("-Bstatic"); 6625 ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs); 6626 if (OnlyLibstdcxxStatic) 6627 CmdArgs.push_back("-Bdynamic"); 6628 CmdArgs.push_back("-lm"); 6629 } 6630 6631 if (!Args.hasArg(options::OPT_nostdlib)) { 6632 if (!Args.hasArg(options::OPT_nodefaultlibs)) { 6633 if (Args.hasArg(options::OPT_static)) 6634 CmdArgs.push_back("--start-group"); 6635 6636 bool OpenMP = Args.hasArg(options::OPT_fopenmp); 6637 if (OpenMP) { 6638 CmdArgs.push_back("-lgomp"); 6639 6640 // FIXME: Exclude this for platforms whith libgomp that doesn't require 6641 // librt. Most modern Linux platfroms require it, but some may not. 6642 CmdArgs.push_back("-lrt"); 6643 } 6644 6645 AddLibgcc(ToolChain.getTriple(), D, CmdArgs, Args); 6646 6647 if (Args.hasArg(options::OPT_pthread) || 6648 Args.hasArg(options::OPT_pthreads) || OpenMP) 6649 CmdArgs.push_back("-lpthread"); 6650 6651 CmdArgs.push_back("-lc"); 6652 6653 if (Args.hasArg(options::OPT_static)) 6654 CmdArgs.push_back("--end-group"); 6655 else 6656 AddLibgcc(ToolChain.getTriple(), D, CmdArgs, Args); 6657 } 6658 6659 if (!Args.hasArg(options::OPT_nostartfiles)) { 6660 const char *crtend; 6661 if (Args.hasArg(options::OPT_shared)) 6662 crtend = isAndroid ? "crtend_so.o" : "crtendS.o"; 6663 else if (IsPIE) 6664 crtend = isAndroid ? "crtend_android.o" : "crtendS.o"; 6665 else 6666 crtend = isAndroid ? "crtend_android.o" : "crtend.o"; 6667 6668 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtend))); 6669 if (!isAndroid) 6670 CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o"))); 6671 } 6672 } 6673 6674 C.addCommand(new Command(JA, *this, ToolChain.Linker.c_str(), CmdArgs)); 6675} 6676 6677void minix::Assemble::ConstructJob(Compilation &C, const JobAction &JA, 6678 const InputInfo &Output, 6679 const InputInfoList &Inputs, 6680 const ArgList &Args, 6681 const char *LinkingOutput) const { 6682 ArgStringList CmdArgs; 6683 6684 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, 6685 options::OPT_Xassembler); 6686 6687 CmdArgs.push_back("-o"); 6688 CmdArgs.push_back(Output.getFilename()); 6689 6690 for (InputInfoList::const_iterator 6691 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 6692 const InputInfo &II = *it; 6693 CmdArgs.push_back(II.getFilename()); 6694 } 6695 6696 const char *Exec = 6697 Args.MakeArgString(getToolChain().GetProgramPath("as")); 6698 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 6699} 6700 6701void minix::Link::ConstructJob(Compilation &C, const JobAction &JA, 6702 const InputInfo &Output, 6703 const InputInfoList &Inputs, 6704 const ArgList &Args, 6705 const char *LinkingOutput) const { 6706 const Driver &D = getToolChain().getDriver(); 6707 ArgStringList CmdArgs; 6708 6709 if (Output.isFilename()) { 6710 CmdArgs.push_back("-o"); 6711 CmdArgs.push_back(Output.getFilename()); 6712 } else { 6713 assert(Output.isNothing() && "Invalid output."); 6714 } 6715 6716 if (!Args.hasArg(options::OPT_nostdlib) && 6717 !Args.hasArg(options::OPT_nostartfiles)) { 6718 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crt1.o"))); 6719 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crti.o"))); 6720 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtbegin.o"))); 6721 CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtn.o"))); 6722 } 6723 6724 Args.AddAllArgs(CmdArgs, options::OPT_L); 6725 Args.AddAllArgs(CmdArgs, options::OPT_T_Group); 6726 Args.AddAllArgs(CmdArgs, options::OPT_e); 6727 6728 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs); 6729 6730 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple()); 6731 6732 if (!Args.hasArg(options::OPT_nostdlib) && 6733 !Args.hasArg(options::OPT_nodefaultlibs)) { 6734 if (D.CCCIsCXX()) { 6735 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs); 6736 CmdArgs.push_back("-lm"); 6737 } 6738 } 6739 6740 if (!Args.hasArg(options::OPT_nostdlib) && 6741 !Args.hasArg(options::OPT_nostartfiles)) { 6742 if (Args.hasArg(options::OPT_pthread)) 6743 CmdArgs.push_back("-lpthread"); 6744 CmdArgs.push_back("-lc"); 6745 CmdArgs.push_back("-lCompilerRT-Generic"); 6746 CmdArgs.push_back("-L/usr/pkg/compiler-rt/lib"); 6747 CmdArgs.push_back( 6748 Args.MakeArgString(getToolChain().GetFilePath("crtend.o"))); 6749 } 6750 6751 const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("ld")); 6752 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 6753} 6754 6755/// DragonFly Tools 6756 6757// For now, DragonFly Assemble does just about the same as for 6758// FreeBSD, but this may change soon. 6759void dragonfly::Assemble::ConstructJob(Compilation &C, const JobAction &JA, 6760 const InputInfo &Output, 6761 const InputInfoList &Inputs, 6762 const ArgList &Args, 6763 const char *LinkingOutput) const { 6764 ArgStringList CmdArgs; 6765 6766 // When building 32-bit code on DragonFly/pc64, we have to explicitly 6767 // instruct as in the base system to assemble 32-bit code. 6768 if (getToolChain().getArch() == llvm::Triple::x86) 6769 CmdArgs.push_back("--32"); 6770 6771 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, 6772 options::OPT_Xassembler); 6773 6774 CmdArgs.push_back("-o"); 6775 CmdArgs.push_back(Output.getFilename()); 6776 6777 for (InputInfoList::const_iterator 6778 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 6779 const InputInfo &II = *it; 6780 CmdArgs.push_back(II.getFilename()); 6781 } 6782 6783 const char *Exec = 6784 Args.MakeArgString(getToolChain().GetProgramPath("as")); 6785 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 6786} 6787 6788void dragonfly::Link::ConstructJob(Compilation &C, const JobAction &JA, 6789 const InputInfo &Output, 6790 const InputInfoList &Inputs, 6791 const ArgList &Args, 6792 const char *LinkingOutput) const { 6793 bool UseGCC47 = false; 6794 const Driver &D = getToolChain().getDriver(); 6795 ArgStringList CmdArgs; 6796 6797 if (llvm::sys::fs::exists("/usr/lib/gcc47", UseGCC47)) 6798 UseGCC47 = false; 6799 6800 if (!D.SysRoot.empty()) 6801 CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot)); 6802 6803 CmdArgs.push_back("--eh-frame-hdr"); 6804 if (Args.hasArg(options::OPT_static)) { 6805 CmdArgs.push_back("-Bstatic"); 6806 } else { 6807 if (Args.hasArg(options::OPT_rdynamic)) 6808 CmdArgs.push_back("-export-dynamic"); 6809 if (Args.hasArg(options::OPT_shared)) 6810 CmdArgs.push_back("-Bshareable"); 6811 else { 6812 CmdArgs.push_back("-dynamic-linker"); 6813 CmdArgs.push_back("/usr/libexec/ld-elf.so.2"); 6814 } 6815 CmdArgs.push_back("--hash-style=both"); 6816 } 6817 6818 // When building 32-bit code on DragonFly/pc64, we have to explicitly 6819 // instruct ld in the base system to link 32-bit code. 6820 if (getToolChain().getArch() == llvm::Triple::x86) { 6821 CmdArgs.push_back("-m"); 6822 CmdArgs.push_back("elf_i386"); 6823 } 6824 6825 if (Output.isFilename()) { 6826 CmdArgs.push_back("-o"); 6827 CmdArgs.push_back(Output.getFilename()); 6828 } else { 6829 assert(Output.isNothing() && "Invalid output."); 6830 } 6831 6832 if (!Args.hasArg(options::OPT_nostdlib) && 6833 !Args.hasArg(options::OPT_nostartfiles)) { 6834 if (!Args.hasArg(options::OPT_shared)) { 6835 if (Args.hasArg(options::OPT_pg)) 6836 CmdArgs.push_back(Args.MakeArgString( 6837 getToolChain().GetFilePath("gcrt1.o"))); 6838 else { 6839 if (Args.hasArg(options::OPT_pie)) 6840 CmdArgs.push_back(Args.MakeArgString( 6841 getToolChain().GetFilePath("Scrt1.o"))); 6842 else 6843 CmdArgs.push_back(Args.MakeArgString( 6844 getToolChain().GetFilePath("crt1.o"))); 6845 } 6846 } 6847 CmdArgs.push_back(Args.MakeArgString( 6848 getToolChain().GetFilePath("crti.o"))); 6849 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie)) 6850 CmdArgs.push_back(Args.MakeArgString( 6851 getToolChain().GetFilePath("crtbeginS.o"))); 6852 else 6853 CmdArgs.push_back(Args.MakeArgString( 6854 getToolChain().GetFilePath("crtbegin.o"))); 6855 } 6856 6857 Args.AddAllArgs(CmdArgs, options::OPT_L); 6858 Args.AddAllArgs(CmdArgs, options::OPT_T_Group); 6859 Args.AddAllArgs(CmdArgs, options::OPT_e); 6860 6861 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs); 6862 6863 if (!Args.hasArg(options::OPT_nostdlib) && 6864 !Args.hasArg(options::OPT_nodefaultlibs)) { 6865 // FIXME: GCC passes on -lgcc, -lgcc_pic and a whole lot of 6866 // rpaths 6867 if (UseGCC47) 6868 CmdArgs.push_back("-L/usr/lib/gcc47"); 6869 else 6870 CmdArgs.push_back("-L/usr/lib/gcc44"); 6871 6872 if (!Args.hasArg(options::OPT_static)) { 6873 if (UseGCC47) { 6874 CmdArgs.push_back("-rpath"); 6875 CmdArgs.push_back("/usr/lib/gcc47"); 6876 } else { 6877 CmdArgs.push_back("-rpath"); 6878 CmdArgs.push_back("/usr/lib/gcc44"); 6879 } 6880 } 6881 6882 if (D.CCCIsCXX()) { 6883 getToolChain().AddCXXStdlibLibArgs(Args, CmdArgs); 6884 CmdArgs.push_back("-lm"); 6885 } 6886 6887 if (Args.hasArg(options::OPT_pthread)) 6888 CmdArgs.push_back("-lpthread"); 6889 6890 if (!Args.hasArg(options::OPT_nolibc)) { 6891 CmdArgs.push_back("-lc"); 6892 } 6893 6894 if (UseGCC47) { 6895 if (Args.hasArg(options::OPT_static) || 6896 Args.hasArg(options::OPT_static_libgcc)) { 6897 CmdArgs.push_back("-lgcc"); 6898 CmdArgs.push_back("-lgcc_eh"); 6899 } else { 6900 if (Args.hasArg(options::OPT_shared_libgcc)) { 6901 CmdArgs.push_back("-lgcc_pic"); 6902 if (!Args.hasArg(options::OPT_shared)) 6903 CmdArgs.push_back("-lgcc"); 6904 } else { 6905 CmdArgs.push_back("-lgcc"); 6906 CmdArgs.push_back("--as-needed"); 6907 CmdArgs.push_back("-lgcc_pic"); 6908 CmdArgs.push_back("--no-as-needed"); 6909 } 6910 } 6911 } else { 6912 if (Args.hasArg(options::OPT_shared)) { 6913 CmdArgs.push_back("-lgcc_pic"); 6914 } else { 6915 CmdArgs.push_back("-lgcc"); 6916 } 6917 } 6918 } 6919 6920 if (!Args.hasArg(options::OPT_nostdlib) && 6921 !Args.hasArg(options::OPT_nostartfiles)) { 6922 if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie)) 6923 CmdArgs.push_back(Args.MakeArgString( 6924 getToolChain().GetFilePath("crtendS.o"))); 6925 else 6926 CmdArgs.push_back(Args.MakeArgString( 6927 getToolChain().GetFilePath("crtend.o"))); 6928 CmdArgs.push_back(Args.MakeArgString( 6929 getToolChain().GetFilePath("crtn.o"))); 6930 } 6931 6932 addProfileRT(getToolChain(), Args, CmdArgs, getToolChain().getTriple()); 6933 6934 const char *Exec = 6935 Args.MakeArgString(getToolChain().GetProgramPath("ld")); 6936 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 6937} 6938 6939void visualstudio::Link::ConstructJob(Compilation &C, const JobAction &JA, 6940 const InputInfo &Output, 6941 const InputInfoList &Inputs, 6942 const ArgList &Args, 6943 const char *LinkingOutput) const { 6944 ArgStringList CmdArgs; 6945 6946 if (Output.isFilename()) { 6947 CmdArgs.push_back(Args.MakeArgString(std::string("-out:") + 6948 Output.getFilename())); 6949 } else { 6950 assert(Output.isNothing() && "Invalid output."); 6951 } 6952 6953 if (!Args.hasArg(options::OPT_nostdlib) && 6954 !Args.hasArg(options::OPT_nostartfiles) && 6955 !C.getDriver().IsCLMode()) { 6956 CmdArgs.push_back("-defaultlib:libcmt"); 6957 } 6958 6959 CmdArgs.push_back("-nologo"); 6960 6961 bool DLL = Args.hasArg(options::OPT__SLASH_LD, options::OPT__SLASH_LDd); 6962 6963 if (DLL) { 6964 CmdArgs.push_back(Args.MakeArgString("-dll")); 6965 6966 SmallString<128> ImplibName(Output.getFilename()); 6967 llvm::sys::path::replace_extension(ImplibName, "lib"); 6968 CmdArgs.push_back(Args.MakeArgString(std::string("-implib:") + 6969 ImplibName.str())); 6970 } 6971 6972 if (getToolChain().getSanitizerArgs().needsAsanRt()) { 6973 CmdArgs.push_back(Args.MakeArgString("-debug")); 6974 CmdArgs.push_back(Args.MakeArgString("-incremental:no")); 6975 SmallString<128> LibSanitizer(getToolChain().getDriver().ResourceDir); 6976 llvm::sys::path::append(LibSanitizer, "lib", "windows"); 6977 if (DLL) { 6978 llvm::sys::path::append(LibSanitizer, "clang_rt.asan_dll_thunk-i386.lib"); 6979 } else { 6980 llvm::sys::path::append(LibSanitizer, "clang_rt.asan-i386.lib"); 6981 } 6982 // FIXME: Handle 64-bit. 6983 CmdArgs.push_back(Args.MakeArgString(LibSanitizer)); 6984 } 6985 6986 Args.AddAllArgValues(CmdArgs, options::OPT_l); 6987 Args.AddAllArgValues(CmdArgs, options::OPT__SLASH_link); 6988 6989 // Add filenames immediately. 6990 for (InputInfoList::const_iterator 6991 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 6992 if (it->isFilename()) 6993 CmdArgs.push_back(it->getFilename()); 6994 else 6995 it->getInputArg().renderAsInput(Args, CmdArgs); 6996 } 6997 6998 const char *Exec = 6999 Args.MakeArgString(getToolChain().GetProgramPath("link.exe")); 7000 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 7001} 7002 7003void visualstudio::Compile::ConstructJob(Compilation &C, const JobAction &JA, 7004 const InputInfo &Output, 7005 const InputInfoList &Inputs, 7006 const ArgList &Args, 7007 const char *LinkingOutput) const { 7008 C.addCommand(GetCommand(C, JA, Output, Inputs, Args, LinkingOutput)); 7009} 7010 7011// Try to find FallbackName on PATH that is not identical to ClangProgramPath. 7012// If one cannot be found, return FallbackName. 7013// We do this special search to prevent clang-cl from falling back onto itself 7014// if it's available as cl.exe on the path. 7015static std::string FindFallback(const char *FallbackName, 7016 const char *ClangProgramPath) { 7017 llvm::Optional<std::string> OptPath = llvm::sys::Process::GetEnv("PATH"); 7018 if (!OptPath.hasValue()) 7019 return FallbackName; 7020 7021#ifdef LLVM_ON_WIN32 7022 const StringRef PathSeparators = ";"; 7023#else 7024 const StringRef PathSeparators = ":"; 7025#endif 7026 7027 SmallVector<StringRef, 8> PathSegments; 7028 llvm::SplitString(OptPath.getValue(), PathSegments, PathSeparators); 7029 7030 for (size_t i = 0, e = PathSegments.size(); i != e; ++i) { 7031 const StringRef &PathSegment = PathSegments[i]; 7032 if (PathSegment.empty()) 7033 continue; 7034 7035 SmallString<128> FilePath(PathSegment); 7036 llvm::sys::path::append(FilePath, FallbackName); 7037 if (llvm::sys::fs::can_execute(Twine(FilePath)) && 7038 !llvm::sys::fs::equivalent(Twine(FilePath), ClangProgramPath)) 7039 return FilePath.str(); 7040 } 7041 7042 return FallbackName; 7043} 7044 7045Command *visualstudio::Compile::GetCommand(Compilation &C, const JobAction &JA, 7046 const InputInfo &Output, 7047 const InputInfoList &Inputs, 7048 const ArgList &Args, 7049 const char *LinkingOutput) const { 7050 ArgStringList CmdArgs; 7051 CmdArgs.push_back("/nologo"); 7052 CmdArgs.push_back("/c"); // Compile only. 7053 CmdArgs.push_back("/W0"); // No warnings. 7054 7055 // The goal is to be able to invoke this tool correctly based on 7056 // any flag accepted by clang-cl. 7057 7058 // These are spelled the same way in clang and cl.exe,. 7059 Args.AddAllArgs(CmdArgs, options::OPT_D, options::OPT_U); 7060 Args.AddAllArgs(CmdArgs, options::OPT_I); 7061 7062 // Optimization level. 7063 if (Arg *A = Args.getLastArg(options::OPT_O, options::OPT_O0)) { 7064 if (A->getOption().getID() == options::OPT_O0) { 7065 CmdArgs.push_back("/Od"); 7066 } else { 7067 StringRef OptLevel = A->getValue(); 7068 if (OptLevel == "1" || OptLevel == "2" || OptLevel == "s") 7069 A->render(Args, CmdArgs); 7070 else if (OptLevel == "3") 7071 CmdArgs.push_back("/Ox"); 7072 } 7073 } 7074 7075 // Flags for which clang-cl have an alias. 7076 // FIXME: How can we ensure this stays in sync with relevant clang-cl options? 7077 7078 if (Arg *A = Args.getLastArg(options::OPT_frtti, options::OPT_fno_rtti)) 7079 CmdArgs.push_back(A->getOption().getID() == options::OPT_frtti ? "/GR" 7080 : "/GR-"); 7081 if (Args.hasArg(options::OPT_fsyntax_only)) 7082 CmdArgs.push_back("/Zs"); 7083 7084 std::vector<std::string> Includes = Args.getAllArgValues(options::OPT_include); 7085 for (size_t I = 0, E = Includes.size(); I != E; ++I) 7086 CmdArgs.push_back(Args.MakeArgString(std::string("/FI") + Includes[I])); 7087 7088 // Flags that can simply be passed through. 7089 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_LD); 7090 Args.AddAllArgs(CmdArgs, options::OPT__SLASH_LDd); 7091 7092 // The order of these flags is relevant, so pick the last one. 7093 if (Arg *A = Args.getLastArg(options::OPT__SLASH_MD, options::OPT__SLASH_MDd, 7094 options::OPT__SLASH_MT, options::OPT__SLASH_MTd)) 7095 A->render(Args, CmdArgs); 7096 7097 7098 // Input filename. 7099 assert(Inputs.size() == 1); 7100 const InputInfo &II = Inputs[0]; 7101 assert(II.getType() == types::TY_C || II.getType() == types::TY_CXX); 7102 CmdArgs.push_back(II.getType() == types::TY_C ? "/Tc" : "/Tp"); 7103 if (II.isFilename()) 7104 CmdArgs.push_back(II.getFilename()); 7105 else 7106 II.getInputArg().renderAsInput(Args, CmdArgs); 7107 7108 // Output filename. 7109 assert(Output.getType() == types::TY_Object); 7110 const char *Fo = Args.MakeArgString(std::string("/Fo") + 7111 Output.getFilename()); 7112 CmdArgs.push_back(Fo); 7113 7114 const Driver &D = getToolChain().getDriver(); 7115 std::string Exec = FindFallback("cl.exe", D.getClangProgramPath()); 7116 7117 return new Command(JA, *this, Args.MakeArgString(Exec), CmdArgs); 7118} 7119 7120 7121/// XCore Tools 7122// We pass assemble and link construction to the xcc tool. 7123 7124void XCore::Assemble::ConstructJob(Compilation &C, const JobAction &JA, 7125 const InputInfo &Output, 7126 const InputInfoList &Inputs, 7127 const ArgList &Args, 7128 const char *LinkingOutput) const { 7129 ArgStringList CmdArgs; 7130 7131 CmdArgs.push_back("-o"); 7132 CmdArgs.push_back(Output.getFilename()); 7133 7134 CmdArgs.push_back("-c"); 7135 7136 if (Args.hasArg(options::OPT_g_Group)) { 7137 CmdArgs.push_back("-g"); 7138 } 7139 7140 Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, 7141 options::OPT_Xassembler); 7142 7143 for (InputInfoList::const_iterator 7144 it = Inputs.begin(), ie = Inputs.end(); it != ie; ++it) { 7145 const InputInfo &II = *it; 7146 CmdArgs.push_back(II.getFilename()); 7147 } 7148 7149 const char *Exec = 7150 Args.MakeArgString(getToolChain().GetProgramPath("xcc")); 7151 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 7152} 7153 7154void XCore::Link::ConstructJob(Compilation &C, const JobAction &JA, 7155 const InputInfo &Output, 7156 const InputInfoList &Inputs, 7157 const ArgList &Args, 7158 const char *LinkingOutput) const { 7159 ArgStringList CmdArgs; 7160 7161 if (Output.isFilename()) { 7162 CmdArgs.push_back("-o"); 7163 CmdArgs.push_back(Output.getFilename()); 7164 } else { 7165 assert(Output.isNothing() && "Invalid output."); 7166 } 7167 7168 AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs); 7169 7170 const char *Exec = 7171 Args.MakeArgString(getToolChain().GetProgramPath("xcc")); 7172 C.addCommand(new Command(JA, *this, Exec, CmdArgs)); 7173} 7174