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