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