1 //===--- LLVM.cpp - Clang+LLVM ToolChain Implementations --------*- C++ -*-===// 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 "Clang.h" 11 #include "Arch/AArch64.h" 12 #include "Arch/ARM.h" 13 #include "Arch/Mips.h" 14 #include "Arch/PPC.h" 15 #include "Arch/RISCV.h" 16 #include "Arch/Sparc.h" 17 #include "Arch/SystemZ.h" 18 #include "Arch/X86.h" 19 #include "AMDGPU.h" 20 #include "CommonArgs.h" 21 #include "Hexagon.h" 22 #include "InputInfo.h" 23 #include "PS4CPU.h" 24 #include "clang/Basic/CharInfo.h" 25 #include "clang/Basic/LangOptions.h" 26 #include "clang/Basic/ObjCRuntime.h" 27 #include "clang/Basic/Version.h" 28 #include "clang/Driver/DriverDiagnostic.h" 29 #include "clang/Driver/Options.h" 30 #include "clang/Driver/SanitizerArgs.h" 31 #include "clang/Driver/XRayArgs.h" 32 #include "llvm/ADT/StringExtras.h" 33 #include "llvm/Config/llvm-config.h" 34 #include "llvm/Option/ArgList.h" 35 #include "llvm/Support/CodeGen.h" 36 #include "llvm/Support/Compression.h" 37 #include "llvm/Support/FileSystem.h" 38 #include "llvm/Support/Path.h" 39 #include "llvm/Support/Process.h" 40 #include "llvm/Support/TargetParser.h" 41 #include "llvm/Support/YAMLParser.h" 42 43 #ifdef LLVM_ON_UNIX 44 #include <unistd.h> // For getuid(). 45 #endif 46 47 using namespace clang::driver; 48 using namespace clang::driver::tools; 49 using namespace clang; 50 using namespace llvm::opt; 51 52 static void CheckPreprocessingOptions(const Driver &D, const ArgList &Args) { 53 if (Arg *A = 54 Args.getLastArg(clang::driver::options::OPT_C, options::OPT_CC)) { 55 if (!Args.hasArg(options::OPT_E) && !Args.hasArg(options::OPT__SLASH_P) && 56 !Args.hasArg(options::OPT__SLASH_EP) && !D.CCCIsCPP()) { 57 D.Diag(clang::diag::err_drv_argument_only_allowed_with) 58 << A->getBaseArg().getAsString(Args) 59 << (D.IsCLMode() ? "/E, /P or /EP" : "-E"); 60 } 61 } 62 } 63 64 static void CheckCodeGenerationOptions(const Driver &D, const ArgList &Args) { 65 // In gcc, only ARM checks this, but it seems reasonable to check universally. 66 if (Args.hasArg(options::OPT_static)) 67 if (const Arg *A = 68 Args.getLastArg(options::OPT_dynamic, options::OPT_mdynamic_no_pic)) 69 D.Diag(diag::err_drv_argument_not_allowed_with) << A->getAsString(Args) 70 << "-static"; 71 } 72 73 // Add backslashes to escape spaces and other backslashes. 74 // This is used for the space-separated argument list specified with 75 // the -dwarf-debug-flags option. 76 static void EscapeSpacesAndBackslashes(const char *Arg, 77 SmallVectorImpl<char> &Res) { 78 for (; *Arg; ++Arg) { 79 switch (*Arg) { 80 default: 81 break; 82 case ' ': 83 case '\\': 84 Res.push_back('\\'); 85 break; 86 } 87 Res.push_back(*Arg); 88 } 89 } 90 91 // Quote target names for inclusion in GNU Make dependency files. 92 // Only the characters '$', '#', ' ', '\t' are quoted. 93 static void QuoteTarget(StringRef Target, SmallVectorImpl<char> &Res) { 94 for (unsigned i = 0, e = Target.size(); i != e; ++i) { 95 switch (Target[i]) { 96 case ' ': 97 case '\t': 98 // Escape the preceding backslashes 99 for (int j = i - 1; j >= 0 && Target[j] == '\\'; --j) 100 Res.push_back('\\'); 101 102 // Escape the space/tab 103 Res.push_back('\\'); 104 break; 105 case '$': 106 Res.push_back('$'); 107 break; 108 case '#': 109 Res.push_back('\\'); 110 break; 111 default: 112 break; 113 } 114 115 Res.push_back(Target[i]); 116 } 117 } 118 119 /// Apply \a Work on the current tool chain \a RegularToolChain and any other 120 /// offloading tool chain that is associated with the current action \a JA. 121 static void 122 forAllAssociatedToolChains(Compilation &C, const JobAction &JA, 123 const ToolChain &RegularToolChain, 124 llvm::function_ref<void(const ToolChain &)> Work) { 125 // Apply Work on the current/regular tool chain. 126 Work(RegularToolChain); 127 128 // Apply Work on all the offloading tool chains associated with the current 129 // action. 130 if (JA.isHostOffloading(Action::OFK_Cuda)) 131 Work(*C.getSingleOffloadToolChain<Action::OFK_Cuda>()); 132 else if (JA.isDeviceOffloading(Action::OFK_Cuda)) 133 Work(*C.getSingleOffloadToolChain<Action::OFK_Host>()); 134 else if (JA.isHostOffloading(Action::OFK_HIP)) 135 Work(*C.getSingleOffloadToolChain<Action::OFK_HIP>()); 136 else if (JA.isDeviceOffloading(Action::OFK_HIP)) 137 Work(*C.getSingleOffloadToolChain<Action::OFK_Host>()); 138 139 if (JA.isHostOffloading(Action::OFK_OpenMP)) { 140 auto TCs = C.getOffloadToolChains<Action::OFK_OpenMP>(); 141 for (auto II = TCs.first, IE = TCs.second; II != IE; ++II) 142 Work(*II->second); 143 } else if (JA.isDeviceOffloading(Action::OFK_OpenMP)) 144 Work(*C.getSingleOffloadToolChain<Action::OFK_Host>()); 145 146 // 147 // TODO: Add support for other offloading programming models here. 148 // 149 } 150 151 /// This is a helper function for validating the optional refinement step 152 /// parameter in reciprocal argument strings. Return false if there is an error 153 /// parsing the refinement step. Otherwise, return true and set the Position 154 /// of the refinement step in the input string. 155 static bool getRefinementStep(StringRef In, const Driver &D, 156 const Arg &A, size_t &Position) { 157 const char RefinementStepToken = ':'; 158 Position = In.find(RefinementStepToken); 159 if (Position != StringRef::npos) { 160 StringRef Option = A.getOption().getName(); 161 StringRef RefStep = In.substr(Position + 1); 162 // Allow exactly one numeric character for the additional refinement 163 // step parameter. This is reasonable for all currently-supported 164 // operations and architectures because we would expect that a larger value 165 // of refinement steps would cause the estimate "optimization" to 166 // under-perform the native operation. Also, if the estimate does not 167 // converge quickly, it probably will not ever converge, so further 168 // refinement steps will not produce a better answer. 169 if (RefStep.size() != 1) { 170 D.Diag(diag::err_drv_invalid_value) << Option << RefStep; 171 return false; 172 } 173 char RefStepChar = RefStep[0]; 174 if (RefStepChar < '0' || RefStepChar > '9') { 175 D.Diag(diag::err_drv_invalid_value) << Option << RefStep; 176 return false; 177 } 178 } 179 return true; 180 } 181 182 /// The -mrecip flag requires processing of many optional parameters. 183 static void ParseMRecip(const Driver &D, const ArgList &Args, 184 ArgStringList &OutStrings) { 185 StringRef DisabledPrefixIn = "!"; 186 StringRef DisabledPrefixOut = "!"; 187 StringRef EnabledPrefixOut = ""; 188 StringRef Out = "-mrecip="; 189 190 Arg *A = Args.getLastArg(options::OPT_mrecip, options::OPT_mrecip_EQ); 191 if (!A) 192 return; 193 194 unsigned NumOptions = A->getNumValues(); 195 if (NumOptions == 0) { 196 // No option is the same as "all". 197 OutStrings.push_back(Args.MakeArgString(Out + "all")); 198 return; 199 } 200 201 // Pass through "all", "none", or "default" with an optional refinement step. 202 if (NumOptions == 1) { 203 StringRef Val = A->getValue(0); 204 size_t RefStepLoc; 205 if (!getRefinementStep(Val, D, *A, RefStepLoc)) 206 return; 207 StringRef ValBase = Val.slice(0, RefStepLoc); 208 if (ValBase == "all" || ValBase == "none" || ValBase == "default") { 209 OutStrings.push_back(Args.MakeArgString(Out + Val)); 210 return; 211 } 212 } 213 214 // Each reciprocal type may be enabled or disabled individually. 215 // Check each input value for validity, concatenate them all back together, 216 // and pass through. 217 218 llvm::StringMap<bool> OptionStrings; 219 OptionStrings.insert(std::make_pair("divd", false)); 220 OptionStrings.insert(std::make_pair("divf", false)); 221 OptionStrings.insert(std::make_pair("vec-divd", false)); 222 OptionStrings.insert(std::make_pair("vec-divf", false)); 223 OptionStrings.insert(std::make_pair("sqrtd", false)); 224 OptionStrings.insert(std::make_pair("sqrtf", false)); 225 OptionStrings.insert(std::make_pair("vec-sqrtd", false)); 226 OptionStrings.insert(std::make_pair("vec-sqrtf", false)); 227 228 for (unsigned i = 0; i != NumOptions; ++i) { 229 StringRef Val = A->getValue(i); 230 231 bool IsDisabled = Val.startswith(DisabledPrefixIn); 232 // Ignore the disablement token for string matching. 233 if (IsDisabled) 234 Val = Val.substr(1); 235 236 size_t RefStep; 237 if (!getRefinementStep(Val, D, *A, RefStep)) 238 return; 239 240 StringRef ValBase = Val.slice(0, RefStep); 241 llvm::StringMap<bool>::iterator OptionIter = OptionStrings.find(ValBase); 242 if (OptionIter == OptionStrings.end()) { 243 // Try again specifying float suffix. 244 OptionIter = OptionStrings.find(ValBase.str() + 'f'); 245 if (OptionIter == OptionStrings.end()) { 246 // The input name did not match any known option string. 247 D.Diag(diag::err_drv_unknown_argument) << Val; 248 return; 249 } 250 // The option was specified without a float or double suffix. 251 // Make sure that the double entry was not already specified. 252 // The float entry will be checked below. 253 if (OptionStrings[ValBase.str() + 'd']) { 254 D.Diag(diag::err_drv_invalid_value) << A->getOption().getName() << Val; 255 return; 256 } 257 } 258 259 if (OptionIter->second == true) { 260 // Duplicate option specified. 261 D.Diag(diag::err_drv_invalid_value) << A->getOption().getName() << Val; 262 return; 263 } 264 265 // Mark the matched option as found. Do not allow duplicate specifiers. 266 OptionIter->second = true; 267 268 // If the precision was not specified, also mark the double entry as found. 269 if (ValBase.back() != 'f' && ValBase.back() != 'd') 270 OptionStrings[ValBase.str() + 'd'] = true; 271 272 // Build the output string. 273 StringRef Prefix = IsDisabled ? DisabledPrefixOut : EnabledPrefixOut; 274 Out = Args.MakeArgString(Out + Prefix + Val); 275 if (i != NumOptions - 1) 276 Out = Args.MakeArgString(Out + ","); 277 } 278 279 OutStrings.push_back(Args.MakeArgString(Out)); 280 } 281 282 /// The -mprefer-vector-width option accepts either a positive integer 283 /// or the string "none". 284 static void ParseMPreferVectorWidth(const Driver &D, const ArgList &Args, 285 ArgStringList &CmdArgs) { 286 Arg *A = Args.getLastArg(options::OPT_mprefer_vector_width_EQ); 287 if (!A) 288 return; 289 290 StringRef Value = A->getValue(); 291 if (Value == "none") { 292 CmdArgs.push_back("-mprefer-vector-width=none"); 293 } else { 294 unsigned Width; 295 if (Value.getAsInteger(10, Width)) { 296 D.Diag(diag::err_drv_invalid_value) << A->getOption().getName() << Value; 297 return; 298 } 299 CmdArgs.push_back(Args.MakeArgString("-mprefer-vector-width=" + Value)); 300 } 301 } 302 303 static void getWebAssemblyTargetFeatures(const ArgList &Args, 304 std::vector<StringRef> &Features) { 305 handleTargetFeaturesGroup(Args, Features, options::OPT_m_wasm_Features_Group); 306 } 307 308 static void getTargetFeatures(const ToolChain &TC, const llvm::Triple &Triple, 309 const ArgList &Args, ArgStringList &CmdArgs, 310 bool ForAS) { 311 const Driver &D = TC.getDriver(); 312 std::vector<StringRef> Features; 313 switch (Triple.getArch()) { 314 default: 315 break; 316 case llvm::Triple::mips: 317 case llvm::Triple::mipsel: 318 case llvm::Triple::mips64: 319 case llvm::Triple::mips64el: 320 mips::getMIPSTargetFeatures(D, Triple, Args, Features); 321 break; 322 323 case llvm::Triple::arm: 324 case llvm::Triple::armeb: 325 case llvm::Triple::thumb: 326 case llvm::Triple::thumbeb: 327 arm::getARMTargetFeatures(TC, Triple, Args, CmdArgs, Features, ForAS); 328 break; 329 330 case llvm::Triple::ppc: 331 case llvm::Triple::ppc64: 332 case llvm::Triple::ppc64le: 333 ppc::getPPCTargetFeatures(D, Triple, Args, Features); 334 break; 335 case llvm::Triple::riscv32: 336 case llvm::Triple::riscv64: 337 riscv::getRISCVTargetFeatures(D, Args, Features); 338 break; 339 case llvm::Triple::systemz: 340 systemz::getSystemZTargetFeatures(Args, Features); 341 break; 342 case llvm::Triple::aarch64: 343 case llvm::Triple::aarch64_be: 344 aarch64::getAArch64TargetFeatures(D, Args, Features); 345 break; 346 case llvm::Triple::x86: 347 case llvm::Triple::x86_64: 348 x86::getX86TargetFeatures(D, Triple, Args, Features); 349 break; 350 case llvm::Triple::hexagon: 351 hexagon::getHexagonTargetFeatures(D, Args, Features); 352 break; 353 case llvm::Triple::wasm32: 354 case llvm::Triple::wasm64: 355 getWebAssemblyTargetFeatures(Args, Features); 356 break; 357 case llvm::Triple::sparc: 358 case llvm::Triple::sparcel: 359 case llvm::Triple::sparcv9: 360 sparc::getSparcTargetFeatures(D, Args, Features); 361 break; 362 case llvm::Triple::r600: 363 case llvm::Triple::amdgcn: 364 amdgpu::getAMDGPUTargetFeatures(D, Args, Features); 365 break; 366 } 367 368 // Find the last of each feature. 369 llvm::StringMap<unsigned> LastOpt; 370 for (unsigned I = 0, N = Features.size(); I < N; ++I) { 371 StringRef Name = Features[I]; 372 assert(Name[0] == '-' || Name[0] == '+'); 373 LastOpt[Name.drop_front(1)] = I; 374 } 375 376 for (unsigned I = 0, N = Features.size(); I < N; ++I) { 377 // If this feature was overridden, ignore it. 378 StringRef Name = Features[I]; 379 llvm::StringMap<unsigned>::iterator LastI = LastOpt.find(Name.drop_front(1)); 380 assert(LastI != LastOpt.end()); 381 unsigned Last = LastI->second; 382 if (Last != I) 383 continue; 384 385 CmdArgs.push_back("-target-feature"); 386 CmdArgs.push_back(Name.data()); 387 } 388 } 389 390 static bool 391 shouldUseExceptionTablesForObjCExceptions(const ObjCRuntime &runtime, 392 const llvm::Triple &Triple) { 393 // We use the zero-cost exception tables for Objective-C if the non-fragile 394 // ABI is enabled or when compiling for x86_64 and ARM on Snow Leopard and 395 // later. 396 if (runtime.isNonFragile()) 397 return true; 398 399 if (!Triple.isMacOSX()) 400 return false; 401 402 return (!Triple.isMacOSXVersionLT(10, 5) && 403 (Triple.getArch() == llvm::Triple::x86_64 || 404 Triple.getArch() == llvm::Triple::arm)); 405 } 406 407 /// Adds exception related arguments to the driver command arguments. There's a 408 /// master flag, -fexceptions and also language specific flags to enable/disable 409 /// C++ and Objective-C exceptions. This makes it possible to for example 410 /// disable C++ exceptions but enable Objective-C exceptions. 411 static void addExceptionArgs(const ArgList &Args, types::ID InputType, 412 const ToolChain &TC, bool KernelOrKext, 413 const ObjCRuntime &objcRuntime, 414 ArgStringList &CmdArgs) { 415 const llvm::Triple &Triple = TC.getTriple(); 416 417 if (KernelOrKext) { 418 // -mkernel and -fapple-kext imply no exceptions, so claim exception related 419 // arguments now to avoid warnings about unused arguments. 420 Args.ClaimAllArgs(options::OPT_fexceptions); 421 Args.ClaimAllArgs(options::OPT_fno_exceptions); 422 Args.ClaimAllArgs(options::OPT_fobjc_exceptions); 423 Args.ClaimAllArgs(options::OPT_fno_objc_exceptions); 424 Args.ClaimAllArgs(options::OPT_fcxx_exceptions); 425 Args.ClaimAllArgs(options::OPT_fno_cxx_exceptions); 426 return; 427 } 428 429 // See if the user explicitly enabled exceptions. 430 bool EH = Args.hasFlag(options::OPT_fexceptions, options::OPT_fno_exceptions, 431 false); 432 433 // Obj-C exceptions are enabled by default, regardless of -fexceptions. This 434 // is not necessarily sensible, but follows GCC. 435 if (types::isObjC(InputType) && 436 Args.hasFlag(options::OPT_fobjc_exceptions, 437 options::OPT_fno_objc_exceptions, true)) { 438 CmdArgs.push_back("-fobjc-exceptions"); 439 440 EH |= shouldUseExceptionTablesForObjCExceptions(objcRuntime, Triple); 441 } 442 443 if (types::isCXX(InputType)) { 444 // Disable C++ EH by default on XCore and PS4. 445 bool CXXExceptionsEnabled = 446 Triple.getArch() != llvm::Triple::xcore && !Triple.isPS4CPU(); 447 Arg *ExceptionArg = Args.getLastArg( 448 options::OPT_fcxx_exceptions, options::OPT_fno_cxx_exceptions, 449 options::OPT_fexceptions, options::OPT_fno_exceptions); 450 if (ExceptionArg) 451 CXXExceptionsEnabled = 452 ExceptionArg->getOption().matches(options::OPT_fcxx_exceptions) || 453 ExceptionArg->getOption().matches(options::OPT_fexceptions); 454 455 if (CXXExceptionsEnabled) { 456 CmdArgs.push_back("-fcxx-exceptions"); 457 458 EH = true; 459 } 460 } 461 462 if (EH) 463 CmdArgs.push_back("-fexceptions"); 464 } 465 466 static bool ShouldDisableAutolink(const ArgList &Args, const ToolChain &TC) { 467 bool Default = true; 468 if (TC.getTriple().isOSDarwin()) { 469 // The native darwin assembler doesn't support the linker_option directives, 470 // so we disable them if we think the .s file will be passed to it. 471 Default = TC.useIntegratedAs(); 472 } 473 return !Args.hasFlag(options::OPT_fautolink, options::OPT_fno_autolink, 474 Default); 475 } 476 477 static bool ShouldDisableDwarfDirectory(const ArgList &Args, 478 const ToolChain &TC) { 479 bool UseDwarfDirectory = 480 Args.hasFlag(options::OPT_fdwarf_directory_asm, 481 options::OPT_fno_dwarf_directory_asm, TC.useIntegratedAs()); 482 return !UseDwarfDirectory; 483 } 484 485 // Convert an arg of the form "-gN" or "-ggdbN" or one of their aliases 486 // to the corresponding DebugInfoKind. 487 static codegenoptions::DebugInfoKind DebugLevelToInfoKind(const Arg &A) { 488 assert(A.getOption().matches(options::OPT_gN_Group) && 489 "Not a -g option that specifies a debug-info level"); 490 if (A.getOption().matches(options::OPT_g0) || 491 A.getOption().matches(options::OPT_ggdb0)) 492 return codegenoptions::NoDebugInfo; 493 if (A.getOption().matches(options::OPT_gline_tables_only) || 494 A.getOption().matches(options::OPT_ggdb1)) 495 return codegenoptions::DebugLineTablesOnly; 496 return codegenoptions::LimitedDebugInfo; 497 } 498 499 static bool mustUseNonLeafFramePointerForTarget(const llvm::Triple &Triple) { 500 switch (Triple.getArch()){ 501 default: 502 return false; 503 case llvm::Triple::arm: 504 case llvm::Triple::thumb: 505 // ARM Darwin targets require a frame pointer to be always present to aid 506 // offline debugging via backtraces. 507 return Triple.isOSDarwin(); 508 } 509 } 510 511 static bool useFramePointerForTargetByDefault(const ArgList &Args, 512 const llvm::Triple &Triple) { 513 switch (Triple.getArch()) { 514 case llvm::Triple::xcore: 515 case llvm::Triple::wasm32: 516 case llvm::Triple::wasm64: 517 // XCore never wants frame pointers, regardless of OS. 518 // WebAssembly never wants frame pointers. 519 return false; 520 case llvm::Triple::riscv32: 521 case llvm::Triple::riscv64: 522 return !areOptimizationsEnabled(Args); 523 default: 524 break; 525 } 526 527 if (Triple.isOSLinux() || Triple.getOS() == llvm::Triple::CloudABI) { 528 switch (Triple.getArch()) { 529 // Don't use a frame pointer on linux if optimizing for certain targets. 530 case llvm::Triple::mips64: 531 case llvm::Triple::mips64el: 532 case llvm::Triple::mips: 533 case llvm::Triple::mipsel: 534 case llvm::Triple::ppc: 535 case llvm::Triple::ppc64: 536 case llvm::Triple::ppc64le: 537 case llvm::Triple::systemz: 538 case llvm::Triple::x86: 539 case llvm::Triple::x86_64: 540 return !areOptimizationsEnabled(Args); 541 default: 542 return true; 543 } 544 } 545 546 if (Triple.isOSWindows()) { 547 switch (Triple.getArch()) { 548 case llvm::Triple::x86: 549 return !areOptimizationsEnabled(Args); 550 case llvm::Triple::x86_64: 551 return Triple.isOSBinFormatMachO(); 552 case llvm::Triple::arm: 553 case llvm::Triple::thumb: 554 // Windows on ARM builds with FPO disabled to aid fast stack walking 555 return true; 556 default: 557 // All other supported Windows ISAs use xdata unwind information, so frame 558 // pointers are not generally useful. 559 return false; 560 } 561 } 562 563 return true; 564 } 565 566 static bool shouldUseFramePointer(const ArgList &Args, 567 const llvm::Triple &Triple) { 568 if (Arg *A = Args.getLastArg(options::OPT_fno_omit_frame_pointer, 569 options::OPT_fomit_frame_pointer)) 570 return A->getOption().matches(options::OPT_fno_omit_frame_pointer) || 571 mustUseNonLeafFramePointerForTarget(Triple); 572 573 if (Args.hasArg(options::OPT_pg)) 574 return true; 575 576 return useFramePointerForTargetByDefault(Args, Triple); 577 } 578 579 static bool shouldUseLeafFramePointer(const ArgList &Args, 580 const llvm::Triple &Triple) { 581 if (Arg *A = Args.getLastArg(options::OPT_mno_omit_leaf_frame_pointer, 582 options::OPT_momit_leaf_frame_pointer)) 583 return A->getOption().matches(options::OPT_mno_omit_leaf_frame_pointer); 584 585 if (Args.hasArg(options::OPT_pg)) 586 return true; 587 588 if (Triple.isPS4CPU()) 589 return false; 590 591 return useFramePointerForTargetByDefault(Args, Triple); 592 } 593 594 /// Add a CC1 option to specify the debug compilation directory. 595 static void addDebugCompDirArg(const ArgList &Args, ArgStringList &CmdArgs) { 596 SmallString<128> cwd; 597 if (!llvm::sys::fs::current_path(cwd)) { 598 CmdArgs.push_back("-fdebug-compilation-dir"); 599 CmdArgs.push_back(Args.MakeArgString(cwd)); 600 } 601 } 602 603 /// Vectorize at all optimization levels greater than 1 except for -Oz. 604 /// For -Oz the loop vectorizer is disable, while the slp vectorizer is enabled. 605 static bool shouldEnableVectorizerAtOLevel(const ArgList &Args, bool isSlpVec) { 606 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) { 607 if (A->getOption().matches(options::OPT_O4) || 608 A->getOption().matches(options::OPT_Ofast)) 609 return true; 610 611 if (A->getOption().matches(options::OPT_O0)) 612 return false; 613 614 assert(A->getOption().matches(options::OPT_O) && "Must have a -O flag"); 615 616 // Vectorize -Os. 617 StringRef S(A->getValue()); 618 if (S == "s") 619 return true; 620 621 // Don't vectorize -Oz, unless it's the slp vectorizer. 622 if (S == "z") 623 return isSlpVec; 624 625 unsigned OptLevel = 0; 626 if (S.getAsInteger(10, OptLevel)) 627 return false; 628 629 return OptLevel > 1; 630 } 631 632 return false; 633 } 634 635 /// Add -x lang to \p CmdArgs for \p Input. 636 static void addDashXForInput(const ArgList &Args, const InputInfo &Input, 637 ArgStringList &CmdArgs) { 638 // When using -verify-pch, we don't want to provide the type 639 // 'precompiled-header' if it was inferred from the file extension 640 if (Args.hasArg(options::OPT_verify_pch) && Input.getType() == types::TY_PCH) 641 return; 642 643 CmdArgs.push_back("-x"); 644 if (Args.hasArg(options::OPT_rewrite_objc)) 645 CmdArgs.push_back(types::getTypeName(types::TY_PP_ObjCXX)); 646 else { 647 // Map the driver type to the frontend type. This is mostly an identity 648 // mapping, except that the distinction between module interface units 649 // and other source files does not exist at the frontend layer. 650 const char *ClangType; 651 switch (Input.getType()) { 652 case types::TY_CXXModule: 653 ClangType = "c++"; 654 break; 655 case types::TY_PP_CXXModule: 656 ClangType = "c++-cpp-output"; 657 break; 658 default: 659 ClangType = types::getTypeName(Input.getType()); 660 break; 661 } 662 CmdArgs.push_back(ClangType); 663 } 664 } 665 666 static void appendUserToPath(SmallVectorImpl<char> &Result) { 667 #ifdef LLVM_ON_UNIX 668 const char *Username = getenv("LOGNAME"); 669 #else 670 const char *Username = getenv("USERNAME"); 671 #endif 672 if (Username) { 673 // Validate that LoginName can be used in a path, and get its length. 674 size_t Len = 0; 675 for (const char *P = Username; *P; ++P, ++Len) { 676 if (!clang::isAlphanumeric(*P) && *P != '_') { 677 Username = nullptr; 678 break; 679 } 680 } 681 682 if (Username && Len > 0) { 683 Result.append(Username, Username + Len); 684 return; 685 } 686 } 687 688 // Fallback to user id. 689 #ifdef LLVM_ON_UNIX 690 std::string UID = llvm::utostr(getuid()); 691 #else 692 // FIXME: Windows seems to have an 'SID' that might work. 693 std::string UID = "9999"; 694 #endif 695 Result.append(UID.begin(), UID.end()); 696 } 697 698 static void addPGOAndCoverageFlags(Compilation &C, const Driver &D, 699 const InputInfo &Output, const ArgList &Args, 700 ArgStringList &CmdArgs) { 701 702 auto *PGOGenerateArg = Args.getLastArg(options::OPT_fprofile_generate, 703 options::OPT_fprofile_generate_EQ, 704 options::OPT_fno_profile_generate); 705 if (PGOGenerateArg && 706 PGOGenerateArg->getOption().matches(options::OPT_fno_profile_generate)) 707 PGOGenerateArg = nullptr; 708 709 auto *ProfileGenerateArg = Args.getLastArg( 710 options::OPT_fprofile_instr_generate, 711 options::OPT_fprofile_instr_generate_EQ, 712 options::OPT_fno_profile_instr_generate); 713 if (ProfileGenerateArg && 714 ProfileGenerateArg->getOption().matches( 715 options::OPT_fno_profile_instr_generate)) 716 ProfileGenerateArg = nullptr; 717 718 if (PGOGenerateArg && ProfileGenerateArg) 719 D.Diag(diag::err_drv_argument_not_allowed_with) 720 << PGOGenerateArg->getSpelling() << ProfileGenerateArg->getSpelling(); 721 722 auto *ProfileUseArg = getLastProfileUseArg(Args); 723 724 if (PGOGenerateArg && ProfileUseArg) 725 D.Diag(diag::err_drv_argument_not_allowed_with) 726 << ProfileUseArg->getSpelling() << PGOGenerateArg->getSpelling(); 727 728 if (ProfileGenerateArg && ProfileUseArg) 729 D.Diag(diag::err_drv_argument_not_allowed_with) 730 << ProfileGenerateArg->getSpelling() << ProfileUseArg->getSpelling(); 731 732 if (ProfileGenerateArg) { 733 if (ProfileGenerateArg->getOption().matches( 734 options::OPT_fprofile_instr_generate_EQ)) 735 CmdArgs.push_back(Args.MakeArgString(Twine("-fprofile-instrument-path=") + 736 ProfileGenerateArg->getValue())); 737 // The default is to use Clang Instrumentation. 738 CmdArgs.push_back("-fprofile-instrument=clang"); 739 } 740 741 if (PGOGenerateArg) { 742 CmdArgs.push_back("-fprofile-instrument=llvm"); 743 if (PGOGenerateArg->getOption().matches( 744 options::OPT_fprofile_generate_EQ)) { 745 SmallString<128> Path(PGOGenerateArg->getValue()); 746 llvm::sys::path::append(Path, "default_%m.profraw"); 747 CmdArgs.push_back( 748 Args.MakeArgString(Twine("-fprofile-instrument-path=") + Path)); 749 } 750 } 751 752 if (ProfileUseArg) { 753 if (ProfileUseArg->getOption().matches(options::OPT_fprofile_instr_use_EQ)) 754 CmdArgs.push_back(Args.MakeArgString( 755 Twine("-fprofile-instrument-use-path=") + ProfileUseArg->getValue())); 756 else if ((ProfileUseArg->getOption().matches( 757 options::OPT_fprofile_use_EQ) || 758 ProfileUseArg->getOption().matches( 759 options::OPT_fprofile_instr_use))) { 760 SmallString<128> Path( 761 ProfileUseArg->getNumValues() == 0 ? "" : ProfileUseArg->getValue()); 762 if (Path.empty() || llvm::sys::fs::is_directory(Path)) 763 llvm::sys::path::append(Path, "default.profdata"); 764 CmdArgs.push_back( 765 Args.MakeArgString(Twine("-fprofile-instrument-use-path=") + Path)); 766 } 767 } 768 769 if (Args.hasArg(options::OPT_ftest_coverage) || 770 Args.hasArg(options::OPT_coverage)) 771 CmdArgs.push_back("-femit-coverage-notes"); 772 if (Args.hasFlag(options::OPT_fprofile_arcs, options::OPT_fno_profile_arcs, 773 false) || 774 Args.hasArg(options::OPT_coverage)) 775 CmdArgs.push_back("-femit-coverage-data"); 776 777 if (Args.hasFlag(options::OPT_fcoverage_mapping, 778 options::OPT_fno_coverage_mapping, false)) { 779 if (!ProfileGenerateArg) 780 D.Diag(clang::diag::err_drv_argument_only_allowed_with) 781 << "-fcoverage-mapping" 782 << "-fprofile-instr-generate"; 783 784 CmdArgs.push_back("-fcoverage-mapping"); 785 } 786 787 if (C.getArgs().hasArg(options::OPT_c) || 788 C.getArgs().hasArg(options::OPT_S)) { 789 if (Output.isFilename()) { 790 CmdArgs.push_back("-coverage-notes-file"); 791 SmallString<128> OutputFilename; 792 if (Arg *FinalOutput = C.getArgs().getLastArg(options::OPT_o)) 793 OutputFilename = FinalOutput->getValue(); 794 else 795 OutputFilename = llvm::sys::path::filename(Output.getBaseInput()); 796 SmallString<128> CoverageFilename = OutputFilename; 797 if (llvm::sys::path::is_relative(CoverageFilename)) { 798 SmallString<128> Pwd; 799 if (!llvm::sys::fs::current_path(Pwd)) { 800 llvm::sys::path::append(Pwd, CoverageFilename); 801 CoverageFilename.swap(Pwd); 802 } 803 } 804 llvm::sys::path::replace_extension(CoverageFilename, "gcno"); 805 CmdArgs.push_back(Args.MakeArgString(CoverageFilename)); 806 807 // Leave -fprofile-dir= an unused argument unless .gcda emission is 808 // enabled. To be polite, with '-fprofile-arcs -fno-profile-arcs' consider 809 // the flag used. There is no -fno-profile-dir, so the user has no 810 // targeted way to suppress the warning. 811 if (Args.hasArg(options::OPT_fprofile_arcs) || 812 Args.hasArg(options::OPT_coverage)) { 813 CmdArgs.push_back("-coverage-data-file"); 814 if (Arg *FProfileDir = Args.getLastArg(options::OPT_fprofile_dir)) { 815 CoverageFilename = FProfileDir->getValue(); 816 llvm::sys::path::append(CoverageFilename, OutputFilename); 817 } 818 llvm::sys::path::replace_extension(CoverageFilename, "gcda"); 819 CmdArgs.push_back(Args.MakeArgString(CoverageFilename)); 820 } 821 } 822 } 823 } 824 825 /// Check whether the given input tree contains any compilation actions. 826 static bool ContainsCompileAction(const Action *A) { 827 if (isa<CompileJobAction>(A) || isa<BackendJobAction>(A)) 828 return true; 829 830 for (const auto &AI : A->inputs()) 831 if (ContainsCompileAction(AI)) 832 return true; 833 834 return false; 835 } 836 837 /// Check if -relax-all should be passed to the internal assembler. 838 /// This is done by default when compiling non-assembler source with -O0. 839 static bool UseRelaxAll(Compilation &C, const ArgList &Args) { 840 bool RelaxDefault = true; 841 842 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) 843 RelaxDefault = A->getOption().matches(options::OPT_O0); 844 845 if (RelaxDefault) { 846 RelaxDefault = false; 847 for (const auto &Act : C.getActions()) { 848 if (ContainsCompileAction(Act)) { 849 RelaxDefault = true; 850 break; 851 } 852 } 853 } 854 855 return Args.hasFlag(options::OPT_mrelax_all, options::OPT_mno_relax_all, 856 RelaxDefault); 857 } 858 859 // Extract the integer N from a string spelled "-dwarf-N", returning 0 860 // on mismatch. The StringRef input (rather than an Arg) allows 861 // for use by the "-Xassembler" option parser. 862 static unsigned DwarfVersionNum(StringRef ArgValue) { 863 return llvm::StringSwitch<unsigned>(ArgValue) 864 .Case("-gdwarf-2", 2) 865 .Case("-gdwarf-3", 3) 866 .Case("-gdwarf-4", 4) 867 .Case("-gdwarf-5", 5) 868 .Default(0); 869 } 870 871 static void RenderDebugEnablingArgs(const ArgList &Args, ArgStringList &CmdArgs, 872 codegenoptions::DebugInfoKind DebugInfoKind, 873 unsigned DwarfVersion, 874 llvm::DebuggerKind DebuggerTuning) { 875 switch (DebugInfoKind) { 876 case codegenoptions::DebugLineTablesOnly: 877 CmdArgs.push_back("-debug-info-kind=line-tables-only"); 878 break; 879 case codegenoptions::LimitedDebugInfo: 880 CmdArgs.push_back("-debug-info-kind=limited"); 881 break; 882 case codegenoptions::FullDebugInfo: 883 CmdArgs.push_back("-debug-info-kind=standalone"); 884 break; 885 default: 886 break; 887 } 888 if (DwarfVersion > 0) 889 CmdArgs.push_back( 890 Args.MakeArgString("-dwarf-version=" + Twine(DwarfVersion))); 891 switch (DebuggerTuning) { 892 case llvm::DebuggerKind::GDB: 893 CmdArgs.push_back("-debugger-tuning=gdb"); 894 break; 895 case llvm::DebuggerKind::LLDB: 896 CmdArgs.push_back("-debugger-tuning=lldb"); 897 break; 898 case llvm::DebuggerKind::SCE: 899 CmdArgs.push_back("-debugger-tuning=sce"); 900 break; 901 default: 902 break; 903 } 904 } 905 906 static void RenderDebugInfoCompressionArgs(const ArgList &Args, 907 ArgStringList &CmdArgs, 908 const Driver &D) { 909 const Arg *A = Args.getLastArg(options::OPT_gz, options::OPT_gz_EQ); 910 if (!A) 911 return; 912 913 if (A->getOption().getID() == options::OPT_gz) { 914 if (llvm::zlib::isAvailable()) 915 CmdArgs.push_back("-compress-debug-sections"); 916 else 917 D.Diag(diag::warn_debug_compression_unavailable); 918 return; 919 } 920 921 StringRef Value = A->getValue(); 922 if (Value == "none") { 923 CmdArgs.push_back("-compress-debug-sections=none"); 924 } else if (Value == "zlib" || Value == "zlib-gnu") { 925 if (llvm::zlib::isAvailable()) { 926 CmdArgs.push_back( 927 Args.MakeArgString("-compress-debug-sections=" + Twine(Value))); 928 } else { 929 D.Diag(diag::warn_debug_compression_unavailable); 930 } 931 } else { 932 D.Diag(diag::err_drv_unsupported_option_argument) 933 << A->getOption().getName() << Value; 934 } 935 } 936 937 static const char *RelocationModelName(llvm::Reloc::Model Model) { 938 switch (Model) { 939 case llvm::Reloc::Static: 940 return "static"; 941 case llvm::Reloc::PIC_: 942 return "pic"; 943 case llvm::Reloc::DynamicNoPIC: 944 return "dynamic-no-pic"; 945 case llvm::Reloc::ROPI: 946 return "ropi"; 947 case llvm::Reloc::RWPI: 948 return "rwpi"; 949 case llvm::Reloc::ROPI_RWPI: 950 return "ropi-rwpi"; 951 } 952 llvm_unreachable("Unknown Reloc::Model kind"); 953 } 954 955 void Clang::AddPreprocessingOptions(Compilation &C, const JobAction &JA, 956 const Driver &D, const ArgList &Args, 957 ArgStringList &CmdArgs, 958 const InputInfo &Output, 959 const InputInfoList &Inputs) const { 960 Arg *A; 961 const bool IsIAMCU = getToolChain().getTriple().isOSIAMCU(); 962 963 CheckPreprocessingOptions(D, Args); 964 965 Args.AddLastArg(CmdArgs, options::OPT_C); 966 Args.AddLastArg(CmdArgs, options::OPT_CC); 967 968 // Handle dependency file generation. 969 if ((A = Args.getLastArg(options::OPT_M, options::OPT_MM)) || 970 (A = Args.getLastArg(options::OPT_MD)) || 971 (A = Args.getLastArg(options::OPT_MMD))) { 972 // Determine the output location. 973 const char *DepFile; 974 if (Arg *MF = Args.getLastArg(options::OPT_MF)) { 975 DepFile = MF->getValue(); 976 C.addFailureResultFile(DepFile, &JA); 977 } else if (Output.getType() == types::TY_Dependencies) { 978 DepFile = Output.getFilename(); 979 } else if (A->getOption().matches(options::OPT_M) || 980 A->getOption().matches(options::OPT_MM)) { 981 DepFile = "-"; 982 } else { 983 DepFile = getDependencyFileName(Args, Inputs); 984 C.addFailureResultFile(DepFile, &JA); 985 } 986 CmdArgs.push_back("-dependency-file"); 987 CmdArgs.push_back(DepFile); 988 989 // Add a default target if one wasn't specified. 990 if (!Args.hasArg(options::OPT_MT) && !Args.hasArg(options::OPT_MQ)) { 991 const char *DepTarget; 992 993 // If user provided -o, that is the dependency target, except 994 // when we are only generating a dependency file. 995 Arg *OutputOpt = Args.getLastArg(options::OPT_o); 996 if (OutputOpt && Output.getType() != types::TY_Dependencies) { 997 DepTarget = OutputOpt->getValue(); 998 } else { 999 // Otherwise derive from the base input. 1000 // 1001 // FIXME: This should use the computed output file location. 1002 SmallString<128> P(Inputs[0].getBaseInput()); 1003 llvm::sys::path::replace_extension(P, "o"); 1004 DepTarget = Args.MakeArgString(llvm::sys::path::filename(P)); 1005 } 1006 1007 if (!A->getOption().matches(options::OPT_MD) && !A->getOption().matches(options::OPT_MMD)) { 1008 CmdArgs.push_back("-w"); 1009 } 1010 CmdArgs.push_back("-MT"); 1011 SmallString<128> Quoted; 1012 QuoteTarget(DepTarget, Quoted); 1013 CmdArgs.push_back(Args.MakeArgString(Quoted)); 1014 } 1015 1016 if (A->getOption().matches(options::OPT_M) || 1017 A->getOption().matches(options::OPT_MD)) 1018 CmdArgs.push_back("-sys-header-deps"); 1019 if ((isa<PrecompileJobAction>(JA) && 1020 !Args.hasArg(options::OPT_fno_module_file_deps)) || 1021 Args.hasArg(options::OPT_fmodule_file_deps)) 1022 CmdArgs.push_back("-module-file-deps"); 1023 } 1024 1025 if (Args.hasArg(options::OPT_MG)) { 1026 if (!A || A->getOption().matches(options::OPT_MD) || 1027 A->getOption().matches(options::OPT_MMD)) 1028 D.Diag(diag::err_drv_mg_requires_m_or_mm); 1029 CmdArgs.push_back("-MG"); 1030 } 1031 1032 Args.AddLastArg(CmdArgs, options::OPT_MP); 1033 Args.AddLastArg(CmdArgs, options::OPT_MV); 1034 1035 // Convert all -MQ <target> args to -MT <quoted target> 1036 for (const Arg *A : Args.filtered(options::OPT_MT, options::OPT_MQ)) { 1037 A->claim(); 1038 1039 if (A->getOption().matches(options::OPT_MQ)) { 1040 CmdArgs.push_back("-MT"); 1041 SmallString<128> Quoted; 1042 QuoteTarget(A->getValue(), Quoted); 1043 CmdArgs.push_back(Args.MakeArgString(Quoted)); 1044 1045 // -MT flag - no change 1046 } else { 1047 A->render(Args, CmdArgs); 1048 } 1049 } 1050 1051 // Add offload include arguments specific for CUDA. This must happen before 1052 // we -I or -include anything else, because we must pick up the CUDA headers 1053 // from the particular CUDA installation, rather than from e.g. 1054 // /usr/local/include. 1055 if (JA.isOffloading(Action::OFK_Cuda)) 1056 getToolChain().AddCudaIncludeArgs(Args, CmdArgs); 1057 1058 // Add -i* options, and automatically translate to 1059 // -include-pch/-include-pth for transparent PCH support. It's 1060 // wonky, but we include looking for .gch so we can support seamless 1061 // replacement into a build system already set up to be generating 1062 // .gch files. 1063 int YcIndex = -1, YuIndex = -1; 1064 { 1065 int AI = -1; 1066 const Arg *YcArg = Args.getLastArg(options::OPT__SLASH_Yc); 1067 const Arg *YuArg = Args.getLastArg(options::OPT__SLASH_Yu); 1068 for (const Arg *A : Args.filtered(options::OPT_clang_i_Group)) { 1069 // Walk the whole i_Group and skip non "-include" flags so that the index 1070 // here matches the index in the next loop below. 1071 ++AI; 1072 if (!A->getOption().matches(options::OPT_include)) 1073 continue; 1074 if (YcArg && strcmp(A->getValue(), YcArg->getValue()) == 0) 1075 YcIndex = AI; 1076 if (YuArg && strcmp(A->getValue(), YuArg->getValue()) == 0) 1077 YuIndex = AI; 1078 } 1079 } 1080 if (isa<PrecompileJobAction>(JA) && YcIndex != -1) { 1081 Driver::InputList Inputs; 1082 D.BuildInputs(getToolChain(), C.getArgs(), Inputs); 1083 assert(Inputs.size() == 1 && "Need one input when building pch"); 1084 CmdArgs.push_back(Args.MakeArgString(Twine("-find-pch-source=") + 1085 Inputs[0].second->getValue())); 1086 } 1087 if (YcIndex != -1 && JA.getKind() >= Action::PrecompileJobClass && 1088 JA.getKind() <= Action::AssembleJobClass) { 1089 CmdArgs.push_back(Args.MakeArgString("-building-pch-with-obj")); 1090 } 1091 1092 bool RenderedImplicitInclude = false; 1093 int AI = -1; 1094 for (const Arg *A : Args.filtered(options::OPT_clang_i_Group)) { 1095 ++AI; 1096 1097 if (getToolChain().getDriver().IsCLMode() && 1098 A->getOption().matches(options::OPT_include)) { 1099 // In clang-cl mode, /Ycfoo.h means that all code up to a foo.h 1100 // include is compiled into foo.h, and everything after goes into 1101 // the .obj file. /Yufoo.h means that all includes prior to and including 1102 // foo.h are completely skipped and replaced with a use of the pch file 1103 // for foo.h. (Each flag can have at most one value, multiple /Yc flags 1104 // just mean that the last one wins.) If /Yc and /Yu are both present 1105 // and refer to the same file, /Yc wins. 1106 // Note that OPT__SLASH_FI gets mapped to OPT_include. 1107 // FIXME: The code here assumes that /Yc and /Yu refer to the same file. 1108 // cl.exe seems to support both flags with different values, but that 1109 // seems strange (which flag does /Fp now refer to?), so don't implement 1110 // that until someone needs it. 1111 int PchIndex = YcIndex != -1 ? YcIndex : YuIndex; 1112 if (PchIndex != -1) { 1113 if (isa<PrecompileJobAction>(JA)) { 1114 // When building the pch, skip all includes after the pch. 1115 assert(YcIndex != -1 && PchIndex == YcIndex); 1116 if (AI >= YcIndex) 1117 continue; 1118 } else { 1119 // When using the pch, skip all includes prior to the pch. 1120 if (AI < PchIndex) { 1121 A->claim(); 1122 continue; 1123 } 1124 if (AI == PchIndex) { 1125 A->claim(); 1126 CmdArgs.push_back("-include-pch"); 1127 CmdArgs.push_back( 1128 Args.MakeArgString(D.GetClPchPath(C, A->getValue()))); 1129 continue; 1130 } 1131 } 1132 } 1133 } else if (A->getOption().matches(options::OPT_include)) { 1134 // Handling of gcc-style gch precompiled headers. 1135 bool IsFirstImplicitInclude = !RenderedImplicitInclude; 1136 RenderedImplicitInclude = true; 1137 1138 // Use PCH if the user requested it. 1139 bool UsePCH = D.CCCUsePCH; 1140 1141 bool FoundPTH = false; 1142 bool FoundPCH = false; 1143 SmallString<128> P(A->getValue()); 1144 // We want the files to have a name like foo.h.pch. Add a dummy extension 1145 // so that replace_extension does the right thing. 1146 P += ".dummy"; 1147 if (UsePCH) { 1148 llvm::sys::path::replace_extension(P, "pch"); 1149 if (llvm::sys::fs::exists(P)) 1150 FoundPCH = true; 1151 } 1152 1153 if (!FoundPCH) { 1154 llvm::sys::path::replace_extension(P, "pth"); 1155 if (llvm::sys::fs::exists(P)) 1156 FoundPTH = true; 1157 } 1158 1159 if (!FoundPCH && !FoundPTH) { 1160 llvm::sys::path::replace_extension(P, "gch"); 1161 if (llvm::sys::fs::exists(P)) { 1162 FoundPCH = UsePCH; 1163 FoundPTH = !UsePCH; 1164 } 1165 } 1166 1167 if (FoundPCH || FoundPTH) { 1168 if (IsFirstImplicitInclude) { 1169 A->claim(); 1170 if (UsePCH) 1171 CmdArgs.push_back("-include-pch"); 1172 else 1173 CmdArgs.push_back("-include-pth"); 1174 CmdArgs.push_back(Args.MakeArgString(P)); 1175 continue; 1176 } else { 1177 // Ignore the PCH if not first on command line and emit warning. 1178 D.Diag(diag::warn_drv_pch_not_first_include) << P 1179 << A->getAsString(Args); 1180 } 1181 } 1182 } else if (A->getOption().matches(options::OPT_isystem_after)) { 1183 // Handling of paths which must come late. These entries are handled by 1184 // the toolchain itself after the resource dir is inserted in the right 1185 // search order. 1186 // Do not claim the argument so that the use of the argument does not 1187 // silently go unnoticed on toolchains which do not honour the option. 1188 continue; 1189 } 1190 1191 // Not translated, render as usual. 1192 A->claim(); 1193 A->render(Args, CmdArgs); 1194 } 1195 1196 Args.AddAllArgs(CmdArgs, 1197 {options::OPT_D, options::OPT_U, options::OPT_I_Group, 1198 options::OPT_F, options::OPT_index_header_map}); 1199 1200 // Add -Wp, and -Xpreprocessor if using the preprocessor. 1201 1202 // FIXME: There is a very unfortunate problem here, some troubled 1203 // souls abuse -Wp, to pass preprocessor options in gcc syntax. To 1204 // really support that we would have to parse and then translate 1205 // those options. :( 1206 Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA, 1207 options::OPT_Xpreprocessor); 1208 1209 // -I- is a deprecated GCC feature, reject it. 1210 if (Arg *A = Args.getLastArg(options::OPT_I_)) 1211 D.Diag(diag::err_drv_I_dash_not_supported) << A->getAsString(Args); 1212 1213 // If we have a --sysroot, and don't have an explicit -isysroot flag, add an 1214 // -isysroot to the CC1 invocation. 1215 StringRef sysroot = C.getSysRoot(); 1216 if (sysroot != "") { 1217 if (!Args.hasArg(options::OPT_isysroot)) { 1218 CmdArgs.push_back("-isysroot"); 1219 CmdArgs.push_back(C.getArgs().MakeArgString(sysroot)); 1220 } 1221 } 1222 1223 // Parse additional include paths from environment variables. 1224 // FIXME: We should probably sink the logic for handling these from the 1225 // frontend into the driver. It will allow deleting 4 otherwise unused flags. 1226 // CPATH - included following the user specified includes (but prior to 1227 // builtin and standard includes). 1228 addDirectoryList(Args, CmdArgs, "-I", "CPATH"); 1229 // C_INCLUDE_PATH - system includes enabled when compiling C. 1230 addDirectoryList(Args, CmdArgs, "-c-isystem", "C_INCLUDE_PATH"); 1231 // CPLUS_INCLUDE_PATH - system includes enabled when compiling C++. 1232 addDirectoryList(Args, CmdArgs, "-cxx-isystem", "CPLUS_INCLUDE_PATH"); 1233 // OBJC_INCLUDE_PATH - system includes enabled when compiling ObjC. 1234 addDirectoryList(Args, CmdArgs, "-objc-isystem", "OBJC_INCLUDE_PATH"); 1235 // OBJCPLUS_INCLUDE_PATH - system includes enabled when compiling ObjC++. 1236 addDirectoryList(Args, CmdArgs, "-objcxx-isystem", "OBJCPLUS_INCLUDE_PATH"); 1237 1238 // While adding the include arguments, we also attempt to retrieve the 1239 // arguments of related offloading toolchains or arguments that are specific 1240 // of an offloading programming model. 1241 1242 // Add C++ include arguments, if needed. 1243 if (types::isCXX(Inputs[0].getType())) 1244 forAllAssociatedToolChains(C, JA, getToolChain(), 1245 [&Args, &CmdArgs](const ToolChain &TC) { 1246 TC.AddClangCXXStdlibIncludeArgs(Args, CmdArgs); 1247 }); 1248 1249 // Add system include arguments for all targets but IAMCU. 1250 if (!IsIAMCU) 1251 forAllAssociatedToolChains(C, JA, getToolChain(), 1252 [&Args, &CmdArgs](const ToolChain &TC) { 1253 TC.AddClangSystemIncludeArgs(Args, CmdArgs); 1254 }); 1255 else { 1256 // For IAMCU add special include arguments. 1257 getToolChain().AddIAMCUIncludeArgs(Args, CmdArgs); 1258 } 1259 } 1260 1261 // FIXME: Move to target hook. 1262 static bool isSignedCharDefault(const llvm::Triple &Triple) { 1263 switch (Triple.getArch()) { 1264 default: 1265 return true; 1266 1267 case llvm::Triple::aarch64: 1268 case llvm::Triple::aarch64_be: 1269 case llvm::Triple::arm: 1270 case llvm::Triple::armeb: 1271 case llvm::Triple::thumb: 1272 case llvm::Triple::thumbeb: 1273 if (Triple.isOSDarwin() || Triple.isOSWindows()) 1274 return true; 1275 return false; 1276 1277 case llvm::Triple::ppc: 1278 case llvm::Triple::ppc64: 1279 if (Triple.isOSDarwin()) 1280 return true; 1281 return false; 1282 1283 case llvm::Triple::hexagon: 1284 case llvm::Triple::ppc64le: 1285 case llvm::Triple::riscv32: 1286 case llvm::Triple::riscv64: 1287 case llvm::Triple::systemz: 1288 case llvm::Triple::xcore: 1289 return false; 1290 } 1291 } 1292 1293 static bool isNoCommonDefault(const llvm::Triple &Triple) { 1294 switch (Triple.getArch()) { 1295 default: 1296 if (Triple.isOSFuchsia()) 1297 return true; 1298 return false; 1299 1300 case llvm::Triple::xcore: 1301 case llvm::Triple::wasm32: 1302 case llvm::Triple::wasm64: 1303 return true; 1304 } 1305 } 1306 1307 void Clang::AddARMTargetArgs(const llvm::Triple &Triple, const ArgList &Args, 1308 ArgStringList &CmdArgs, bool KernelOrKext) const { 1309 // Select the ABI to use. 1310 // FIXME: Support -meabi. 1311 // FIXME: Parts of this are duplicated in the backend, unify this somehow. 1312 const char *ABIName = nullptr; 1313 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) 1314 ABIName = A->getValue(); 1315 else { 1316 std::string CPU = getCPUName(Args, Triple, /*FromAs*/ false); 1317 ABIName = llvm::ARM::computeDefaultTargetABI(Triple, CPU).data(); 1318 } 1319 1320 CmdArgs.push_back("-target-abi"); 1321 CmdArgs.push_back(ABIName); 1322 1323 // Determine floating point ABI from the options & target defaults. 1324 arm::FloatABI ABI = arm::getARMFloatABI(getToolChain(), Args); 1325 if (ABI == arm::FloatABI::Soft) { 1326 // Floating point operations and argument passing are soft. 1327 // FIXME: This changes CPP defines, we need -target-soft-float. 1328 CmdArgs.push_back("-msoft-float"); 1329 CmdArgs.push_back("-mfloat-abi"); 1330 CmdArgs.push_back("soft"); 1331 } else if (ABI == arm::FloatABI::SoftFP) { 1332 // Floating point operations are hard, but argument passing is soft. 1333 CmdArgs.push_back("-mfloat-abi"); 1334 CmdArgs.push_back("soft"); 1335 } else { 1336 // Floating point operations and argument passing are hard. 1337 assert(ABI == arm::FloatABI::Hard && "Invalid float abi!"); 1338 CmdArgs.push_back("-mfloat-abi"); 1339 CmdArgs.push_back("hard"); 1340 } 1341 1342 // Forward the -mglobal-merge option for explicit control over the pass. 1343 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge, 1344 options::OPT_mno_global_merge)) { 1345 CmdArgs.push_back("-mllvm"); 1346 if (A->getOption().matches(options::OPT_mno_global_merge)) 1347 CmdArgs.push_back("-arm-global-merge=false"); 1348 else 1349 CmdArgs.push_back("-arm-global-merge=true"); 1350 } 1351 1352 if (!Args.hasFlag(options::OPT_mimplicit_float, 1353 options::OPT_mno_implicit_float, true)) 1354 CmdArgs.push_back("-no-implicit-float"); 1355 } 1356 1357 void Clang::RenderTargetOptions(const llvm::Triple &EffectiveTriple, 1358 const ArgList &Args, bool KernelOrKext, 1359 ArgStringList &CmdArgs) const { 1360 const ToolChain &TC = getToolChain(); 1361 1362 // Add the target features 1363 getTargetFeatures(TC, EffectiveTriple, Args, CmdArgs, false); 1364 1365 // Add target specific flags. 1366 switch (TC.getArch()) { 1367 default: 1368 break; 1369 1370 case llvm::Triple::arm: 1371 case llvm::Triple::armeb: 1372 case llvm::Triple::thumb: 1373 case llvm::Triple::thumbeb: 1374 // Use the effective triple, which takes into account the deployment target. 1375 AddARMTargetArgs(EffectiveTriple, Args, CmdArgs, KernelOrKext); 1376 CmdArgs.push_back("-fallow-half-arguments-and-returns"); 1377 break; 1378 1379 case llvm::Triple::aarch64: 1380 case llvm::Triple::aarch64_be: 1381 AddAArch64TargetArgs(Args, CmdArgs); 1382 CmdArgs.push_back("-fallow-half-arguments-and-returns"); 1383 break; 1384 1385 case llvm::Triple::mips: 1386 case llvm::Triple::mipsel: 1387 case llvm::Triple::mips64: 1388 case llvm::Triple::mips64el: 1389 AddMIPSTargetArgs(Args, CmdArgs); 1390 break; 1391 1392 case llvm::Triple::ppc: 1393 case llvm::Triple::ppc64: 1394 case llvm::Triple::ppc64le: 1395 AddPPCTargetArgs(Args, CmdArgs); 1396 break; 1397 1398 case llvm::Triple::riscv32: 1399 case llvm::Triple::riscv64: 1400 AddRISCVTargetArgs(Args, CmdArgs); 1401 break; 1402 1403 case llvm::Triple::sparc: 1404 case llvm::Triple::sparcel: 1405 case llvm::Triple::sparcv9: 1406 AddSparcTargetArgs(Args, CmdArgs); 1407 break; 1408 1409 case llvm::Triple::systemz: 1410 AddSystemZTargetArgs(Args, CmdArgs); 1411 break; 1412 1413 case llvm::Triple::x86: 1414 case llvm::Triple::x86_64: 1415 AddX86TargetArgs(Args, CmdArgs); 1416 break; 1417 1418 case llvm::Triple::lanai: 1419 AddLanaiTargetArgs(Args, CmdArgs); 1420 break; 1421 1422 case llvm::Triple::hexagon: 1423 AddHexagonTargetArgs(Args, CmdArgs); 1424 break; 1425 1426 case llvm::Triple::wasm32: 1427 case llvm::Triple::wasm64: 1428 AddWebAssemblyTargetArgs(Args, CmdArgs); 1429 break; 1430 } 1431 } 1432 1433 void Clang::AddAArch64TargetArgs(const ArgList &Args, 1434 ArgStringList &CmdArgs) const { 1435 const llvm::Triple &Triple = getToolChain().getEffectiveTriple(); 1436 1437 if (!Args.hasFlag(options::OPT_mred_zone, options::OPT_mno_red_zone, true) || 1438 Args.hasArg(options::OPT_mkernel) || 1439 Args.hasArg(options::OPT_fapple_kext)) 1440 CmdArgs.push_back("-disable-red-zone"); 1441 1442 if (!Args.hasFlag(options::OPT_mimplicit_float, 1443 options::OPT_mno_implicit_float, true)) 1444 CmdArgs.push_back("-no-implicit-float"); 1445 1446 const char *ABIName = nullptr; 1447 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) 1448 ABIName = A->getValue(); 1449 else if (Triple.isOSDarwin()) 1450 ABIName = "darwinpcs"; 1451 else 1452 ABIName = "aapcs"; 1453 1454 CmdArgs.push_back("-target-abi"); 1455 CmdArgs.push_back(ABIName); 1456 1457 if (Arg *A = Args.getLastArg(options::OPT_mfix_cortex_a53_835769, 1458 options::OPT_mno_fix_cortex_a53_835769)) { 1459 CmdArgs.push_back("-mllvm"); 1460 if (A->getOption().matches(options::OPT_mfix_cortex_a53_835769)) 1461 CmdArgs.push_back("-aarch64-fix-cortex-a53-835769=1"); 1462 else 1463 CmdArgs.push_back("-aarch64-fix-cortex-a53-835769=0"); 1464 } else if (Triple.isAndroid()) { 1465 // Enabled A53 errata (835769) workaround by default on android 1466 CmdArgs.push_back("-mllvm"); 1467 CmdArgs.push_back("-aarch64-fix-cortex-a53-835769=1"); 1468 } 1469 1470 // Forward the -mglobal-merge option for explicit control over the pass. 1471 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge, 1472 options::OPT_mno_global_merge)) { 1473 CmdArgs.push_back("-mllvm"); 1474 if (A->getOption().matches(options::OPT_mno_global_merge)) 1475 CmdArgs.push_back("-aarch64-enable-global-merge=false"); 1476 else 1477 CmdArgs.push_back("-aarch64-enable-global-merge=true"); 1478 } 1479 } 1480 1481 void Clang::AddMIPSTargetArgs(const ArgList &Args, 1482 ArgStringList &CmdArgs) const { 1483 const Driver &D = getToolChain().getDriver(); 1484 StringRef CPUName; 1485 StringRef ABIName; 1486 const llvm::Triple &Triple = getToolChain().getTriple(); 1487 mips::getMipsCPUAndABI(Args, Triple, CPUName, ABIName); 1488 1489 CmdArgs.push_back("-target-abi"); 1490 CmdArgs.push_back(ABIName.data()); 1491 1492 mips::FloatABI ABI = mips::getMipsFloatABI(D, Args); 1493 if (ABI == mips::FloatABI::Soft) { 1494 // Floating point operations and argument passing are soft. 1495 CmdArgs.push_back("-msoft-float"); 1496 CmdArgs.push_back("-mfloat-abi"); 1497 CmdArgs.push_back("soft"); 1498 } else { 1499 // Floating point operations and argument passing are hard. 1500 assert(ABI == mips::FloatABI::Hard && "Invalid float abi!"); 1501 CmdArgs.push_back("-mfloat-abi"); 1502 CmdArgs.push_back("hard"); 1503 } 1504 1505 if (Arg *A = Args.getLastArg(options::OPT_mxgot, options::OPT_mno_xgot)) { 1506 if (A->getOption().matches(options::OPT_mxgot)) { 1507 CmdArgs.push_back("-mllvm"); 1508 CmdArgs.push_back("-mxgot"); 1509 } 1510 } 1511 1512 if (Arg *A = Args.getLastArg(options::OPT_mldc1_sdc1, 1513 options::OPT_mno_ldc1_sdc1)) { 1514 if (A->getOption().matches(options::OPT_mno_ldc1_sdc1)) { 1515 CmdArgs.push_back("-mllvm"); 1516 CmdArgs.push_back("-mno-ldc1-sdc1"); 1517 } 1518 } 1519 1520 if (Arg *A = Args.getLastArg(options::OPT_mcheck_zero_division, 1521 options::OPT_mno_check_zero_division)) { 1522 if (A->getOption().matches(options::OPT_mno_check_zero_division)) { 1523 CmdArgs.push_back("-mllvm"); 1524 CmdArgs.push_back("-mno-check-zero-division"); 1525 } 1526 } 1527 1528 if (Arg *A = Args.getLastArg(options::OPT_G)) { 1529 StringRef v = A->getValue(); 1530 CmdArgs.push_back("-mllvm"); 1531 CmdArgs.push_back(Args.MakeArgString("-mips-ssection-threshold=" + v)); 1532 A->claim(); 1533 } 1534 1535 Arg *GPOpt = Args.getLastArg(options::OPT_mgpopt, options::OPT_mno_gpopt); 1536 Arg *ABICalls = 1537 Args.getLastArg(options::OPT_mabicalls, options::OPT_mno_abicalls); 1538 1539 // -mabicalls is the default for many MIPS environments, even with -fno-pic. 1540 // -mgpopt is the default for static, -fno-pic environments but these two 1541 // options conflict. We want to be certain that -mno-abicalls -mgpopt is 1542 // the only case where -mllvm -mgpopt is passed. 1543 // NOTE: We need a warning here or in the backend to warn when -mgpopt is 1544 // passed explicitly when compiling something with -mabicalls 1545 // (implictly) in affect. Currently the warning is in the backend. 1546 // 1547 // When the ABI in use is N64, we also need to determine the PIC mode that 1548 // is in use, as -fno-pic for N64 implies -mno-abicalls. 1549 bool NoABICalls = 1550 ABICalls && ABICalls->getOption().matches(options::OPT_mno_abicalls); 1551 1552 llvm::Reloc::Model RelocationModel; 1553 unsigned PICLevel; 1554 bool IsPIE; 1555 std::tie(RelocationModel, PICLevel, IsPIE) = 1556 ParsePICArgs(getToolChain(), Args); 1557 1558 NoABICalls = NoABICalls || 1559 (RelocationModel == llvm::Reloc::Static && ABIName == "n64"); 1560 1561 bool WantGPOpt = GPOpt && GPOpt->getOption().matches(options::OPT_mgpopt); 1562 // We quietly ignore -mno-gpopt as the backend defaults to -mno-gpopt. 1563 if (NoABICalls && (!GPOpt || WantGPOpt)) { 1564 CmdArgs.push_back("-mllvm"); 1565 CmdArgs.push_back("-mgpopt"); 1566 1567 Arg *LocalSData = Args.getLastArg(options::OPT_mlocal_sdata, 1568 options::OPT_mno_local_sdata); 1569 Arg *ExternSData = Args.getLastArg(options::OPT_mextern_sdata, 1570 options::OPT_mno_extern_sdata); 1571 Arg *EmbeddedData = Args.getLastArg(options::OPT_membedded_data, 1572 options::OPT_mno_embedded_data); 1573 if (LocalSData) { 1574 CmdArgs.push_back("-mllvm"); 1575 if (LocalSData->getOption().matches(options::OPT_mlocal_sdata)) { 1576 CmdArgs.push_back("-mlocal-sdata=1"); 1577 } else { 1578 CmdArgs.push_back("-mlocal-sdata=0"); 1579 } 1580 LocalSData->claim(); 1581 } 1582 1583 if (ExternSData) { 1584 CmdArgs.push_back("-mllvm"); 1585 if (ExternSData->getOption().matches(options::OPT_mextern_sdata)) { 1586 CmdArgs.push_back("-mextern-sdata=1"); 1587 } else { 1588 CmdArgs.push_back("-mextern-sdata=0"); 1589 } 1590 ExternSData->claim(); 1591 } 1592 1593 if (EmbeddedData) { 1594 CmdArgs.push_back("-mllvm"); 1595 if (EmbeddedData->getOption().matches(options::OPT_membedded_data)) { 1596 CmdArgs.push_back("-membedded-data=1"); 1597 } else { 1598 CmdArgs.push_back("-membedded-data=0"); 1599 } 1600 EmbeddedData->claim(); 1601 } 1602 1603 } else if ((!ABICalls || (!NoABICalls && ABICalls)) && WantGPOpt) 1604 D.Diag(diag::warn_drv_unsupported_gpopt) << (ABICalls ? 0 : 1); 1605 1606 if (GPOpt) 1607 GPOpt->claim(); 1608 1609 if (Arg *A = Args.getLastArg(options::OPT_mcompact_branches_EQ)) { 1610 StringRef Val = StringRef(A->getValue()); 1611 if (mips::hasCompactBranches(CPUName)) { 1612 if (Val == "never" || Val == "always" || Val == "optimal") { 1613 CmdArgs.push_back("-mllvm"); 1614 CmdArgs.push_back(Args.MakeArgString("-mips-compact-branches=" + Val)); 1615 } else 1616 D.Diag(diag::err_drv_unsupported_option_argument) 1617 << A->getOption().getName() << Val; 1618 } else 1619 D.Diag(diag::warn_target_unsupported_compact_branches) << CPUName; 1620 } 1621 } 1622 1623 void Clang::AddPPCTargetArgs(const ArgList &Args, 1624 ArgStringList &CmdArgs) const { 1625 // Select the ABI to use. 1626 const char *ABIName = nullptr; 1627 if (getToolChain().getTriple().isOSLinux()) 1628 switch (getToolChain().getArch()) { 1629 case llvm::Triple::ppc64: { 1630 // When targeting a processor that supports QPX, or if QPX is 1631 // specifically enabled, default to using the ABI that supports QPX (so 1632 // long as it is not specifically disabled). 1633 bool HasQPX = false; 1634 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) 1635 HasQPX = A->getValue() == StringRef("a2q"); 1636 HasQPX = Args.hasFlag(options::OPT_mqpx, options::OPT_mno_qpx, HasQPX); 1637 if (HasQPX) { 1638 ABIName = "elfv1-qpx"; 1639 break; 1640 } 1641 1642 ABIName = "elfv1"; 1643 break; 1644 } 1645 case llvm::Triple::ppc64le: 1646 ABIName = "elfv2"; 1647 break; 1648 default: 1649 break; 1650 } 1651 1652 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) 1653 // The ppc64 linux abis are all "altivec" abis by default. Accept and ignore 1654 // the option if given as we don't have backend support for any targets 1655 // that don't use the altivec abi. 1656 if (StringRef(A->getValue()) != "altivec") 1657 ABIName = A->getValue(); 1658 1659 ppc::FloatABI FloatABI = 1660 ppc::getPPCFloatABI(getToolChain().getDriver(), Args); 1661 1662 if (FloatABI == ppc::FloatABI::Soft) { 1663 // Floating point operations and argument passing are soft. 1664 CmdArgs.push_back("-msoft-float"); 1665 CmdArgs.push_back("-mfloat-abi"); 1666 CmdArgs.push_back("soft"); 1667 } else { 1668 // Floating point operations and argument passing are hard. 1669 assert(FloatABI == ppc::FloatABI::Hard && "Invalid float abi!"); 1670 CmdArgs.push_back("-mfloat-abi"); 1671 CmdArgs.push_back("hard"); 1672 } 1673 1674 if (ABIName) { 1675 CmdArgs.push_back("-target-abi"); 1676 CmdArgs.push_back(ABIName); 1677 } 1678 } 1679 1680 void Clang::AddRISCVTargetArgs(const ArgList &Args, 1681 ArgStringList &CmdArgs) const { 1682 // FIXME: currently defaults to the soft-float ABIs. Will need to be 1683 // expanded to select ilp32f, ilp32d, lp64f, lp64d when appropriate. 1684 const char *ABIName = nullptr; 1685 const llvm::Triple &Triple = getToolChain().getTriple(); 1686 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) 1687 ABIName = A->getValue(); 1688 else if (Triple.getArch() == llvm::Triple::riscv32) 1689 ABIName = "ilp32"; 1690 else if (Triple.getArch() == llvm::Triple::riscv64) 1691 ABIName = "lp64"; 1692 else 1693 llvm_unreachable("Unexpected triple!"); 1694 1695 CmdArgs.push_back("-target-abi"); 1696 CmdArgs.push_back(ABIName); 1697 } 1698 1699 void Clang::AddSparcTargetArgs(const ArgList &Args, 1700 ArgStringList &CmdArgs) const { 1701 sparc::FloatABI FloatABI = 1702 sparc::getSparcFloatABI(getToolChain().getDriver(), Args); 1703 1704 if (FloatABI == sparc::FloatABI::Soft) { 1705 // Floating point operations and argument passing are soft. 1706 CmdArgs.push_back("-msoft-float"); 1707 CmdArgs.push_back("-mfloat-abi"); 1708 CmdArgs.push_back("soft"); 1709 } else { 1710 // Floating point operations and argument passing are hard. 1711 assert(FloatABI == sparc::FloatABI::Hard && "Invalid float abi!"); 1712 CmdArgs.push_back("-mfloat-abi"); 1713 CmdArgs.push_back("hard"); 1714 } 1715 } 1716 1717 void Clang::AddSystemZTargetArgs(const ArgList &Args, 1718 ArgStringList &CmdArgs) const { 1719 if (Args.hasFlag(options::OPT_mbackchain, options::OPT_mno_backchain, false)) 1720 CmdArgs.push_back("-mbackchain"); 1721 } 1722 1723 void Clang::AddX86TargetArgs(const ArgList &Args, 1724 ArgStringList &CmdArgs) const { 1725 if (!Args.hasFlag(options::OPT_mred_zone, options::OPT_mno_red_zone, true) || 1726 Args.hasArg(options::OPT_mkernel) || 1727 Args.hasArg(options::OPT_fapple_kext)) 1728 CmdArgs.push_back("-disable-red-zone"); 1729 1730 // Default to avoid implicit floating-point for kernel/kext code, but allow 1731 // that to be overridden with -mno-soft-float. 1732 bool NoImplicitFloat = (Args.hasArg(options::OPT_mkernel) || 1733 Args.hasArg(options::OPT_fapple_kext)); 1734 if (Arg *A = Args.getLastArg( 1735 options::OPT_msoft_float, options::OPT_mno_soft_float, 1736 options::OPT_mimplicit_float, options::OPT_mno_implicit_float)) { 1737 const Option &O = A->getOption(); 1738 NoImplicitFloat = (O.matches(options::OPT_mno_implicit_float) || 1739 O.matches(options::OPT_msoft_float)); 1740 } 1741 if (NoImplicitFloat) 1742 CmdArgs.push_back("-no-implicit-float"); 1743 1744 if (Arg *A = Args.getLastArg(options::OPT_masm_EQ)) { 1745 StringRef Value = A->getValue(); 1746 if (Value == "intel" || Value == "att") { 1747 CmdArgs.push_back("-mllvm"); 1748 CmdArgs.push_back(Args.MakeArgString("-x86-asm-syntax=" + Value)); 1749 } else { 1750 getToolChain().getDriver().Diag(diag::err_drv_unsupported_option_argument) 1751 << A->getOption().getName() << Value; 1752 } 1753 } else if (getToolChain().getDriver().IsCLMode()) { 1754 CmdArgs.push_back("-mllvm"); 1755 CmdArgs.push_back("-x86-asm-syntax=intel"); 1756 } 1757 1758 // Set flags to support MCU ABI. 1759 if (Args.hasFlag(options::OPT_miamcu, options::OPT_mno_iamcu, false)) { 1760 CmdArgs.push_back("-mfloat-abi"); 1761 CmdArgs.push_back("soft"); 1762 CmdArgs.push_back("-mstack-alignment=4"); 1763 } 1764 } 1765 1766 void Clang::AddHexagonTargetArgs(const ArgList &Args, 1767 ArgStringList &CmdArgs) const { 1768 CmdArgs.push_back("-mqdsp6-compat"); 1769 CmdArgs.push_back("-Wreturn-type"); 1770 1771 if (auto G = toolchains::HexagonToolChain::getSmallDataThreshold(Args)) { 1772 CmdArgs.push_back("-mllvm"); 1773 CmdArgs.push_back(Args.MakeArgString("-hexagon-small-data-threshold=" + 1774 Twine(G.getValue()))); 1775 } 1776 1777 if (!Args.hasArg(options::OPT_fno_short_enums)) 1778 CmdArgs.push_back("-fshort-enums"); 1779 if (Args.getLastArg(options::OPT_mieee_rnd_near)) { 1780 CmdArgs.push_back("-mllvm"); 1781 CmdArgs.push_back("-enable-hexagon-ieee-rnd-near"); 1782 } 1783 CmdArgs.push_back("-mllvm"); 1784 CmdArgs.push_back("-machine-sink-split=0"); 1785 } 1786 1787 void Clang::AddLanaiTargetArgs(const ArgList &Args, 1788 ArgStringList &CmdArgs) const { 1789 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) { 1790 StringRef CPUName = A->getValue(); 1791 1792 CmdArgs.push_back("-target-cpu"); 1793 CmdArgs.push_back(Args.MakeArgString(CPUName)); 1794 } 1795 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) { 1796 StringRef Value = A->getValue(); 1797 // Only support mregparm=4 to support old usage. Report error for all other 1798 // cases. 1799 int Mregparm; 1800 if (Value.getAsInteger(10, Mregparm)) { 1801 if (Mregparm != 4) { 1802 getToolChain().getDriver().Diag( 1803 diag::err_drv_unsupported_option_argument) 1804 << A->getOption().getName() << Value; 1805 } 1806 } 1807 } 1808 } 1809 1810 void Clang::AddWebAssemblyTargetArgs(const ArgList &Args, 1811 ArgStringList &CmdArgs) const { 1812 // Default to "hidden" visibility. 1813 if (!Args.hasArg(options::OPT_fvisibility_EQ, 1814 options::OPT_fvisibility_ms_compat)) { 1815 CmdArgs.push_back("-fvisibility"); 1816 CmdArgs.push_back("hidden"); 1817 } 1818 } 1819 1820 void Clang::DumpCompilationDatabase(Compilation &C, StringRef Filename, 1821 StringRef Target, const InputInfo &Output, 1822 const InputInfo &Input, const ArgList &Args) const { 1823 // If this is a dry run, do not create the compilation database file. 1824 if (C.getArgs().hasArg(options::OPT__HASH_HASH_HASH)) 1825 return; 1826 1827 using llvm::yaml::escape; 1828 const Driver &D = getToolChain().getDriver(); 1829 1830 if (!CompilationDatabase) { 1831 std::error_code EC; 1832 auto File = llvm::make_unique<llvm::raw_fd_ostream>(Filename, EC, llvm::sys::fs::F_Text); 1833 if (EC) { 1834 D.Diag(clang::diag::err_drv_compilationdatabase) << Filename 1835 << EC.message(); 1836 return; 1837 } 1838 CompilationDatabase = std::move(File); 1839 } 1840 auto &CDB = *CompilationDatabase; 1841 SmallString<128> Buf; 1842 if (llvm::sys::fs::current_path(Buf)) 1843 Buf = "."; 1844 CDB << "{ \"directory\": \"" << escape(Buf) << "\""; 1845 CDB << ", \"file\": \"" << escape(Input.getFilename()) << "\""; 1846 CDB << ", \"output\": \"" << escape(Output.getFilename()) << "\""; 1847 CDB << ", \"arguments\": [\"" << escape(D.ClangExecutable) << "\""; 1848 Buf = "-x"; 1849 Buf += types::getTypeName(Input.getType()); 1850 CDB << ", \"" << escape(Buf) << "\""; 1851 if (!D.SysRoot.empty() && !Args.hasArg(options::OPT__sysroot_EQ)) { 1852 Buf = "--sysroot="; 1853 Buf += D.SysRoot; 1854 CDB << ", \"" << escape(Buf) << "\""; 1855 } 1856 CDB << ", \"" << escape(Input.getFilename()) << "\""; 1857 for (auto &A: Args) { 1858 auto &O = A->getOption(); 1859 // Skip language selection, which is positional. 1860 if (O.getID() == options::OPT_x) 1861 continue; 1862 // Skip writing dependency output and the compilation database itself. 1863 if (O.getGroup().isValid() && O.getGroup().getID() == options::OPT_M_Group) 1864 continue; 1865 // Skip inputs. 1866 if (O.getKind() == Option::InputClass) 1867 continue; 1868 // All other arguments are quoted and appended. 1869 ArgStringList ASL; 1870 A->render(Args, ASL); 1871 for (auto &it: ASL) 1872 CDB << ", \"" << escape(it) << "\""; 1873 } 1874 Buf = "--target="; 1875 Buf += Target; 1876 CDB << ", \"" << escape(Buf) << "\"]},\n"; 1877 } 1878 1879 static void CollectArgsForIntegratedAssembler(Compilation &C, 1880 const ArgList &Args, 1881 ArgStringList &CmdArgs, 1882 const Driver &D) { 1883 if (UseRelaxAll(C, Args)) 1884 CmdArgs.push_back("-mrelax-all"); 1885 1886 // Only default to -mincremental-linker-compatible if we think we are 1887 // targeting the MSVC linker. 1888 bool DefaultIncrementalLinkerCompatible = 1889 C.getDefaultToolChain().getTriple().isWindowsMSVCEnvironment(); 1890 if (Args.hasFlag(options::OPT_mincremental_linker_compatible, 1891 options::OPT_mno_incremental_linker_compatible, 1892 DefaultIncrementalLinkerCompatible)) 1893 CmdArgs.push_back("-mincremental-linker-compatible"); 1894 1895 switch (C.getDefaultToolChain().getArch()) { 1896 case llvm::Triple::arm: 1897 case llvm::Triple::armeb: 1898 case llvm::Triple::thumb: 1899 case llvm::Triple::thumbeb: 1900 if (Arg *A = Args.getLastArg(options::OPT_mimplicit_it_EQ)) { 1901 StringRef Value = A->getValue(); 1902 if (Value == "always" || Value == "never" || Value == "arm" || 1903 Value == "thumb") { 1904 CmdArgs.push_back("-mllvm"); 1905 CmdArgs.push_back(Args.MakeArgString("-arm-implicit-it=" + Value)); 1906 } else { 1907 D.Diag(diag::err_drv_unsupported_option_argument) 1908 << A->getOption().getName() << Value; 1909 } 1910 } 1911 break; 1912 default: 1913 break; 1914 } 1915 1916 // When passing -I arguments to the assembler we sometimes need to 1917 // unconditionally take the next argument. For example, when parsing 1918 // '-Wa,-I -Wa,foo' we need to accept the -Wa,foo arg after seeing the 1919 // -Wa,-I arg and when parsing '-Wa,-I,foo' we need to accept the 'foo' 1920 // arg after parsing the '-I' arg. 1921 bool TakeNextArg = false; 1922 1923 bool UseRelaxRelocations = C.getDefaultToolChain().useRelaxRelocations(); 1924 const char *MipsTargetFeature = nullptr; 1925 for (const Arg *A : 1926 Args.filtered(options::OPT_Wa_COMMA, options::OPT_Xassembler)) { 1927 A->claim(); 1928 1929 for (StringRef Value : A->getValues()) { 1930 if (TakeNextArg) { 1931 CmdArgs.push_back(Value.data()); 1932 TakeNextArg = false; 1933 continue; 1934 } 1935 1936 if (C.getDefaultToolChain().getTriple().isOSBinFormatCOFF() && 1937 Value == "-mbig-obj") 1938 continue; // LLVM handles bigobj automatically 1939 1940 switch (C.getDefaultToolChain().getArch()) { 1941 default: 1942 break; 1943 case llvm::Triple::thumb: 1944 case llvm::Triple::thumbeb: 1945 case llvm::Triple::arm: 1946 case llvm::Triple::armeb: 1947 if (Value == "-mthumb") 1948 // -mthumb has already been processed in ComputeLLVMTriple() 1949 // recognize but skip over here. 1950 continue; 1951 break; 1952 case llvm::Triple::mips: 1953 case llvm::Triple::mipsel: 1954 case llvm::Triple::mips64: 1955 case llvm::Triple::mips64el: 1956 if (Value == "--trap") { 1957 CmdArgs.push_back("-target-feature"); 1958 CmdArgs.push_back("+use-tcc-in-div"); 1959 continue; 1960 } 1961 if (Value == "--break") { 1962 CmdArgs.push_back("-target-feature"); 1963 CmdArgs.push_back("-use-tcc-in-div"); 1964 continue; 1965 } 1966 if (Value.startswith("-msoft-float")) { 1967 CmdArgs.push_back("-target-feature"); 1968 CmdArgs.push_back("+soft-float"); 1969 continue; 1970 } 1971 if (Value.startswith("-mhard-float")) { 1972 CmdArgs.push_back("-target-feature"); 1973 CmdArgs.push_back("-soft-float"); 1974 continue; 1975 } 1976 1977 MipsTargetFeature = llvm::StringSwitch<const char *>(Value) 1978 .Case("-mips1", "+mips1") 1979 .Case("-mips2", "+mips2") 1980 .Case("-mips3", "+mips3") 1981 .Case("-mips4", "+mips4") 1982 .Case("-mips5", "+mips5") 1983 .Case("-mips32", "+mips32") 1984 .Case("-mips32r2", "+mips32r2") 1985 .Case("-mips32r3", "+mips32r3") 1986 .Case("-mips32r5", "+mips32r5") 1987 .Case("-mips32r6", "+mips32r6") 1988 .Case("-mips64", "+mips64") 1989 .Case("-mips64r2", "+mips64r2") 1990 .Case("-mips64r3", "+mips64r3") 1991 .Case("-mips64r5", "+mips64r5") 1992 .Case("-mips64r6", "+mips64r6") 1993 .Default(nullptr); 1994 if (MipsTargetFeature) 1995 continue; 1996 } 1997 1998 if (Value == "-force_cpusubtype_ALL") { 1999 // Do nothing, this is the default and we don't support anything else. 2000 } else if (Value == "-L") { 2001 CmdArgs.push_back("-msave-temp-labels"); 2002 } else if (Value == "--fatal-warnings") { 2003 CmdArgs.push_back("-massembler-fatal-warnings"); 2004 } else if (Value == "--noexecstack") { 2005 CmdArgs.push_back("-mnoexecstack"); 2006 } else if (Value.startswith("-compress-debug-sections") || 2007 Value.startswith("--compress-debug-sections") || 2008 Value == "-nocompress-debug-sections" || 2009 Value == "--nocompress-debug-sections") { 2010 CmdArgs.push_back(Value.data()); 2011 } else if (Value == "-mrelax-relocations=yes" || 2012 Value == "--mrelax-relocations=yes") { 2013 UseRelaxRelocations = true; 2014 } else if (Value == "-mrelax-relocations=no" || 2015 Value == "--mrelax-relocations=no") { 2016 UseRelaxRelocations = false; 2017 } else if (Value.startswith("-I")) { 2018 CmdArgs.push_back(Value.data()); 2019 // We need to consume the next argument if the current arg is a plain 2020 // -I. The next arg will be the include directory. 2021 if (Value == "-I") 2022 TakeNextArg = true; 2023 } else if (Value.startswith("-gdwarf-")) { 2024 // "-gdwarf-N" options are not cc1as options. 2025 unsigned DwarfVersion = DwarfVersionNum(Value); 2026 if (DwarfVersion == 0) { // Send it onward, and let cc1as complain. 2027 CmdArgs.push_back(Value.data()); 2028 } else { 2029 RenderDebugEnablingArgs(Args, CmdArgs, 2030 codegenoptions::LimitedDebugInfo, 2031 DwarfVersion, llvm::DebuggerKind::Default); 2032 } 2033 } else if (Value.startswith("-mcpu") || Value.startswith("-mfpu") || 2034 Value.startswith("-mhwdiv") || Value.startswith("-march")) { 2035 // Do nothing, we'll validate it later. 2036 } else if (Value == "-defsym") { 2037 if (A->getNumValues() != 2) { 2038 D.Diag(diag::err_drv_defsym_invalid_format) << Value; 2039 break; 2040 } 2041 const char *S = A->getValue(1); 2042 auto Pair = StringRef(S).split('='); 2043 auto Sym = Pair.first; 2044 auto SVal = Pair.second; 2045 2046 if (Sym.empty() || SVal.empty()) { 2047 D.Diag(diag::err_drv_defsym_invalid_format) << S; 2048 break; 2049 } 2050 int64_t IVal; 2051 if (SVal.getAsInteger(0, IVal)) { 2052 D.Diag(diag::err_drv_defsym_invalid_symval) << SVal; 2053 break; 2054 } 2055 CmdArgs.push_back(Value.data()); 2056 TakeNextArg = true; 2057 } else { 2058 D.Diag(diag::err_drv_unsupported_option_argument) 2059 << A->getOption().getName() << Value; 2060 } 2061 } 2062 } 2063 if (UseRelaxRelocations) 2064 CmdArgs.push_back("--mrelax-relocations"); 2065 if (MipsTargetFeature != nullptr) { 2066 CmdArgs.push_back("-target-feature"); 2067 CmdArgs.push_back(MipsTargetFeature); 2068 } 2069 } 2070 2071 static void RenderFloatingPointOptions(const ToolChain &TC, const Driver &D, 2072 bool OFastEnabled, const ArgList &Args, 2073 ArgStringList &CmdArgs) { 2074 // Handle various floating point optimization flags, mapping them to the 2075 // appropriate LLVM code generation flags. This is complicated by several 2076 // "umbrella" flags, so we do this by stepping through the flags incrementally 2077 // adjusting what we think is enabled/disabled, then at the end setting the 2078 // LLVM flags based on the final state. 2079 bool HonorINFs = true; 2080 bool HonorNaNs = true; 2081 // -fmath-errno is the default on some platforms, e.g. BSD-derived OSes. 2082 bool MathErrno = TC.IsMathErrnoDefault(); 2083 bool AssociativeMath = false; 2084 bool ReciprocalMath = false; 2085 bool SignedZeros = true; 2086 bool TrappingMath = true; 2087 StringRef DenormalFPMath = ""; 2088 StringRef FPContract = ""; 2089 2090 for (const Arg *A : Args) { 2091 switch (A->getOption().getID()) { 2092 // If this isn't an FP option skip the claim below 2093 default: continue; 2094 2095 // Options controlling individual features 2096 case options::OPT_fhonor_infinities: HonorINFs = true; break; 2097 case options::OPT_fno_honor_infinities: HonorINFs = false; break; 2098 case options::OPT_fhonor_nans: HonorNaNs = true; break; 2099 case options::OPT_fno_honor_nans: HonorNaNs = false; break; 2100 case options::OPT_fmath_errno: MathErrno = true; break; 2101 case options::OPT_fno_math_errno: MathErrno = false; break; 2102 case options::OPT_fassociative_math: AssociativeMath = true; break; 2103 case options::OPT_fno_associative_math: AssociativeMath = false; break; 2104 case options::OPT_freciprocal_math: ReciprocalMath = true; break; 2105 case options::OPT_fno_reciprocal_math: ReciprocalMath = false; break; 2106 case options::OPT_fsigned_zeros: SignedZeros = true; break; 2107 case options::OPT_fno_signed_zeros: SignedZeros = false; break; 2108 case options::OPT_ftrapping_math: TrappingMath = true; break; 2109 case options::OPT_fno_trapping_math: TrappingMath = false; break; 2110 2111 case options::OPT_fdenormal_fp_math_EQ: 2112 DenormalFPMath = A->getValue(); 2113 break; 2114 2115 // Validate and pass through -fp-contract option. 2116 case options::OPT_ffp_contract: { 2117 StringRef Val = A->getValue(); 2118 if (Val == "fast" || Val == "on" || Val == "off") 2119 FPContract = Val; 2120 else 2121 D.Diag(diag::err_drv_unsupported_option_argument) 2122 << A->getOption().getName() << Val; 2123 break; 2124 } 2125 2126 case options::OPT_ffinite_math_only: 2127 HonorINFs = false; 2128 HonorNaNs = false; 2129 break; 2130 case options::OPT_fno_finite_math_only: 2131 HonorINFs = true; 2132 HonorNaNs = true; 2133 break; 2134 2135 case options::OPT_funsafe_math_optimizations: 2136 AssociativeMath = true; 2137 ReciprocalMath = true; 2138 SignedZeros = false; 2139 TrappingMath = false; 2140 break; 2141 case options::OPT_fno_unsafe_math_optimizations: 2142 AssociativeMath = false; 2143 ReciprocalMath = false; 2144 SignedZeros = true; 2145 TrappingMath = true; 2146 // -fno_unsafe_math_optimizations restores default denormal handling 2147 DenormalFPMath = ""; 2148 break; 2149 2150 case options::OPT_Ofast: 2151 // If -Ofast is the optimization level, then -ffast-math should be enabled 2152 if (!OFastEnabled) 2153 continue; 2154 LLVM_FALLTHROUGH; 2155 case options::OPT_ffast_math: 2156 HonorINFs = false; 2157 HonorNaNs = false; 2158 MathErrno = false; 2159 AssociativeMath = true; 2160 ReciprocalMath = true; 2161 SignedZeros = false; 2162 TrappingMath = false; 2163 // If fast-math is set then set the fp-contract mode to fast. 2164 FPContract = "fast"; 2165 break; 2166 case options::OPT_fno_fast_math: 2167 HonorINFs = true; 2168 HonorNaNs = true; 2169 // Turning on -ffast-math (with either flag) removes the need for 2170 // MathErrno. However, turning *off* -ffast-math merely restores the 2171 // toolchain default (which may be false). 2172 MathErrno = TC.IsMathErrnoDefault(); 2173 AssociativeMath = false; 2174 ReciprocalMath = false; 2175 SignedZeros = true; 2176 TrappingMath = true; 2177 // -fno_fast_math restores default denormal and fpcontract handling 2178 DenormalFPMath = ""; 2179 FPContract = ""; 2180 break; 2181 } 2182 2183 // If we handled this option claim it 2184 A->claim(); 2185 } 2186 2187 if (!HonorINFs) 2188 CmdArgs.push_back("-menable-no-infs"); 2189 2190 if (!HonorNaNs) 2191 CmdArgs.push_back("-menable-no-nans"); 2192 2193 if (MathErrno) 2194 CmdArgs.push_back("-fmath-errno"); 2195 2196 if (!MathErrno && AssociativeMath && ReciprocalMath && !SignedZeros && 2197 !TrappingMath) 2198 CmdArgs.push_back("-menable-unsafe-fp-math"); 2199 2200 if (!SignedZeros) 2201 CmdArgs.push_back("-fno-signed-zeros"); 2202 2203 if (AssociativeMath && !SignedZeros && !TrappingMath) 2204 CmdArgs.push_back("-mreassociate"); 2205 2206 if (ReciprocalMath) 2207 CmdArgs.push_back("-freciprocal-math"); 2208 2209 if (!TrappingMath) 2210 CmdArgs.push_back("-fno-trapping-math"); 2211 2212 if (!DenormalFPMath.empty()) 2213 CmdArgs.push_back( 2214 Args.MakeArgString("-fdenormal-fp-math=" + DenormalFPMath)); 2215 2216 if (!FPContract.empty()) 2217 CmdArgs.push_back(Args.MakeArgString("-ffp-contract=" + FPContract)); 2218 2219 ParseMRecip(D, Args, CmdArgs); 2220 2221 // -ffast-math enables the __FAST_MATH__ preprocessor macro, but check for the 2222 // individual features enabled by -ffast-math instead of the option itself as 2223 // that's consistent with gcc's behaviour. 2224 if (!HonorINFs && !HonorNaNs && !MathErrno && AssociativeMath && 2225 ReciprocalMath && !SignedZeros && !TrappingMath) 2226 CmdArgs.push_back("-ffast-math"); 2227 2228 // Handle __FINITE_MATH_ONLY__ similarly. 2229 if (!HonorINFs && !HonorNaNs) 2230 CmdArgs.push_back("-ffinite-math-only"); 2231 2232 if (const Arg *A = Args.getLastArg(options::OPT_mfpmath_EQ)) { 2233 CmdArgs.push_back("-mfpmath"); 2234 CmdArgs.push_back(A->getValue()); 2235 } 2236 2237 // Disable a codegen optimization for floating-point casts. 2238 if (Args.hasFlag(options::OPT_fno_strict_float_cast_overflow, 2239 options::OPT_fstrict_float_cast_overflow, false)) 2240 CmdArgs.push_back("-fno-strict-float-cast-overflow"); 2241 } 2242 2243 static void RenderAnalyzerOptions(const ArgList &Args, ArgStringList &CmdArgs, 2244 const llvm::Triple &Triple, 2245 const InputInfo &Input) { 2246 // Enable region store model by default. 2247 CmdArgs.push_back("-analyzer-store=region"); 2248 2249 // Treat blocks as analysis entry points. 2250 CmdArgs.push_back("-analyzer-opt-analyze-nested-blocks"); 2251 2252 CmdArgs.push_back("-analyzer-eagerly-assume"); 2253 2254 // Add default argument set. 2255 if (!Args.hasArg(options::OPT__analyzer_no_default_checks)) { 2256 CmdArgs.push_back("-analyzer-checker=core"); 2257 CmdArgs.push_back("-analyzer-checker=apiModeling"); 2258 2259 if (!Triple.isWindowsMSVCEnvironment()) { 2260 CmdArgs.push_back("-analyzer-checker=unix"); 2261 } else { 2262 // Enable "unix" checkers that also work on Windows. 2263 CmdArgs.push_back("-analyzer-checker=unix.API"); 2264 CmdArgs.push_back("-analyzer-checker=unix.Malloc"); 2265 CmdArgs.push_back("-analyzer-checker=unix.MallocSizeof"); 2266 CmdArgs.push_back("-analyzer-checker=unix.MismatchedDeallocator"); 2267 CmdArgs.push_back("-analyzer-checker=unix.cstring.BadSizeArg"); 2268 CmdArgs.push_back("-analyzer-checker=unix.cstring.NullArg"); 2269 } 2270 2271 // Disable some unix checkers for PS4. 2272 if (Triple.isPS4CPU()) { 2273 CmdArgs.push_back("-analyzer-disable-checker=unix.API"); 2274 CmdArgs.push_back("-analyzer-disable-checker=unix.Vfork"); 2275 } 2276 2277 if (Triple.isOSDarwin()) 2278 CmdArgs.push_back("-analyzer-checker=osx"); 2279 2280 CmdArgs.push_back("-analyzer-checker=deadcode"); 2281 2282 if (types::isCXX(Input.getType())) 2283 CmdArgs.push_back("-analyzer-checker=cplusplus"); 2284 2285 if (!Triple.isPS4CPU()) { 2286 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.UncheckedReturn"); 2287 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.getpw"); 2288 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.gets"); 2289 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mktemp"); 2290 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mkstemp"); 2291 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.vfork"); 2292 } 2293 2294 // Default nullability checks. 2295 CmdArgs.push_back("-analyzer-checker=nullability.NullPassedToNonnull"); 2296 CmdArgs.push_back("-analyzer-checker=nullability.NullReturnedFromNonnull"); 2297 } 2298 2299 // Set the output format. The default is plist, for (lame) historical reasons. 2300 CmdArgs.push_back("-analyzer-output"); 2301 if (Arg *A = Args.getLastArg(options::OPT__analyzer_output)) 2302 CmdArgs.push_back(A->getValue()); 2303 else 2304 CmdArgs.push_back("plist"); 2305 2306 // Disable the presentation of standard compiler warnings when using 2307 // --analyze. We only want to show static analyzer diagnostics or frontend 2308 // errors. 2309 CmdArgs.push_back("-w"); 2310 2311 // Add -Xanalyzer arguments when running as analyzer. 2312 Args.AddAllArgValues(CmdArgs, options::OPT_Xanalyzer); 2313 } 2314 2315 static void RenderSSPOptions(const ToolChain &TC, const ArgList &Args, 2316 ArgStringList &CmdArgs, bool KernelOrKext) { 2317 const llvm::Triple &EffectiveTriple = TC.getEffectiveTriple(); 2318 2319 // NVPTX doesn't support stack protectors; from the compiler's perspective, it 2320 // doesn't even have a stack! 2321 if (EffectiveTriple.isNVPTX()) 2322 return; 2323 2324 // -stack-protector=0 is default. 2325 unsigned StackProtectorLevel = 0; 2326 unsigned DefaultStackProtectorLevel = 2327 TC.GetDefaultStackProtectorLevel(KernelOrKext); 2328 2329 if (Arg *A = Args.getLastArg(options::OPT_fno_stack_protector, 2330 options::OPT_fstack_protector_all, 2331 options::OPT_fstack_protector_strong, 2332 options::OPT_fstack_protector)) { 2333 if (A->getOption().matches(options::OPT_fstack_protector)) 2334 StackProtectorLevel = 2335 std::max<unsigned>(LangOptions::SSPOn, DefaultStackProtectorLevel); 2336 else if (A->getOption().matches(options::OPT_fstack_protector_strong)) 2337 StackProtectorLevel = LangOptions::SSPStrong; 2338 else if (A->getOption().matches(options::OPT_fstack_protector_all)) 2339 StackProtectorLevel = LangOptions::SSPReq; 2340 } else { 2341 StackProtectorLevel = DefaultStackProtectorLevel; 2342 } 2343 2344 if (StackProtectorLevel) { 2345 CmdArgs.push_back("-stack-protector"); 2346 CmdArgs.push_back(Args.MakeArgString(Twine(StackProtectorLevel))); 2347 } 2348 2349 // --param ssp-buffer-size= 2350 for (const Arg *A : Args.filtered(options::OPT__param)) { 2351 StringRef Str(A->getValue()); 2352 if (Str.startswith("ssp-buffer-size=")) { 2353 if (StackProtectorLevel) { 2354 CmdArgs.push_back("-stack-protector-buffer-size"); 2355 // FIXME: Verify the argument is a valid integer. 2356 CmdArgs.push_back(Args.MakeArgString(Str.drop_front(16))); 2357 } 2358 A->claim(); 2359 } 2360 } 2361 } 2362 2363 static void RenderOpenCLOptions(const ArgList &Args, ArgStringList &CmdArgs) { 2364 const unsigned ForwardedArguments[] = { 2365 options::OPT_cl_opt_disable, 2366 options::OPT_cl_strict_aliasing, 2367 options::OPT_cl_single_precision_constant, 2368 options::OPT_cl_finite_math_only, 2369 options::OPT_cl_kernel_arg_info, 2370 options::OPT_cl_unsafe_math_optimizations, 2371 options::OPT_cl_fast_relaxed_math, 2372 options::OPT_cl_mad_enable, 2373 options::OPT_cl_no_signed_zeros, 2374 options::OPT_cl_denorms_are_zero, 2375 options::OPT_cl_fp32_correctly_rounded_divide_sqrt, 2376 options::OPT_cl_uniform_work_group_size 2377 }; 2378 2379 if (Arg *A = Args.getLastArg(options::OPT_cl_std_EQ)) { 2380 std::string CLStdStr = std::string("-cl-std=") + A->getValue(); 2381 CmdArgs.push_back(Args.MakeArgString(CLStdStr)); 2382 } 2383 2384 for (const auto &Arg : ForwardedArguments) 2385 if (const auto *A = Args.getLastArg(Arg)) 2386 CmdArgs.push_back(Args.MakeArgString(A->getOption().getPrefixedName())); 2387 } 2388 2389 static void RenderARCMigrateToolOptions(const Driver &D, const ArgList &Args, 2390 ArgStringList &CmdArgs) { 2391 bool ARCMTEnabled = false; 2392 if (!Args.hasArg(options::OPT_fno_objc_arc, options::OPT_fobjc_arc)) { 2393 if (const Arg *A = Args.getLastArg(options::OPT_ccc_arcmt_check, 2394 options::OPT_ccc_arcmt_modify, 2395 options::OPT_ccc_arcmt_migrate)) { 2396 ARCMTEnabled = true; 2397 switch (A->getOption().getID()) { 2398 default: llvm_unreachable("missed a case"); 2399 case options::OPT_ccc_arcmt_check: 2400 CmdArgs.push_back("-arcmt-check"); 2401 break; 2402 case options::OPT_ccc_arcmt_modify: 2403 CmdArgs.push_back("-arcmt-modify"); 2404 break; 2405 case options::OPT_ccc_arcmt_migrate: 2406 CmdArgs.push_back("-arcmt-migrate"); 2407 CmdArgs.push_back("-mt-migrate-directory"); 2408 CmdArgs.push_back(A->getValue()); 2409 2410 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_report_output); 2411 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_emit_arc_errors); 2412 break; 2413 } 2414 } 2415 } else { 2416 Args.ClaimAllArgs(options::OPT_ccc_arcmt_check); 2417 Args.ClaimAllArgs(options::OPT_ccc_arcmt_modify); 2418 Args.ClaimAllArgs(options::OPT_ccc_arcmt_migrate); 2419 } 2420 2421 if (const Arg *A = Args.getLastArg(options::OPT_ccc_objcmt_migrate)) { 2422 if (ARCMTEnabled) 2423 D.Diag(diag::err_drv_argument_not_allowed_with) 2424 << A->getAsString(Args) << "-ccc-arcmt-migrate"; 2425 2426 CmdArgs.push_back("-mt-migrate-directory"); 2427 CmdArgs.push_back(A->getValue()); 2428 2429 if (!Args.hasArg(options::OPT_objcmt_migrate_literals, 2430 options::OPT_objcmt_migrate_subscripting, 2431 options::OPT_objcmt_migrate_property)) { 2432 // None specified, means enable them all. 2433 CmdArgs.push_back("-objcmt-migrate-literals"); 2434 CmdArgs.push_back("-objcmt-migrate-subscripting"); 2435 CmdArgs.push_back("-objcmt-migrate-property"); 2436 } else { 2437 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals); 2438 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting); 2439 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property); 2440 } 2441 } else { 2442 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals); 2443 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting); 2444 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property); 2445 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_all); 2446 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readonly_property); 2447 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readwrite_property); 2448 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property_dot_syntax); 2449 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_annotation); 2450 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_instancetype); 2451 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_nsmacros); 2452 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_protocol_conformance); 2453 Args.AddLastArg(CmdArgs, options::OPT_objcmt_atomic_property); 2454 Args.AddLastArg(CmdArgs, options::OPT_objcmt_returns_innerpointer_property); 2455 Args.AddLastArg(CmdArgs, options::OPT_objcmt_ns_nonatomic_iosonly); 2456 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_designated_init); 2457 Args.AddLastArg(CmdArgs, options::OPT_objcmt_whitelist_dir_path); 2458 } 2459 } 2460 2461 static void RenderBuiltinOptions(const ToolChain &TC, const llvm::Triple &T, 2462 const ArgList &Args, ArgStringList &CmdArgs) { 2463 // -fbuiltin is default unless -mkernel is used. 2464 bool UseBuiltins = 2465 Args.hasFlag(options::OPT_fbuiltin, options::OPT_fno_builtin, 2466 !Args.hasArg(options::OPT_mkernel)); 2467 if (!UseBuiltins) 2468 CmdArgs.push_back("-fno-builtin"); 2469 2470 // -ffreestanding implies -fno-builtin. 2471 if (Args.hasArg(options::OPT_ffreestanding)) 2472 UseBuiltins = false; 2473 2474 // Process the -fno-builtin-* options. 2475 for (const auto &Arg : Args) { 2476 const Option &O = Arg->getOption(); 2477 if (!O.matches(options::OPT_fno_builtin_)) 2478 continue; 2479 2480 Arg->claim(); 2481 2482 // If -fno-builtin is specified, then there's no need to pass the option to 2483 // the frontend. 2484 if (!UseBuiltins) 2485 continue; 2486 2487 StringRef FuncName = Arg->getValue(); 2488 CmdArgs.push_back(Args.MakeArgString("-fno-builtin-" + FuncName)); 2489 } 2490 2491 // le32-specific flags: 2492 // -fno-math-builtin: clang should not convert math builtins to intrinsics 2493 // by default. 2494 if (TC.getArch() == llvm::Triple::le32) 2495 CmdArgs.push_back("-fno-math-builtin"); 2496 } 2497 2498 void Driver::getDefaultModuleCachePath(SmallVectorImpl<char> &Result) { 2499 llvm::sys::path::system_temp_directory(/*erasedOnReboot=*/false, Result); 2500 llvm::sys::path::append(Result, "org.llvm.clang."); 2501 appendUserToPath(Result); 2502 llvm::sys::path::append(Result, "ModuleCache"); 2503 } 2504 2505 static void RenderModulesOptions(Compilation &C, const Driver &D, 2506 const ArgList &Args, const InputInfo &Input, 2507 const InputInfo &Output, 2508 ArgStringList &CmdArgs, bool &HaveModules) { 2509 // -fmodules enables the use of precompiled modules (off by default). 2510 // Users can pass -fno-cxx-modules to turn off modules support for 2511 // C++/Objective-C++ programs. 2512 bool HaveClangModules = false; 2513 if (Args.hasFlag(options::OPT_fmodules, options::OPT_fno_modules, false)) { 2514 bool AllowedInCXX = Args.hasFlag(options::OPT_fcxx_modules, 2515 options::OPT_fno_cxx_modules, true); 2516 if (AllowedInCXX || !types::isCXX(Input.getType())) { 2517 CmdArgs.push_back("-fmodules"); 2518 HaveClangModules = true; 2519 } 2520 } 2521 2522 HaveModules = HaveClangModules; 2523 if (Args.hasArg(options::OPT_fmodules_ts)) { 2524 CmdArgs.push_back("-fmodules-ts"); 2525 HaveModules = true; 2526 } 2527 2528 // -fmodule-maps enables implicit reading of module map files. By default, 2529 // this is enabled if we are using Clang's flavor of precompiled modules. 2530 if (Args.hasFlag(options::OPT_fimplicit_module_maps, 2531 options::OPT_fno_implicit_module_maps, HaveClangModules)) 2532 CmdArgs.push_back("-fimplicit-module-maps"); 2533 2534 // -fmodules-decluse checks that modules used are declared so (off by default) 2535 if (Args.hasFlag(options::OPT_fmodules_decluse, 2536 options::OPT_fno_modules_decluse, false)) 2537 CmdArgs.push_back("-fmodules-decluse"); 2538 2539 // -fmodules-strict-decluse is like -fmodule-decluse, but also checks that 2540 // all #included headers are part of modules. 2541 if (Args.hasFlag(options::OPT_fmodules_strict_decluse, 2542 options::OPT_fno_modules_strict_decluse, false)) 2543 CmdArgs.push_back("-fmodules-strict-decluse"); 2544 2545 // -fno-implicit-modules turns off implicitly compiling modules on demand. 2546 bool ImplicitModules = false; 2547 if (!Args.hasFlag(options::OPT_fimplicit_modules, 2548 options::OPT_fno_implicit_modules, HaveClangModules)) { 2549 if (HaveModules) 2550 CmdArgs.push_back("-fno-implicit-modules"); 2551 } else if (HaveModules) { 2552 ImplicitModules = true; 2553 // -fmodule-cache-path specifies where our implicitly-built module files 2554 // should be written. 2555 SmallString<128> Path; 2556 if (Arg *A = Args.getLastArg(options::OPT_fmodules_cache_path)) 2557 Path = A->getValue(); 2558 2559 if (C.isForDiagnostics()) { 2560 // When generating crash reports, we want to emit the modules along with 2561 // the reproduction sources, so we ignore any provided module path. 2562 Path = Output.getFilename(); 2563 llvm::sys::path::replace_extension(Path, ".cache"); 2564 llvm::sys::path::append(Path, "modules"); 2565 } else if (Path.empty()) { 2566 // No module path was provided: use the default. 2567 Driver::getDefaultModuleCachePath(Path); 2568 } 2569 2570 const char Arg[] = "-fmodules-cache-path="; 2571 Path.insert(Path.begin(), Arg, Arg + strlen(Arg)); 2572 CmdArgs.push_back(Args.MakeArgString(Path)); 2573 } 2574 2575 if (HaveModules) { 2576 // -fprebuilt-module-path specifies where to load the prebuilt module files. 2577 for (const Arg *A : Args.filtered(options::OPT_fprebuilt_module_path)) { 2578 CmdArgs.push_back(Args.MakeArgString( 2579 std::string("-fprebuilt-module-path=") + A->getValue())); 2580 A->claim(); 2581 } 2582 } 2583 2584 // -fmodule-name specifies the module that is currently being built (or 2585 // used for header checking by -fmodule-maps). 2586 Args.AddLastArg(CmdArgs, options::OPT_fmodule_name_EQ); 2587 2588 // -fmodule-map-file can be used to specify files containing module 2589 // definitions. 2590 Args.AddAllArgs(CmdArgs, options::OPT_fmodule_map_file); 2591 2592 // -fbuiltin-module-map can be used to load the clang 2593 // builtin headers modulemap file. 2594 if (Args.hasArg(options::OPT_fbuiltin_module_map)) { 2595 SmallString<128> BuiltinModuleMap(D.ResourceDir); 2596 llvm::sys::path::append(BuiltinModuleMap, "include"); 2597 llvm::sys::path::append(BuiltinModuleMap, "module.modulemap"); 2598 if (llvm::sys::fs::exists(BuiltinModuleMap)) 2599 CmdArgs.push_back( 2600 Args.MakeArgString("-fmodule-map-file=" + BuiltinModuleMap)); 2601 } 2602 2603 // The -fmodule-file=<name>=<file> form specifies the mapping of module 2604 // names to precompiled module files (the module is loaded only if used). 2605 // The -fmodule-file=<file> form can be used to unconditionally load 2606 // precompiled module files (whether used or not). 2607 if (HaveModules) 2608 Args.AddAllArgs(CmdArgs, options::OPT_fmodule_file); 2609 else 2610 Args.ClaimAllArgs(options::OPT_fmodule_file); 2611 2612 // When building modules and generating crashdumps, we need to dump a module 2613 // dependency VFS alongside the output. 2614 if (HaveClangModules && C.isForDiagnostics()) { 2615 SmallString<128> VFSDir(Output.getFilename()); 2616 llvm::sys::path::replace_extension(VFSDir, ".cache"); 2617 // Add the cache directory as a temp so the crash diagnostics pick it up. 2618 C.addTempFile(Args.MakeArgString(VFSDir)); 2619 2620 llvm::sys::path::append(VFSDir, "vfs"); 2621 CmdArgs.push_back("-module-dependency-dir"); 2622 CmdArgs.push_back(Args.MakeArgString(VFSDir)); 2623 } 2624 2625 if (HaveClangModules) 2626 Args.AddLastArg(CmdArgs, options::OPT_fmodules_user_build_path); 2627 2628 // Pass through all -fmodules-ignore-macro arguments. 2629 Args.AddAllArgs(CmdArgs, options::OPT_fmodules_ignore_macro); 2630 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_interval); 2631 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_after); 2632 2633 Args.AddLastArg(CmdArgs, options::OPT_fbuild_session_timestamp); 2634 2635 if (Arg *A = Args.getLastArg(options::OPT_fbuild_session_file)) { 2636 if (Args.hasArg(options::OPT_fbuild_session_timestamp)) 2637 D.Diag(diag::err_drv_argument_not_allowed_with) 2638 << A->getAsString(Args) << "-fbuild-session-timestamp"; 2639 2640 llvm::sys::fs::file_status Status; 2641 if (llvm::sys::fs::status(A->getValue(), Status)) 2642 D.Diag(diag::err_drv_no_such_file) << A->getValue(); 2643 CmdArgs.push_back( 2644 Args.MakeArgString("-fbuild-session-timestamp=" + 2645 Twine((uint64_t)Status.getLastModificationTime() 2646 .time_since_epoch() 2647 .count()))); 2648 } 2649 2650 if (Args.getLastArg(options::OPT_fmodules_validate_once_per_build_session)) { 2651 if (!Args.getLastArg(options::OPT_fbuild_session_timestamp, 2652 options::OPT_fbuild_session_file)) 2653 D.Diag(diag::err_drv_modules_validate_once_requires_timestamp); 2654 2655 Args.AddLastArg(CmdArgs, 2656 options::OPT_fmodules_validate_once_per_build_session); 2657 } 2658 2659 if (Args.hasFlag(options::OPT_fmodules_validate_system_headers, 2660 options::OPT_fno_modules_validate_system_headers, 2661 ImplicitModules)) 2662 CmdArgs.push_back("-fmodules-validate-system-headers"); 2663 2664 Args.AddLastArg(CmdArgs, options::OPT_fmodules_disable_diagnostic_validation); 2665 } 2666 2667 static void RenderCharacterOptions(const ArgList &Args, const llvm::Triple &T, 2668 ArgStringList &CmdArgs) { 2669 // -fsigned-char is default. 2670 if (const Arg *A = Args.getLastArg(options::OPT_fsigned_char, 2671 options::OPT_fno_signed_char, 2672 options::OPT_funsigned_char, 2673 options::OPT_fno_unsigned_char)) { 2674 if (A->getOption().matches(options::OPT_funsigned_char) || 2675 A->getOption().matches(options::OPT_fno_signed_char)) { 2676 CmdArgs.push_back("-fno-signed-char"); 2677 } 2678 } else if (!isSignedCharDefault(T)) { 2679 CmdArgs.push_back("-fno-signed-char"); 2680 } 2681 2682 if (Args.hasFlag(options::OPT_fchar8__t, options::OPT_fno_char8__t, false)) 2683 CmdArgs.push_back("-fchar8_t"); 2684 2685 if (const Arg *A = Args.getLastArg(options::OPT_fshort_wchar, 2686 options::OPT_fno_short_wchar)) { 2687 if (A->getOption().matches(options::OPT_fshort_wchar)) { 2688 CmdArgs.push_back("-fwchar-type=short"); 2689 CmdArgs.push_back("-fno-signed-wchar"); 2690 } else { 2691 bool IsARM = T.isARM() || T.isThumb() || T.isAArch64(); 2692 CmdArgs.push_back("-fwchar-type=int"); 2693 if (IsARM && !(T.isOSWindows() || T.getOS() == llvm::Triple::NetBSD || 2694 T.getOS() == llvm::Triple::OpenBSD)) 2695 CmdArgs.push_back("-fno-signed-wchar"); 2696 else 2697 CmdArgs.push_back("-fsigned-wchar"); 2698 } 2699 } 2700 } 2701 2702 static void RenderObjCOptions(const ToolChain &TC, const Driver &D, 2703 const llvm::Triple &T, const ArgList &Args, 2704 ObjCRuntime &Runtime, bool InferCovariantReturns, 2705 const InputInfo &Input, ArgStringList &CmdArgs) { 2706 const llvm::Triple::ArchType Arch = TC.getArch(); 2707 2708 // -fobjc-dispatch-method is only relevant with the nonfragile-abi, and legacy 2709 // is the default. Except for deployment target of 10.5, next runtime is 2710 // always legacy dispatch and -fno-objc-legacy-dispatch gets ignored silently. 2711 if (Runtime.isNonFragile()) { 2712 if (!Args.hasFlag(options::OPT_fobjc_legacy_dispatch, 2713 options::OPT_fno_objc_legacy_dispatch, 2714 Runtime.isLegacyDispatchDefaultForArch(Arch))) { 2715 if (TC.UseObjCMixedDispatch()) 2716 CmdArgs.push_back("-fobjc-dispatch-method=mixed"); 2717 else 2718 CmdArgs.push_back("-fobjc-dispatch-method=non-legacy"); 2719 } 2720 } 2721 2722 // When ObjectiveC legacy runtime is in effect on MacOSX, turn on the option 2723 // to do Array/Dictionary subscripting by default. 2724 if (Arch == llvm::Triple::x86 && T.isMacOSX() && 2725 !T.isMacOSXVersionLT(10, 7) && 2726 Runtime.getKind() == ObjCRuntime::FragileMacOSX && Runtime.isNeXTFamily()) 2727 CmdArgs.push_back("-fobjc-subscripting-legacy-runtime"); 2728 2729 // Allow -fno-objc-arr to trump -fobjc-arr/-fobjc-arc. 2730 // NOTE: This logic is duplicated in ToolChains.cpp. 2731 if (isObjCAutoRefCount(Args)) { 2732 TC.CheckObjCARC(); 2733 2734 CmdArgs.push_back("-fobjc-arc"); 2735 2736 // FIXME: It seems like this entire block, and several around it should be 2737 // wrapped in isObjC, but for now we just use it here as this is where it 2738 // was being used previously. 2739 if (types::isCXX(Input.getType()) && types::isObjC(Input.getType())) { 2740 if (TC.GetCXXStdlibType(Args) == ToolChain::CST_Libcxx) 2741 CmdArgs.push_back("-fobjc-arc-cxxlib=libc++"); 2742 else 2743 CmdArgs.push_back("-fobjc-arc-cxxlib=libstdc++"); 2744 } 2745 2746 // Allow the user to enable full exceptions code emission. 2747 // We default off for Objective-C, on for Objective-C++. 2748 if (Args.hasFlag(options::OPT_fobjc_arc_exceptions, 2749 options::OPT_fno_objc_arc_exceptions, 2750 /*default=*/types::isCXX(Input.getType()))) 2751 CmdArgs.push_back("-fobjc-arc-exceptions"); 2752 } 2753 2754 // Silence warning for full exception code emission options when explicitly 2755 // set to use no ARC. 2756 if (Args.hasArg(options::OPT_fno_objc_arc)) { 2757 Args.ClaimAllArgs(options::OPT_fobjc_arc_exceptions); 2758 Args.ClaimAllArgs(options::OPT_fno_objc_arc_exceptions); 2759 } 2760 2761 // -fobjc-infer-related-result-type is the default, except in the Objective-C 2762 // rewriter. 2763 if (InferCovariantReturns) 2764 CmdArgs.push_back("-fno-objc-infer-related-result-type"); 2765 2766 // Pass down -fobjc-weak or -fno-objc-weak if present. 2767 if (types::isObjC(Input.getType())) { 2768 auto WeakArg = 2769 Args.getLastArg(options::OPT_fobjc_weak, options::OPT_fno_objc_weak); 2770 if (!WeakArg) { 2771 // nothing to do 2772 } else if (!Runtime.allowsWeak()) { 2773 if (WeakArg->getOption().matches(options::OPT_fobjc_weak)) 2774 D.Diag(diag::err_objc_weak_unsupported); 2775 } else { 2776 WeakArg->render(Args, CmdArgs); 2777 } 2778 } 2779 } 2780 2781 static void RenderDiagnosticsOptions(const Driver &D, const ArgList &Args, 2782 ArgStringList &CmdArgs) { 2783 bool CaretDefault = true; 2784 bool ColumnDefault = true; 2785 2786 if (const Arg *A = Args.getLastArg(options::OPT__SLASH_diagnostics_classic, 2787 options::OPT__SLASH_diagnostics_column, 2788 options::OPT__SLASH_diagnostics_caret)) { 2789 switch (A->getOption().getID()) { 2790 case options::OPT__SLASH_diagnostics_caret: 2791 CaretDefault = true; 2792 ColumnDefault = true; 2793 break; 2794 case options::OPT__SLASH_diagnostics_column: 2795 CaretDefault = false; 2796 ColumnDefault = true; 2797 break; 2798 case options::OPT__SLASH_diagnostics_classic: 2799 CaretDefault = false; 2800 ColumnDefault = false; 2801 break; 2802 } 2803 } 2804 2805 // -fcaret-diagnostics is default. 2806 if (!Args.hasFlag(options::OPT_fcaret_diagnostics, 2807 options::OPT_fno_caret_diagnostics, CaretDefault)) 2808 CmdArgs.push_back("-fno-caret-diagnostics"); 2809 2810 // -fdiagnostics-fixit-info is default, only pass non-default. 2811 if (!Args.hasFlag(options::OPT_fdiagnostics_fixit_info, 2812 options::OPT_fno_diagnostics_fixit_info)) 2813 CmdArgs.push_back("-fno-diagnostics-fixit-info"); 2814 2815 // Enable -fdiagnostics-show-option by default. 2816 if (Args.hasFlag(options::OPT_fdiagnostics_show_option, 2817 options::OPT_fno_diagnostics_show_option)) 2818 CmdArgs.push_back("-fdiagnostics-show-option"); 2819 2820 if (const Arg *A = 2821 Args.getLastArg(options::OPT_fdiagnostics_show_category_EQ)) { 2822 CmdArgs.push_back("-fdiagnostics-show-category"); 2823 CmdArgs.push_back(A->getValue()); 2824 } 2825 2826 if (Args.hasFlag(options::OPT_fdiagnostics_show_hotness, 2827 options::OPT_fno_diagnostics_show_hotness, false)) 2828 CmdArgs.push_back("-fdiagnostics-show-hotness"); 2829 2830 if (const Arg *A = 2831 Args.getLastArg(options::OPT_fdiagnostics_hotness_threshold_EQ)) { 2832 std::string Opt = 2833 std::string("-fdiagnostics-hotness-threshold=") + A->getValue(); 2834 CmdArgs.push_back(Args.MakeArgString(Opt)); 2835 } 2836 2837 if (const Arg *A = Args.getLastArg(options::OPT_fdiagnostics_format_EQ)) { 2838 CmdArgs.push_back("-fdiagnostics-format"); 2839 CmdArgs.push_back(A->getValue()); 2840 } 2841 2842 if (const Arg *A = Args.getLastArg( 2843 options::OPT_fdiagnostics_show_note_include_stack, 2844 options::OPT_fno_diagnostics_show_note_include_stack)) { 2845 const Option &O = A->getOption(); 2846 if (O.matches(options::OPT_fdiagnostics_show_note_include_stack)) 2847 CmdArgs.push_back("-fdiagnostics-show-note-include-stack"); 2848 else 2849 CmdArgs.push_back("-fno-diagnostics-show-note-include-stack"); 2850 } 2851 2852 // Color diagnostics are parsed by the driver directly from argv and later 2853 // re-parsed to construct this job; claim any possible color diagnostic here 2854 // to avoid warn_drv_unused_argument and diagnose bad 2855 // OPT_fdiagnostics_color_EQ values. 2856 for (const Arg *A : Args) { 2857 const Option &O = A->getOption(); 2858 if (!O.matches(options::OPT_fcolor_diagnostics) && 2859 !O.matches(options::OPT_fdiagnostics_color) && 2860 !O.matches(options::OPT_fno_color_diagnostics) && 2861 !O.matches(options::OPT_fno_diagnostics_color) && 2862 !O.matches(options::OPT_fdiagnostics_color_EQ)) 2863 continue; 2864 2865 if (O.matches(options::OPT_fdiagnostics_color_EQ)) { 2866 StringRef Value(A->getValue()); 2867 if (Value != "always" && Value != "never" && Value != "auto") 2868 D.Diag(diag::err_drv_clang_unsupported) 2869 << ("-fdiagnostics-color=" + Value).str(); 2870 } 2871 A->claim(); 2872 } 2873 2874 if (D.getDiags().getDiagnosticOptions().ShowColors) 2875 CmdArgs.push_back("-fcolor-diagnostics"); 2876 2877 if (Args.hasArg(options::OPT_fansi_escape_codes)) 2878 CmdArgs.push_back("-fansi-escape-codes"); 2879 2880 if (!Args.hasFlag(options::OPT_fshow_source_location, 2881 options::OPT_fno_show_source_location)) 2882 CmdArgs.push_back("-fno-show-source-location"); 2883 2884 if (Args.hasArg(options::OPT_fdiagnostics_absolute_paths)) 2885 CmdArgs.push_back("-fdiagnostics-absolute-paths"); 2886 2887 if (!Args.hasFlag(options::OPT_fshow_column, options::OPT_fno_show_column, 2888 ColumnDefault)) 2889 CmdArgs.push_back("-fno-show-column"); 2890 2891 if (!Args.hasFlag(options::OPT_fspell_checking, 2892 options::OPT_fno_spell_checking)) 2893 CmdArgs.push_back("-fno-spell-checking"); 2894 } 2895 2896 static void RenderDebugOptions(const ToolChain &TC, const Driver &D, 2897 const llvm::Triple &T, const ArgList &Args, 2898 bool EmitCodeView, bool IsWindowsMSVC, 2899 ArgStringList &CmdArgs, 2900 codegenoptions::DebugInfoKind &DebugInfoKind, 2901 const Arg *&SplitDWARFArg) { 2902 if (Args.hasFlag(options::OPT_fdebug_info_for_profiling, 2903 options::OPT_fno_debug_info_for_profiling, false)) 2904 CmdArgs.push_back("-fdebug-info-for-profiling"); 2905 2906 // The 'g' groups options involve a somewhat intricate sequence of decisions 2907 // about what to pass from the driver to the frontend, but by the time they 2908 // reach cc1 they've been factored into three well-defined orthogonal choices: 2909 // * what level of debug info to generate 2910 // * what dwarf version to write 2911 // * what debugger tuning to use 2912 // This avoids having to monkey around further in cc1 other than to disable 2913 // codeview if not running in a Windows environment. Perhaps even that 2914 // decision should be made in the driver as well though. 2915 unsigned DWARFVersion = 0; 2916 llvm::DebuggerKind DebuggerTuning = TC.getDefaultDebuggerTuning(); 2917 2918 bool SplitDWARFInlining = 2919 Args.hasFlag(options::OPT_fsplit_dwarf_inlining, 2920 options::OPT_fno_split_dwarf_inlining, true); 2921 2922 Args.ClaimAllArgs(options::OPT_g_Group); 2923 2924 SplitDWARFArg = Args.getLastArg(options::OPT_gsplit_dwarf); 2925 2926 if (const Arg *A = Args.getLastArg(options::OPT_g_Group)) { 2927 // If the last option explicitly specified a debug-info level, use it. 2928 if (A->getOption().matches(options::OPT_gN_Group)) { 2929 DebugInfoKind = DebugLevelToInfoKind(*A); 2930 // If you say "-gsplit-dwarf -gline-tables-only", -gsplit-dwarf loses. 2931 // But -gsplit-dwarf is not a g_group option, hence we have to check the 2932 // order explicitly. If -gsplit-dwarf wins, we fix DebugInfoKind later. 2933 // This gets a bit more complicated if you've disabled inline info in the 2934 // skeleton CUs (SplitDWARFInlining) - then there's value in composing 2935 // split-dwarf and line-tables-only, so let those compose naturally in 2936 // that case. 2937 // And if you just turned off debug info, (-gsplit-dwarf -g0) - do that. 2938 if (SplitDWARFArg) { 2939 if (A->getIndex() > SplitDWARFArg->getIndex()) { 2940 if (DebugInfoKind == codegenoptions::NoDebugInfo || 2941 (DebugInfoKind == codegenoptions::DebugLineTablesOnly && 2942 SplitDWARFInlining)) 2943 SplitDWARFArg = nullptr; 2944 } else if (SplitDWARFInlining) 2945 DebugInfoKind = codegenoptions::NoDebugInfo; 2946 } 2947 } else { 2948 // For any other 'g' option, use Limited. 2949 DebugInfoKind = codegenoptions::LimitedDebugInfo; 2950 } 2951 } 2952 2953 // If a debugger tuning argument appeared, remember it. 2954 if (const Arg *A = 2955 Args.getLastArg(options::OPT_gTune_Group, options::OPT_ggdbN_Group)) { 2956 if (A->getOption().matches(options::OPT_glldb)) 2957 DebuggerTuning = llvm::DebuggerKind::LLDB; 2958 else if (A->getOption().matches(options::OPT_gsce)) 2959 DebuggerTuning = llvm::DebuggerKind::SCE; 2960 else 2961 DebuggerTuning = llvm::DebuggerKind::GDB; 2962 } 2963 2964 // If a -gdwarf argument appeared, remember it. 2965 if (const Arg *A = 2966 Args.getLastArg(options::OPT_gdwarf_2, options::OPT_gdwarf_3, 2967 options::OPT_gdwarf_4, options::OPT_gdwarf_5)) 2968 DWARFVersion = DwarfVersionNum(A->getSpelling()); 2969 2970 // Forward -gcodeview. EmitCodeView might have been set by CL-compatibility 2971 // argument parsing. 2972 if (EmitCodeView) { 2973 // DWARFVersion remains at 0 if no explicit choice was made. 2974 CmdArgs.push_back("-gcodeview"); 2975 } else if (DWARFVersion == 0 && 2976 DebugInfoKind != codegenoptions::NoDebugInfo) { 2977 DWARFVersion = TC.GetDefaultDwarfVersion(); 2978 } 2979 2980 // We ignore flag -gstrict-dwarf for now. 2981 // And we handle flag -grecord-gcc-switches later with DWARFDebugFlags. 2982 Args.ClaimAllArgs(options::OPT_g_flags_Group); 2983 2984 // Column info is included by default for everything except SCE and CodeView. 2985 // Clang doesn't track end columns, just starting columns, which, in theory, 2986 // is fine for CodeView (and PDB). In practice, however, the Microsoft 2987 // debuggers don't handle missing end columns well, so it's better not to 2988 // include any column info. 2989 if (Args.hasFlag(options::OPT_gcolumn_info, options::OPT_gno_column_info, 2990 /*Default=*/!EmitCodeView && 2991 DebuggerTuning != llvm::DebuggerKind::SCE)) 2992 CmdArgs.push_back("-dwarf-column-info"); 2993 2994 // FIXME: Move backend command line options to the module. 2995 // If -gline-tables-only is the last option it wins. 2996 if (DebugInfoKind != codegenoptions::DebugLineTablesOnly && 2997 Args.hasArg(options::OPT_gmodules)) { 2998 DebugInfoKind = codegenoptions::LimitedDebugInfo; 2999 CmdArgs.push_back("-dwarf-ext-refs"); 3000 CmdArgs.push_back("-fmodule-format=obj"); 3001 } 3002 3003 // -gsplit-dwarf should turn on -g and enable the backend dwarf 3004 // splitting and extraction. 3005 // FIXME: Currently only works on Linux. 3006 if (T.isOSLinux()) { 3007 if (!SplitDWARFInlining) 3008 CmdArgs.push_back("-fno-split-dwarf-inlining"); 3009 3010 if (SplitDWARFArg) { 3011 if (DebugInfoKind == codegenoptions::NoDebugInfo) 3012 DebugInfoKind = codegenoptions::LimitedDebugInfo; 3013 CmdArgs.push_back("-enable-split-dwarf"); 3014 } 3015 } 3016 3017 // After we've dealt with all combinations of things that could 3018 // make DebugInfoKind be other than None or DebugLineTablesOnly, 3019 // figure out if we need to "upgrade" it to standalone debug info. 3020 // We parse these two '-f' options whether or not they will be used, 3021 // to claim them even if you wrote "-fstandalone-debug -gline-tables-only" 3022 bool NeedFullDebug = Args.hasFlag(options::OPT_fstandalone_debug, 3023 options::OPT_fno_standalone_debug, 3024 TC.GetDefaultStandaloneDebug()); 3025 if (DebugInfoKind == codegenoptions::LimitedDebugInfo && NeedFullDebug) 3026 DebugInfoKind = codegenoptions::FullDebugInfo; 3027 3028 if (Args.hasFlag(options::OPT_gembed_source, options::OPT_gno_embed_source, false)) { 3029 // Source embedding is a vendor extension to DWARF v5. By now we have 3030 // checked if a DWARF version was stated explicitly, and have otherwise 3031 // fallen back to the target default, so if this is still not at least 5 we 3032 // emit an error. 3033 if (DWARFVersion < 5) 3034 D.Diag(diag::err_drv_argument_only_allowed_with) 3035 << Args.getLastArg(options::OPT_gembed_source)->getAsString(Args) 3036 << "-gdwarf-5"; 3037 CmdArgs.push_back("-gembed-source"); 3038 } 3039 3040 RenderDebugEnablingArgs(Args, CmdArgs, DebugInfoKind, DWARFVersion, 3041 DebuggerTuning); 3042 3043 // -fdebug-macro turns on macro debug info generation. 3044 if (Args.hasFlag(options::OPT_fdebug_macro, options::OPT_fno_debug_macro, 3045 false)) 3046 CmdArgs.push_back("-debug-info-macro"); 3047 3048 // -ggnu-pubnames turns on gnu style pubnames in the backend. 3049 if (Args.hasArg(options::OPT_ggnu_pubnames)) 3050 CmdArgs.push_back("-ggnu-pubnames"); 3051 3052 // -gdwarf-aranges turns on the emission of the aranges section in the 3053 // backend. 3054 // Always enabled for SCE tuning. 3055 if (Args.hasArg(options::OPT_gdwarf_aranges) || 3056 DebuggerTuning == llvm::DebuggerKind::SCE) { 3057 CmdArgs.push_back("-mllvm"); 3058 CmdArgs.push_back("-generate-arange-section"); 3059 } 3060 3061 if (Args.hasFlag(options::OPT_fdebug_types_section, 3062 options::OPT_fno_debug_types_section, false)) { 3063 CmdArgs.push_back("-mllvm"); 3064 CmdArgs.push_back("-generate-type-units"); 3065 } 3066 3067 // Decide how to render forward declarations of template instantiations. 3068 // SCE wants full descriptions, others just get them in the name. 3069 if (DebuggerTuning == llvm::DebuggerKind::SCE) 3070 CmdArgs.push_back("-debug-forward-template-params"); 3071 3072 // Do we need to explicitly import anonymous namespaces into the parent scope? 3073 if (DebuggerTuning == llvm::DebuggerKind::SCE) 3074 CmdArgs.push_back("-dwarf-explicit-import"); 3075 3076 RenderDebugInfoCompressionArgs(Args, CmdArgs, D); 3077 } 3078 3079 void Clang::ConstructJob(Compilation &C, const JobAction &JA, 3080 const InputInfo &Output, const InputInfoList &Inputs, 3081 const ArgList &Args, const char *LinkingOutput) const { 3082 const llvm::Triple &RawTriple = getToolChain().getTriple(); 3083 const llvm::Triple &Triple = getToolChain().getEffectiveTriple(); 3084 const std::string &TripleStr = Triple.getTriple(); 3085 3086 bool KernelOrKext = 3087 Args.hasArg(options::OPT_mkernel, options::OPT_fapple_kext); 3088 const Driver &D = getToolChain().getDriver(); 3089 ArgStringList CmdArgs; 3090 3091 // Check number of inputs for sanity. We need at least one input. 3092 assert(Inputs.size() >= 1 && "Must have at least one input."); 3093 const InputInfo &Input = Inputs[0]; 3094 // CUDA/HIP compilation may have multiple inputs (source file + results of 3095 // device-side compilations). OpenMP device jobs also take the host IR as a 3096 // second input. All other jobs are expected to have exactly one 3097 // input. 3098 bool IsCuda = JA.isOffloading(Action::OFK_Cuda); 3099 bool IsHIP = JA.isOffloading(Action::OFK_HIP); 3100 bool IsOpenMPDevice = JA.isDeviceOffloading(Action::OFK_OpenMP); 3101 assert((IsCuda || IsHIP || (IsOpenMPDevice && Inputs.size() == 2) || 3102 Inputs.size() == 1) && 3103 "Unable to handle multiple inputs."); 3104 3105 const llvm::Triple *AuxTriple = 3106 IsCuda ? getToolChain().getAuxTriple() : nullptr; 3107 3108 bool IsWindowsGNU = RawTriple.isWindowsGNUEnvironment(); 3109 bool IsWindowsCygnus = RawTriple.isWindowsCygwinEnvironment(); 3110 bool IsWindowsMSVC = RawTriple.isWindowsMSVCEnvironment(); 3111 bool IsIAMCU = RawTriple.isOSIAMCU(); 3112 3113 // Adjust IsWindowsXYZ for CUDA/HIP compilations. Even when compiling in 3114 // device mode (i.e., getToolchain().getTriple() is NVPTX/AMDGCN, not 3115 // Windows), we need to pass Windows-specific flags to cc1. 3116 if (IsCuda || IsHIP) { 3117 IsWindowsMSVC |= AuxTriple && AuxTriple->isWindowsMSVCEnvironment(); 3118 IsWindowsGNU |= AuxTriple && AuxTriple->isWindowsGNUEnvironment(); 3119 IsWindowsCygnus |= AuxTriple && AuxTriple->isWindowsCygwinEnvironment(); 3120 } 3121 3122 // C++ is not supported for IAMCU. 3123 if (IsIAMCU && types::isCXX(Input.getType())) 3124 D.Diag(diag::err_drv_clang_unsupported) << "C++ for IAMCU"; 3125 3126 // Invoke ourselves in -cc1 mode. 3127 // 3128 // FIXME: Implement custom jobs for internal actions. 3129 CmdArgs.push_back("-cc1"); 3130 3131 // Add the "effective" target triple. 3132 CmdArgs.push_back("-triple"); 3133 CmdArgs.push_back(Args.MakeArgString(TripleStr)); 3134 3135 if (const Arg *MJ = Args.getLastArg(options::OPT_MJ)) { 3136 DumpCompilationDatabase(C, MJ->getValue(), TripleStr, Output, Input, Args); 3137 Args.ClaimAllArgs(options::OPT_MJ); 3138 } 3139 3140 if (IsCuda || IsHIP) { 3141 // We have to pass the triple of the host if compiling for a CUDA/HIP device 3142 // and vice-versa. 3143 std::string NormalizedTriple; 3144 if (JA.isDeviceOffloading(Action::OFK_Cuda) || 3145 JA.isDeviceOffloading(Action::OFK_HIP)) 3146 NormalizedTriple = C.getSingleOffloadToolChain<Action::OFK_Host>() 3147 ->getTriple() 3148 .normalize(); 3149 else 3150 NormalizedTriple = 3151 (IsCuda ? C.getSingleOffloadToolChain<Action::OFK_Cuda>() 3152 : C.getSingleOffloadToolChain<Action::OFK_HIP>()) 3153 ->getTriple() 3154 .normalize(); 3155 3156 CmdArgs.push_back("-aux-triple"); 3157 CmdArgs.push_back(Args.MakeArgString(NormalizedTriple)); 3158 } 3159 3160 if (IsOpenMPDevice) { 3161 // We have to pass the triple of the host if compiling for an OpenMP device. 3162 std::string NormalizedTriple = 3163 C.getSingleOffloadToolChain<Action::OFK_Host>() 3164 ->getTriple() 3165 .normalize(); 3166 CmdArgs.push_back("-aux-triple"); 3167 CmdArgs.push_back(Args.MakeArgString(NormalizedTriple)); 3168 } 3169 3170 if (Triple.isOSWindows() && (Triple.getArch() == llvm::Triple::arm || 3171 Triple.getArch() == llvm::Triple::thumb)) { 3172 unsigned Offset = Triple.getArch() == llvm::Triple::arm ? 4 : 6; 3173 unsigned Version; 3174 Triple.getArchName().substr(Offset).getAsInteger(10, Version); 3175 if (Version < 7) 3176 D.Diag(diag::err_target_unsupported_arch) << Triple.getArchName() 3177 << TripleStr; 3178 } 3179 3180 // Push all default warning arguments that are specific to 3181 // the given target. These come before user provided warning options 3182 // are provided. 3183 getToolChain().addClangWarningOptions(CmdArgs); 3184 3185 // Select the appropriate action. 3186 RewriteKind rewriteKind = RK_None; 3187 3188 if (isa<AnalyzeJobAction>(JA)) { 3189 assert(JA.getType() == types::TY_Plist && "Invalid output type."); 3190 CmdArgs.push_back("-analyze"); 3191 } else if (isa<MigrateJobAction>(JA)) { 3192 CmdArgs.push_back("-migrate"); 3193 } else if (isa<PreprocessJobAction>(JA)) { 3194 if (Output.getType() == types::TY_Dependencies) 3195 CmdArgs.push_back("-Eonly"); 3196 else { 3197 CmdArgs.push_back("-E"); 3198 if (Args.hasArg(options::OPT_rewrite_objc) && 3199 !Args.hasArg(options::OPT_g_Group)) 3200 CmdArgs.push_back("-P"); 3201 } 3202 } else if (isa<AssembleJobAction>(JA)) { 3203 CmdArgs.push_back("-emit-obj"); 3204 3205 CollectArgsForIntegratedAssembler(C, Args, CmdArgs, D); 3206 3207 // Also ignore explicit -force_cpusubtype_ALL option. 3208 (void)Args.hasArg(options::OPT_force__cpusubtype__ALL); 3209 } else if (isa<PrecompileJobAction>(JA)) { 3210 // Use PCH if the user requested it. 3211 bool UsePCH = D.CCCUsePCH; 3212 3213 if (JA.getType() == types::TY_Nothing) 3214 CmdArgs.push_back("-fsyntax-only"); 3215 else if (JA.getType() == types::TY_ModuleFile) 3216 CmdArgs.push_back("-emit-module-interface"); 3217 else if (UsePCH) 3218 CmdArgs.push_back("-emit-pch"); 3219 else 3220 CmdArgs.push_back("-emit-pth"); 3221 } else if (isa<VerifyPCHJobAction>(JA)) { 3222 CmdArgs.push_back("-verify-pch"); 3223 } else { 3224 assert((isa<CompileJobAction>(JA) || isa<BackendJobAction>(JA)) && 3225 "Invalid action for clang tool."); 3226 if (JA.getType() == types::TY_Nothing) { 3227 CmdArgs.push_back("-fsyntax-only"); 3228 } else if (JA.getType() == types::TY_LLVM_IR || 3229 JA.getType() == types::TY_LTO_IR) { 3230 CmdArgs.push_back("-emit-llvm"); 3231 } else if (JA.getType() == types::TY_LLVM_BC || 3232 JA.getType() == types::TY_LTO_BC) { 3233 CmdArgs.push_back("-emit-llvm-bc"); 3234 } else if (JA.getType() == types::TY_PP_Asm) { 3235 CmdArgs.push_back("-S"); 3236 } else if (JA.getType() == types::TY_AST) { 3237 CmdArgs.push_back("-emit-pch"); 3238 } else if (JA.getType() == types::TY_ModuleFile) { 3239 CmdArgs.push_back("-module-file-info"); 3240 } else if (JA.getType() == types::TY_RewrittenObjC) { 3241 CmdArgs.push_back("-rewrite-objc"); 3242 rewriteKind = RK_NonFragile; 3243 } else if (JA.getType() == types::TY_RewrittenLegacyObjC) { 3244 CmdArgs.push_back("-rewrite-objc"); 3245 rewriteKind = RK_Fragile; 3246 } else { 3247 assert(JA.getType() == types::TY_PP_Asm && "Unexpected output type!"); 3248 } 3249 3250 // Preserve use-list order by default when emitting bitcode, so that 3251 // loading the bitcode up in 'opt' or 'llc' and running passes gives the 3252 // same result as running passes here. For LTO, we don't need to preserve 3253 // the use-list order, since serialization to bitcode is part of the flow. 3254 if (JA.getType() == types::TY_LLVM_BC) 3255 CmdArgs.push_back("-emit-llvm-uselists"); 3256 3257 // Device-side jobs do not support LTO. 3258 bool isDeviceOffloadAction = !(JA.isDeviceOffloading(Action::OFK_None) || 3259 JA.isDeviceOffloading(Action::OFK_Host)); 3260 3261 if (D.isUsingLTO() && !isDeviceOffloadAction) { 3262 Args.AddLastArg(CmdArgs, options::OPT_flto, options::OPT_flto_EQ); 3263 3264 // The Darwin and PS4 linkers currently use the legacy LTO API, which 3265 // does not support LTO unit features (CFI, whole program vtable opt) 3266 // under ThinLTO. 3267 if (!(RawTriple.isOSDarwin() || RawTriple.isPS4()) || 3268 D.getLTOMode() == LTOK_Full) 3269 CmdArgs.push_back("-flto-unit"); 3270 } 3271 } 3272 3273 if (const Arg *A = Args.getLastArg(options::OPT_fthinlto_index_EQ)) { 3274 if (!types::isLLVMIR(Input.getType())) 3275 D.Diag(diag::err_drv_argument_only_allowed_with) << A->getAsString(Args) 3276 << "-x ir"; 3277 Args.AddLastArg(CmdArgs, options::OPT_fthinlto_index_EQ); 3278 } 3279 3280 if (Args.getLastArg(options::OPT_save_temps_EQ)) 3281 Args.AddLastArg(CmdArgs, options::OPT_save_temps_EQ); 3282 3283 // Embed-bitcode option. 3284 if (C.getDriver().embedBitcodeInObject() && !C.getDriver().isUsingLTO() && 3285 (isa<BackendJobAction>(JA) || isa<AssembleJobAction>(JA))) { 3286 // Add flags implied by -fembed-bitcode. 3287 Args.AddLastArg(CmdArgs, options::OPT_fembed_bitcode_EQ); 3288 // Disable all llvm IR level optimizations. 3289 CmdArgs.push_back("-disable-llvm-passes"); 3290 } 3291 if (C.getDriver().embedBitcodeMarkerOnly() && !C.getDriver().isUsingLTO()) 3292 CmdArgs.push_back("-fembed-bitcode=marker"); 3293 3294 // We normally speed up the clang process a bit by skipping destructors at 3295 // exit, but when we're generating diagnostics we can rely on some of the 3296 // cleanup. 3297 if (!C.isForDiagnostics()) 3298 CmdArgs.push_back("-disable-free"); 3299 3300 #ifdef NDEBUG 3301 const bool IsAssertBuild = false; 3302 #else 3303 const bool IsAssertBuild = true; 3304 #endif 3305 3306 // Disable the verification pass in -asserts builds. 3307 if (!IsAssertBuild) 3308 CmdArgs.push_back("-disable-llvm-verifier"); 3309 3310 // Discard value names in assert builds unless otherwise specified. 3311 if (Args.hasFlag(options::OPT_fdiscard_value_names, 3312 options::OPT_fno_discard_value_names, !IsAssertBuild)) 3313 CmdArgs.push_back("-discard-value-names"); 3314 3315 // Set the main file name, so that debug info works even with 3316 // -save-temps. 3317 CmdArgs.push_back("-main-file-name"); 3318 CmdArgs.push_back(getBaseInputName(Args, Input)); 3319 3320 // Some flags which affect the language (via preprocessor 3321 // defines). 3322 if (Args.hasArg(options::OPT_static)) 3323 CmdArgs.push_back("-static-define"); 3324 3325 if (isa<AnalyzeJobAction>(JA)) 3326 RenderAnalyzerOptions(Args, CmdArgs, Triple, Input); 3327 3328 CheckCodeGenerationOptions(D, Args); 3329 3330 unsigned FunctionAlignment = ParseFunctionAlignment(getToolChain(), Args); 3331 assert(FunctionAlignment <= 31 && "function alignment will be truncated!"); 3332 if (FunctionAlignment) { 3333 CmdArgs.push_back("-function-alignment"); 3334 CmdArgs.push_back(Args.MakeArgString(std::to_string(FunctionAlignment))); 3335 } 3336 3337 llvm::Reloc::Model RelocationModel; 3338 unsigned PICLevel; 3339 bool IsPIE; 3340 std::tie(RelocationModel, PICLevel, IsPIE) = 3341 ParsePICArgs(getToolChain(), Args); 3342 3343 const char *RMName = RelocationModelName(RelocationModel); 3344 3345 if ((RelocationModel == llvm::Reloc::ROPI || 3346 RelocationModel == llvm::Reloc::ROPI_RWPI) && 3347 types::isCXX(Input.getType()) && 3348 !Args.hasArg(options::OPT_fallow_unsupported)) 3349 D.Diag(diag::err_drv_ropi_incompatible_with_cxx); 3350 3351 if (RMName) { 3352 CmdArgs.push_back("-mrelocation-model"); 3353 CmdArgs.push_back(RMName); 3354 } 3355 if (PICLevel > 0) { 3356 CmdArgs.push_back("-pic-level"); 3357 CmdArgs.push_back(PICLevel == 1 ? "1" : "2"); 3358 if (IsPIE) 3359 CmdArgs.push_back("-pic-is-pie"); 3360 } 3361 3362 if (Arg *A = Args.getLastArg(options::OPT_meabi)) { 3363 CmdArgs.push_back("-meabi"); 3364 CmdArgs.push_back(A->getValue()); 3365 } 3366 3367 CmdArgs.push_back("-mthread-model"); 3368 if (Arg *A = Args.getLastArg(options::OPT_mthread_model)) { 3369 if (!getToolChain().isThreadModelSupported(A->getValue())) 3370 D.Diag(diag::err_drv_invalid_thread_model_for_target) 3371 << A->getValue() << A->getAsString(Args); 3372 CmdArgs.push_back(A->getValue()); 3373 } 3374 else 3375 CmdArgs.push_back(Args.MakeArgString(getToolChain().getThreadModel())); 3376 3377 Args.AddLastArg(CmdArgs, options::OPT_fveclib); 3378 3379 if (Args.hasFlag(options::OPT_fmerge_all_constants, 3380 options::OPT_fno_merge_all_constants, false)) 3381 CmdArgs.push_back("-fmerge-all-constants"); 3382 3383 // LLVM Code Generator Options. 3384 3385 if (Args.hasArg(options::OPT_frewrite_map_file) || 3386 Args.hasArg(options::OPT_frewrite_map_file_EQ)) { 3387 for (const Arg *A : Args.filtered(options::OPT_frewrite_map_file, 3388 options::OPT_frewrite_map_file_EQ)) { 3389 StringRef Map = A->getValue(); 3390 if (!llvm::sys::fs::exists(Map)) { 3391 D.Diag(diag::err_drv_no_such_file) << Map; 3392 } else { 3393 CmdArgs.push_back("-frewrite-map-file"); 3394 CmdArgs.push_back(A->getValue()); 3395 A->claim(); 3396 } 3397 } 3398 } 3399 3400 if (Arg *A = Args.getLastArg(options::OPT_Wframe_larger_than_EQ)) { 3401 StringRef v = A->getValue(); 3402 CmdArgs.push_back("-mllvm"); 3403 CmdArgs.push_back(Args.MakeArgString("-warn-stack-size=" + v)); 3404 A->claim(); 3405 } 3406 3407 if (!Args.hasFlag(options::OPT_fjump_tables, options::OPT_fno_jump_tables, 3408 true)) 3409 CmdArgs.push_back("-fno-jump-tables"); 3410 3411 if (Args.hasFlag(options::OPT_fprofile_sample_accurate, 3412 options::OPT_fno_profile_sample_accurate, false)) 3413 CmdArgs.push_back("-fprofile-sample-accurate"); 3414 3415 if (!Args.hasFlag(options::OPT_fpreserve_as_comments, 3416 options::OPT_fno_preserve_as_comments, true)) 3417 CmdArgs.push_back("-fno-preserve-as-comments"); 3418 3419 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) { 3420 CmdArgs.push_back("-mregparm"); 3421 CmdArgs.push_back(A->getValue()); 3422 } 3423 3424 if (Arg *A = Args.getLastArg(options::OPT_fpcc_struct_return, 3425 options::OPT_freg_struct_return)) { 3426 if (getToolChain().getArch() != llvm::Triple::x86) { 3427 D.Diag(diag::err_drv_unsupported_opt_for_target) 3428 << A->getSpelling() << RawTriple.str(); 3429 } else if (A->getOption().matches(options::OPT_fpcc_struct_return)) { 3430 CmdArgs.push_back("-fpcc-struct-return"); 3431 } else { 3432 assert(A->getOption().matches(options::OPT_freg_struct_return)); 3433 CmdArgs.push_back("-freg-struct-return"); 3434 } 3435 } 3436 3437 if (Args.hasFlag(options::OPT_mrtd, options::OPT_mno_rtd, false)) 3438 CmdArgs.push_back("-fdefault-calling-conv=stdcall"); 3439 3440 if (shouldUseFramePointer(Args, RawTriple)) 3441 CmdArgs.push_back("-mdisable-fp-elim"); 3442 if (!Args.hasFlag(options::OPT_fzero_initialized_in_bss, 3443 options::OPT_fno_zero_initialized_in_bss)) 3444 CmdArgs.push_back("-mno-zero-initialized-in-bss"); 3445 3446 bool OFastEnabled = isOptimizationLevelFast(Args); 3447 // If -Ofast is the optimization level, then -fstrict-aliasing should be 3448 // enabled. This alias option is being used to simplify the hasFlag logic. 3449 OptSpecifier StrictAliasingAliasOption = 3450 OFastEnabled ? options::OPT_Ofast : options::OPT_fstrict_aliasing; 3451 // We turn strict aliasing off by default if we're in CL mode, since MSVC 3452 // doesn't do any TBAA. 3453 bool TBAAOnByDefault = !D.IsCLMode(); 3454 if (!Args.hasFlag(options::OPT_fstrict_aliasing, StrictAliasingAliasOption, 3455 options::OPT_fno_strict_aliasing, TBAAOnByDefault)) 3456 CmdArgs.push_back("-relaxed-aliasing"); 3457 if (!Args.hasFlag(options::OPT_fstruct_path_tbaa, 3458 options::OPT_fno_struct_path_tbaa)) 3459 CmdArgs.push_back("-no-struct-path-tbaa"); 3460 if (Args.hasFlag(options::OPT_fstrict_enums, options::OPT_fno_strict_enums, 3461 false)) 3462 CmdArgs.push_back("-fstrict-enums"); 3463 if (!Args.hasFlag(options::OPT_fstrict_return, options::OPT_fno_strict_return, 3464 true)) 3465 CmdArgs.push_back("-fno-strict-return"); 3466 if (Args.hasFlag(options::OPT_fallow_editor_placeholders, 3467 options::OPT_fno_allow_editor_placeholders, false)) 3468 CmdArgs.push_back("-fallow-editor-placeholders"); 3469 if (Args.hasFlag(options::OPT_fstrict_vtable_pointers, 3470 options::OPT_fno_strict_vtable_pointers, 3471 false)) 3472 CmdArgs.push_back("-fstrict-vtable-pointers"); 3473 if (Args.hasFlag(options::OPT_fforce_emit_vtables, 3474 options::OPT_fno_force_emit_vtables, 3475 false)) 3476 CmdArgs.push_back("-fforce-emit-vtables"); 3477 if (!Args.hasFlag(options::OPT_foptimize_sibling_calls, 3478 options::OPT_fno_optimize_sibling_calls)) 3479 CmdArgs.push_back("-mdisable-tail-calls"); 3480 if (Args.hasFlag(options::OPT_fno_escaping_block_tail_calls, 3481 options::OPT_fescaping_block_tail_calls, false)) 3482 CmdArgs.push_back("-fno-escaping-block-tail-calls"); 3483 3484 Args.AddLastArg(CmdArgs, options::OPT_ffine_grained_bitfield_accesses, 3485 options::OPT_fno_fine_grained_bitfield_accesses); 3486 3487 // Handle segmented stacks. 3488 if (Args.hasArg(options::OPT_fsplit_stack)) 3489 CmdArgs.push_back("-split-stacks"); 3490 3491 RenderFloatingPointOptions(getToolChain(), D, OFastEnabled, Args, CmdArgs); 3492 3493 // Decide whether to use verbose asm. Verbose assembly is the default on 3494 // toolchains which have the integrated assembler on by default. 3495 bool IsIntegratedAssemblerDefault = 3496 getToolChain().IsIntegratedAssemblerDefault(); 3497 if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm, 3498 IsIntegratedAssemblerDefault) || 3499 Args.hasArg(options::OPT_dA)) 3500 CmdArgs.push_back("-masm-verbose"); 3501 3502 if (!getToolChain().useIntegratedAs()) 3503 CmdArgs.push_back("-no-integrated-as"); 3504 3505 if (Args.hasArg(options::OPT_fdebug_pass_structure)) { 3506 CmdArgs.push_back("-mdebug-pass"); 3507 CmdArgs.push_back("Structure"); 3508 } 3509 if (Args.hasArg(options::OPT_fdebug_pass_arguments)) { 3510 CmdArgs.push_back("-mdebug-pass"); 3511 CmdArgs.push_back("Arguments"); 3512 } 3513 3514 // Enable -mconstructor-aliases except on darwin, where we have to work around 3515 // a linker bug (see <rdar://problem/7651567>), and CUDA device code, where 3516 // aliases aren't supported. 3517 if (!RawTriple.isOSDarwin() && !RawTriple.isNVPTX()) 3518 CmdArgs.push_back("-mconstructor-aliases"); 3519 3520 // Darwin's kernel doesn't support guard variables; just die if we 3521 // try to use them. 3522 if (KernelOrKext && RawTriple.isOSDarwin()) 3523 CmdArgs.push_back("-fforbid-guard-variables"); 3524 3525 if (Args.hasFlag(options::OPT_mms_bitfields, options::OPT_mno_ms_bitfields, 3526 false)) { 3527 CmdArgs.push_back("-mms-bitfields"); 3528 } 3529 3530 if (Args.hasFlag(options::OPT_mpie_copy_relocations, 3531 options::OPT_mno_pie_copy_relocations, 3532 false)) { 3533 CmdArgs.push_back("-mpie-copy-relocations"); 3534 } 3535 3536 if (Args.hasFlag(options::OPT_fno_plt, options::OPT_fplt, false)) { 3537 CmdArgs.push_back("-fno-plt"); 3538 } 3539 3540 // -fhosted is default. 3541 // TODO: Audit uses of KernelOrKext and see where it'd be more appropriate to 3542 // use Freestanding. 3543 bool Freestanding = 3544 Args.hasFlag(options::OPT_ffreestanding, options::OPT_fhosted, false) || 3545 KernelOrKext; 3546 if (Freestanding) 3547 CmdArgs.push_back("-ffreestanding"); 3548 3549 // This is a coarse approximation of what llvm-gcc actually does, both 3550 // -fasynchronous-unwind-tables and -fnon-call-exceptions interact in more 3551 // complicated ways. 3552 bool AsynchronousUnwindTables = 3553 Args.hasFlag(options::OPT_fasynchronous_unwind_tables, 3554 options::OPT_fno_asynchronous_unwind_tables, 3555 (getToolChain().IsUnwindTablesDefault(Args) || 3556 getToolChain().getSanitizerArgs().needsUnwindTables()) && 3557 !Freestanding); 3558 if (Args.hasFlag(options::OPT_funwind_tables, options::OPT_fno_unwind_tables, 3559 AsynchronousUnwindTables)) 3560 CmdArgs.push_back("-munwind-tables"); 3561 3562 getToolChain().addClangTargetOptions(Args, CmdArgs, 3563 JA.getOffloadingDeviceKind()); 3564 3565 if (Arg *A = Args.getLastArg(options::OPT_flimited_precision_EQ)) { 3566 CmdArgs.push_back("-mlimit-float-precision"); 3567 CmdArgs.push_back(A->getValue()); 3568 } 3569 3570 // FIXME: Handle -mtune=. 3571 (void)Args.hasArg(options::OPT_mtune_EQ); 3572 3573 if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) { 3574 CmdArgs.push_back("-mcode-model"); 3575 CmdArgs.push_back(A->getValue()); 3576 } 3577 3578 // Add the target cpu 3579 std::string CPU = getCPUName(Args, Triple, /*FromAs*/ false); 3580 if (!CPU.empty()) { 3581 CmdArgs.push_back("-target-cpu"); 3582 CmdArgs.push_back(Args.MakeArgString(CPU)); 3583 } 3584 3585 RenderTargetOptions(Triple, Args, KernelOrKext, CmdArgs); 3586 3587 // These two are potentially updated by AddClangCLArgs. 3588 codegenoptions::DebugInfoKind DebugInfoKind = codegenoptions::NoDebugInfo; 3589 bool EmitCodeView = false; 3590 3591 // Add clang-cl arguments. 3592 types::ID InputType = Input.getType(); 3593 if (D.IsCLMode()) 3594 AddClangCLArgs(Args, InputType, CmdArgs, &DebugInfoKind, &EmitCodeView); 3595 else 3596 EmitCodeView = Args.hasArg(options::OPT_gcodeview); 3597 3598 const Arg *SplitDWARFArg = nullptr; 3599 RenderDebugOptions(getToolChain(), D, RawTriple, Args, EmitCodeView, 3600 IsWindowsMSVC, CmdArgs, DebugInfoKind, SplitDWARFArg); 3601 3602 // Add the split debug info name to the command lines here so we 3603 // can propagate it to the backend. 3604 bool SplitDWARF = SplitDWARFArg && RawTriple.isOSLinux() && 3605 (isa<AssembleJobAction>(JA) || isa<CompileJobAction>(JA) || 3606 isa<BackendJobAction>(JA)); 3607 const char *SplitDWARFOut; 3608 if (SplitDWARF) { 3609 CmdArgs.push_back("-split-dwarf-file"); 3610 SplitDWARFOut = SplitDebugName(Args, Input); 3611 CmdArgs.push_back(SplitDWARFOut); 3612 } 3613 3614 // Pass the linker version in use. 3615 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) { 3616 CmdArgs.push_back("-target-linker-version"); 3617 CmdArgs.push_back(A->getValue()); 3618 } 3619 3620 if (!shouldUseLeafFramePointer(Args, RawTriple)) 3621 CmdArgs.push_back("-momit-leaf-frame-pointer"); 3622 3623 // Explicitly error on some things we know we don't support and can't just 3624 // ignore. 3625 if (!Args.hasArg(options::OPT_fallow_unsupported)) { 3626 Arg *Unsupported; 3627 if (types::isCXX(InputType) && RawTriple.isOSDarwin() && 3628 getToolChain().getArch() == llvm::Triple::x86) { 3629 if ((Unsupported = Args.getLastArg(options::OPT_fapple_kext)) || 3630 (Unsupported = Args.getLastArg(options::OPT_mkernel))) 3631 D.Diag(diag::err_drv_clang_unsupported_opt_cxx_darwin_i386) 3632 << Unsupported->getOption().getName(); 3633 } 3634 // The faltivec option has been superseded by the maltivec option. 3635 if ((Unsupported = Args.getLastArg(options::OPT_faltivec))) 3636 D.Diag(diag::err_drv_clang_unsupported_opt_faltivec) 3637 << Unsupported->getOption().getName() 3638 << "please use -maltivec and include altivec.h explicitly"; 3639 if ((Unsupported = Args.getLastArg(options::OPT_fno_altivec))) 3640 D.Diag(diag::err_drv_clang_unsupported_opt_faltivec) 3641 << Unsupported->getOption().getName() << "please use -mno-altivec"; 3642 } 3643 3644 Args.AddAllArgs(CmdArgs, options::OPT_v); 3645 Args.AddLastArg(CmdArgs, options::OPT_H); 3646 if (D.CCPrintHeaders && !D.CCGenDiagnostics) { 3647 CmdArgs.push_back("-header-include-file"); 3648 CmdArgs.push_back(D.CCPrintHeadersFilename ? D.CCPrintHeadersFilename 3649 : "-"); 3650 } 3651 Args.AddLastArg(CmdArgs, options::OPT_P); 3652 Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout); 3653 3654 if (D.CCLogDiagnostics && !D.CCGenDiagnostics) { 3655 CmdArgs.push_back("-diagnostic-log-file"); 3656 CmdArgs.push_back(D.CCLogDiagnosticsFilename ? D.CCLogDiagnosticsFilename 3657 : "-"); 3658 } 3659 3660 bool UseSeparateSections = isUseSeparateSections(Triple); 3661 3662 if (Args.hasFlag(options::OPT_ffunction_sections, 3663 options::OPT_fno_function_sections, UseSeparateSections)) { 3664 CmdArgs.push_back("-ffunction-sections"); 3665 } 3666 3667 if (Args.hasFlag(options::OPT_fdata_sections, options::OPT_fno_data_sections, 3668 UseSeparateSections)) { 3669 CmdArgs.push_back("-fdata-sections"); 3670 } 3671 3672 if (!Args.hasFlag(options::OPT_funique_section_names, 3673 options::OPT_fno_unique_section_names, true)) 3674 CmdArgs.push_back("-fno-unique-section-names"); 3675 3676 if (auto *A = Args.getLastArg( 3677 options::OPT_finstrument_functions, 3678 options::OPT_finstrument_functions_after_inlining, 3679 options::OPT_finstrument_function_entry_bare)) 3680 A->render(Args, CmdArgs); 3681 3682 // NVPTX doesn't support PGO or coverage. There's no runtime support for 3683 // sampling, overhead of call arc collection is way too high and there's no 3684 // way to collect the output. 3685 if (!Triple.isNVPTX()) 3686 addPGOAndCoverageFlags(C, D, Output, Args, CmdArgs); 3687 3688 if (auto *ABICompatArg = Args.getLastArg(options::OPT_fclang_abi_compat_EQ)) 3689 ABICompatArg->render(Args, CmdArgs); 3690 3691 // Add runtime flag for PS4 when PGO, coverage, or sanitizers are enabled. 3692 if (RawTriple.isPS4CPU()) { 3693 PS4cpu::addProfileRTArgs(getToolChain(), Args, CmdArgs); 3694 PS4cpu::addSanitizerArgs(getToolChain(), CmdArgs); 3695 } 3696 3697 // Pass options for controlling the default header search paths. 3698 if (Args.hasArg(options::OPT_nostdinc)) { 3699 CmdArgs.push_back("-nostdsysteminc"); 3700 CmdArgs.push_back("-nobuiltininc"); 3701 } else { 3702 if (Args.hasArg(options::OPT_nostdlibinc)) 3703 CmdArgs.push_back("-nostdsysteminc"); 3704 Args.AddLastArg(CmdArgs, options::OPT_nostdincxx); 3705 Args.AddLastArg(CmdArgs, options::OPT_nobuiltininc); 3706 } 3707 3708 // Pass the path to compiler resource files. 3709 CmdArgs.push_back("-resource-dir"); 3710 CmdArgs.push_back(D.ResourceDir.c_str()); 3711 3712 Args.AddLastArg(CmdArgs, options::OPT_working_directory); 3713 3714 RenderARCMigrateToolOptions(D, Args, CmdArgs); 3715 3716 // Add preprocessing options like -I, -D, etc. if we are using the 3717 // preprocessor. 3718 // 3719 // FIXME: Support -fpreprocessed 3720 if (types::getPreprocessedType(InputType) != types::TY_INVALID) 3721 AddPreprocessingOptions(C, JA, D, Args, CmdArgs, Output, Inputs); 3722 3723 // Don't warn about "clang -c -DPIC -fPIC test.i" because libtool.m4 assumes 3724 // that "The compiler can only warn and ignore the option if not recognized". 3725 // When building with ccache, it will pass -D options to clang even on 3726 // preprocessed inputs and configure concludes that -fPIC is not supported. 3727 Args.ClaimAllArgs(options::OPT_D); 3728 3729 // Manually translate -O4 to -O3; let clang reject others. 3730 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) { 3731 if (A->getOption().matches(options::OPT_O4)) { 3732 CmdArgs.push_back("-O3"); 3733 D.Diag(diag::warn_O4_is_O3); 3734 } else { 3735 A->render(Args, CmdArgs); 3736 } 3737 } 3738 3739 // Warn about ignored options to clang. 3740 for (const Arg *A : 3741 Args.filtered(options::OPT_clang_ignored_gcc_optimization_f_Group)) { 3742 D.Diag(diag::warn_ignored_gcc_optimization) << A->getAsString(Args); 3743 A->claim(); 3744 } 3745 3746 for (const Arg *A : 3747 Args.filtered(options::OPT_clang_ignored_legacy_options_Group)) { 3748 D.Diag(diag::warn_ignored_clang_option) << A->getAsString(Args); 3749 A->claim(); 3750 } 3751 3752 claimNoWarnArgs(Args); 3753 3754 Args.AddAllArgs(CmdArgs, options::OPT_R_Group); 3755 3756 Args.AddAllArgs(CmdArgs, options::OPT_W_Group); 3757 if (Args.hasFlag(options::OPT_pedantic, options::OPT_no_pedantic, false)) 3758 CmdArgs.push_back("-pedantic"); 3759 Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors); 3760 Args.AddLastArg(CmdArgs, options::OPT_w); 3761 3762 // Fixed point flags 3763 if (Args.hasFlag(options::OPT_ffixed_point, options::OPT_fno_fixed_point, 3764 /*Default=*/false)) 3765 Args.AddLastArg(CmdArgs, options::OPT_ffixed_point); 3766 3767 if (Args.hasFlag(options::OPT_fsame_fbits, 3768 options::OPT_fno_same_fbits, 3769 /*Default=*/false)) 3770 Args.AddLastArg(CmdArgs, options::OPT_fsame_fbits); 3771 3772 // Handle -{std, ansi, trigraphs} -- take the last of -{std, ansi} 3773 // (-ansi is equivalent to -std=c89 or -std=c++98). 3774 // 3775 // If a std is supplied, only add -trigraphs if it follows the 3776 // option. 3777 bool ImplyVCPPCXXVer = false; 3778 if (Arg *Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi)) { 3779 if (Std->getOption().matches(options::OPT_ansi)) 3780 if (types::isCXX(InputType)) 3781 CmdArgs.push_back("-std=c++98"); 3782 else 3783 CmdArgs.push_back("-std=c89"); 3784 else 3785 Std->render(Args, CmdArgs); 3786 3787 // If -f(no-)trigraphs appears after the language standard flag, honor it. 3788 if (Arg *A = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi, 3789 options::OPT_ftrigraphs, 3790 options::OPT_fno_trigraphs)) 3791 if (A != Std) 3792 A->render(Args, CmdArgs); 3793 } else { 3794 // Honor -std-default. 3795 // 3796 // FIXME: Clang doesn't correctly handle -std= when the input language 3797 // doesn't match. For the time being just ignore this for C++ inputs; 3798 // eventually we want to do all the standard defaulting here instead of 3799 // splitting it between the driver and clang -cc1. 3800 if (!types::isCXX(InputType)) 3801 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ, "-std=", 3802 /*Joined=*/true); 3803 else if (IsWindowsMSVC) 3804 ImplyVCPPCXXVer = true; 3805 3806 Args.AddLastArg(CmdArgs, options::OPT_ftrigraphs, 3807 options::OPT_fno_trigraphs); 3808 } 3809 3810 // GCC's behavior for -Wwrite-strings is a bit strange: 3811 // * In C, this "warning flag" changes the types of string literals from 3812 // 'char[N]' to 'const char[N]', and thus triggers an unrelated warning 3813 // for the discarded qualifier. 3814 // * In C++, this is just a normal warning flag. 3815 // 3816 // Implementing this warning correctly in C is hard, so we follow GCC's 3817 // behavior for now. FIXME: Directly diagnose uses of a string literal as 3818 // a non-const char* in C, rather than using this crude hack. 3819 if (!types::isCXX(InputType)) { 3820 // FIXME: This should behave just like a warning flag, and thus should also 3821 // respect -Weverything, -Wno-everything, -Werror=write-strings, and so on. 3822 Arg *WriteStrings = 3823 Args.getLastArg(options::OPT_Wwrite_strings, 3824 options::OPT_Wno_write_strings, options::OPT_w); 3825 if (WriteStrings && 3826 WriteStrings->getOption().matches(options::OPT_Wwrite_strings)) 3827 CmdArgs.push_back("-fconst-strings"); 3828 } 3829 3830 // GCC provides a macro definition '__DEPRECATED' when -Wdeprecated is active 3831 // during C++ compilation, which it is by default. GCC keeps this define even 3832 // in the presence of '-w', match this behavior bug-for-bug. 3833 if (types::isCXX(InputType) && 3834 Args.hasFlag(options::OPT_Wdeprecated, options::OPT_Wno_deprecated, 3835 true)) { 3836 CmdArgs.push_back("-fdeprecated-macro"); 3837 } 3838 3839 // Translate GCC's misnamer '-fasm' arguments to '-fgnu-keywords'. 3840 if (Arg *Asm = Args.getLastArg(options::OPT_fasm, options::OPT_fno_asm)) { 3841 if (Asm->getOption().matches(options::OPT_fasm)) 3842 CmdArgs.push_back("-fgnu-keywords"); 3843 else 3844 CmdArgs.push_back("-fno-gnu-keywords"); 3845 } 3846 3847 if (ShouldDisableDwarfDirectory(Args, getToolChain())) 3848 CmdArgs.push_back("-fno-dwarf-directory-asm"); 3849 3850 if (ShouldDisableAutolink(Args, getToolChain())) 3851 CmdArgs.push_back("-fno-autolink"); 3852 3853 // Add in -fdebug-compilation-dir if necessary. 3854 addDebugCompDirArg(Args, CmdArgs); 3855 3856 for (const Arg *A : Args.filtered(options::OPT_fdebug_prefix_map_EQ)) { 3857 StringRef Map = A->getValue(); 3858 if (Map.find('=') == StringRef::npos) 3859 D.Diag(diag::err_drv_invalid_argument_to_fdebug_prefix_map) << Map; 3860 else 3861 CmdArgs.push_back(Args.MakeArgString("-fdebug-prefix-map=" + Map)); 3862 A->claim(); 3863 } 3864 3865 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_depth_, 3866 options::OPT_ftemplate_depth_EQ)) { 3867 CmdArgs.push_back("-ftemplate-depth"); 3868 CmdArgs.push_back(A->getValue()); 3869 } 3870 3871 if (Arg *A = Args.getLastArg(options::OPT_foperator_arrow_depth_EQ)) { 3872 CmdArgs.push_back("-foperator-arrow-depth"); 3873 CmdArgs.push_back(A->getValue()); 3874 } 3875 3876 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_depth_EQ)) { 3877 CmdArgs.push_back("-fconstexpr-depth"); 3878 CmdArgs.push_back(A->getValue()); 3879 } 3880 3881 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_steps_EQ)) { 3882 CmdArgs.push_back("-fconstexpr-steps"); 3883 CmdArgs.push_back(A->getValue()); 3884 } 3885 3886 if (Arg *A = Args.getLastArg(options::OPT_fbracket_depth_EQ)) { 3887 CmdArgs.push_back("-fbracket-depth"); 3888 CmdArgs.push_back(A->getValue()); 3889 } 3890 3891 if (Arg *A = Args.getLastArg(options::OPT_Wlarge_by_value_copy_EQ, 3892 options::OPT_Wlarge_by_value_copy_def)) { 3893 if (A->getNumValues()) { 3894 StringRef bytes = A->getValue(); 3895 CmdArgs.push_back(Args.MakeArgString("-Wlarge-by-value-copy=" + bytes)); 3896 } else 3897 CmdArgs.push_back("-Wlarge-by-value-copy=64"); // default value 3898 } 3899 3900 if (Args.hasArg(options::OPT_relocatable_pch)) 3901 CmdArgs.push_back("-relocatable-pch"); 3902 3903 if (Arg *A = Args.getLastArg(options::OPT_fconstant_string_class_EQ)) { 3904 CmdArgs.push_back("-fconstant-string-class"); 3905 CmdArgs.push_back(A->getValue()); 3906 } 3907 3908 if (Arg *A = Args.getLastArg(options::OPT_ftabstop_EQ)) { 3909 CmdArgs.push_back("-ftabstop"); 3910 CmdArgs.push_back(A->getValue()); 3911 } 3912 3913 if (Args.hasFlag(options::OPT_fstack_size_section, 3914 options::OPT_fno_stack_size_section, RawTriple.isPS4())) 3915 CmdArgs.push_back("-fstack-size-section"); 3916 3917 CmdArgs.push_back("-ferror-limit"); 3918 if (Arg *A = Args.getLastArg(options::OPT_ferror_limit_EQ)) 3919 CmdArgs.push_back(A->getValue()); 3920 else 3921 CmdArgs.push_back("19"); 3922 3923 if (Arg *A = Args.getLastArg(options::OPT_fmacro_backtrace_limit_EQ)) { 3924 CmdArgs.push_back("-fmacro-backtrace-limit"); 3925 CmdArgs.push_back(A->getValue()); 3926 } 3927 3928 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_backtrace_limit_EQ)) { 3929 CmdArgs.push_back("-ftemplate-backtrace-limit"); 3930 CmdArgs.push_back(A->getValue()); 3931 } 3932 3933 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_backtrace_limit_EQ)) { 3934 CmdArgs.push_back("-fconstexpr-backtrace-limit"); 3935 CmdArgs.push_back(A->getValue()); 3936 } 3937 3938 if (Arg *A = Args.getLastArg(options::OPT_fspell_checking_limit_EQ)) { 3939 CmdArgs.push_back("-fspell-checking-limit"); 3940 CmdArgs.push_back(A->getValue()); 3941 } 3942 3943 // Pass -fmessage-length=. 3944 CmdArgs.push_back("-fmessage-length"); 3945 if (Arg *A = Args.getLastArg(options::OPT_fmessage_length_EQ)) { 3946 CmdArgs.push_back(A->getValue()); 3947 } else { 3948 // If -fmessage-length=N was not specified, determine whether this is a 3949 // terminal and, if so, implicitly define -fmessage-length appropriately. 3950 unsigned N = llvm::sys::Process::StandardErrColumns(); 3951 CmdArgs.push_back(Args.MakeArgString(Twine(N))); 3952 } 3953 3954 // -fvisibility= and -fvisibility-ms-compat are of a piece. 3955 if (const Arg *A = Args.getLastArg(options::OPT_fvisibility_EQ, 3956 options::OPT_fvisibility_ms_compat)) { 3957 if (A->getOption().matches(options::OPT_fvisibility_EQ)) { 3958 CmdArgs.push_back("-fvisibility"); 3959 CmdArgs.push_back(A->getValue()); 3960 } else { 3961 assert(A->getOption().matches(options::OPT_fvisibility_ms_compat)); 3962 CmdArgs.push_back("-fvisibility"); 3963 CmdArgs.push_back("hidden"); 3964 CmdArgs.push_back("-ftype-visibility"); 3965 CmdArgs.push_back("default"); 3966 } 3967 } 3968 3969 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden); 3970 3971 Args.AddLastArg(CmdArgs, options::OPT_ftlsmodel_EQ); 3972 3973 // Forward -f (flag) options which we can pass directly. 3974 Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls); 3975 Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions); 3976 Args.AddLastArg(CmdArgs, options::OPT_fno_operator_names); 3977 Args.AddLastArg(CmdArgs, options::OPT_femulated_tls, 3978 options::OPT_fno_emulated_tls); 3979 3980 // AltiVec-like language extensions aren't relevant for assembling. 3981 if (!isa<PreprocessJobAction>(JA) || Output.getType() != types::TY_PP_Asm) 3982 Args.AddLastArg(CmdArgs, options::OPT_fzvector); 3983 3984 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_show_template_tree); 3985 Args.AddLastArg(CmdArgs, options::OPT_fno_elide_type); 3986 3987 // Forward flags for OpenMP. We don't do this if the current action is an 3988 // device offloading action other than OpenMP. 3989 if (Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ, 3990 options::OPT_fno_openmp, false) && 3991 (JA.isDeviceOffloading(Action::OFK_None) || 3992 JA.isDeviceOffloading(Action::OFK_OpenMP))) { 3993 switch (D.getOpenMPRuntime(Args)) { 3994 case Driver::OMPRT_OMP: 3995 case Driver::OMPRT_IOMP5: 3996 // Clang can generate useful OpenMP code for these two runtime libraries. 3997 CmdArgs.push_back("-fopenmp"); 3998 3999 // If no option regarding the use of TLS in OpenMP codegeneration is 4000 // given, decide a default based on the target. Otherwise rely on the 4001 // options and pass the right information to the frontend. 4002 if (!Args.hasFlag(options::OPT_fopenmp_use_tls, 4003 options::OPT_fnoopenmp_use_tls, /*Default=*/true)) 4004 CmdArgs.push_back("-fnoopenmp-use-tls"); 4005 Args.AddLastArg(CmdArgs, options::OPT_fopenmp_simd, 4006 options::OPT_fno_openmp_simd); 4007 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_version_EQ); 4008 4009 // When in OpenMP offloading mode with NVPTX target, forward 4010 // cuda-mode flag 4011 Args.AddLastArg(CmdArgs, options::OPT_fopenmp_cuda_mode, 4012 options::OPT_fno_openmp_cuda_mode); 4013 break; 4014 default: 4015 // By default, if Clang doesn't know how to generate useful OpenMP code 4016 // for a specific runtime library, we just don't pass the '-fopenmp' flag 4017 // down to the actual compilation. 4018 // FIXME: It would be better to have a mode which *only* omits IR 4019 // generation based on the OpenMP support so that we get consistent 4020 // semantic analysis, etc. 4021 break; 4022 } 4023 } else { 4024 Args.AddLastArg(CmdArgs, options::OPT_fopenmp_simd, 4025 options::OPT_fno_openmp_simd); 4026 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_version_EQ); 4027 } 4028 4029 const SanitizerArgs &Sanitize = getToolChain().getSanitizerArgs(); 4030 Sanitize.addArgs(getToolChain(), Args, CmdArgs, InputType); 4031 4032 const XRayArgs &XRay = getToolChain().getXRayArgs(); 4033 XRay.addArgs(getToolChain(), Args, CmdArgs, InputType); 4034 4035 if (getToolChain().SupportsProfiling()) 4036 Args.AddLastArg(CmdArgs, options::OPT_pg); 4037 4038 if (getToolChain().SupportsProfiling()) 4039 Args.AddLastArg(CmdArgs, options::OPT_mfentry); 4040 4041 // -flax-vector-conversions is default. 4042 if (!Args.hasFlag(options::OPT_flax_vector_conversions, 4043 options::OPT_fno_lax_vector_conversions)) 4044 CmdArgs.push_back("-fno-lax-vector-conversions"); 4045 4046 if (Args.getLastArg(options::OPT_fapple_kext) || 4047 (Args.hasArg(options::OPT_mkernel) && types::isCXX(InputType))) 4048 CmdArgs.push_back("-fapple-kext"); 4049 4050 Args.AddLastArg(CmdArgs, options::OPT_fobjc_sender_dependent_dispatch); 4051 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_print_source_range_info); 4052 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_parseable_fixits); 4053 Args.AddLastArg(CmdArgs, options::OPT_ftime_report); 4054 Args.AddLastArg(CmdArgs, options::OPT_ftrapv); 4055 4056 if (Arg *A = Args.getLastArg(options::OPT_ftrapv_handler_EQ)) { 4057 CmdArgs.push_back("-ftrapv-handler"); 4058 CmdArgs.push_back(A->getValue()); 4059 } 4060 4061 Args.AddLastArg(CmdArgs, options::OPT_ftrap_function_EQ); 4062 4063 // -fno-strict-overflow implies -fwrapv if it isn't disabled, but 4064 // -fstrict-overflow won't turn off an explicitly enabled -fwrapv. 4065 if (Arg *A = Args.getLastArg(options::OPT_fwrapv, options::OPT_fno_wrapv)) { 4066 if (A->getOption().matches(options::OPT_fwrapv)) 4067 CmdArgs.push_back("-fwrapv"); 4068 } else if (Arg *A = Args.getLastArg(options::OPT_fstrict_overflow, 4069 options::OPT_fno_strict_overflow)) { 4070 if (A->getOption().matches(options::OPT_fno_strict_overflow)) 4071 CmdArgs.push_back("-fwrapv"); 4072 } 4073 4074 if (Arg *A = Args.getLastArg(options::OPT_freroll_loops, 4075 options::OPT_fno_reroll_loops)) 4076 if (A->getOption().matches(options::OPT_freroll_loops)) 4077 CmdArgs.push_back("-freroll-loops"); 4078 4079 Args.AddLastArg(CmdArgs, options::OPT_fwritable_strings); 4080 Args.AddLastArg(CmdArgs, options::OPT_funroll_loops, 4081 options::OPT_fno_unroll_loops); 4082 4083 Args.AddLastArg(CmdArgs, options::OPT_pthread); 4084 4085 RenderSSPOptions(getToolChain(), Args, CmdArgs, KernelOrKext); 4086 4087 // Translate -mstackrealign 4088 if (Args.hasFlag(options::OPT_mstackrealign, options::OPT_mno_stackrealign, 4089 false)) 4090 CmdArgs.push_back(Args.MakeArgString("-mstackrealign")); 4091 4092 if (Args.hasArg(options::OPT_mstack_alignment)) { 4093 StringRef alignment = Args.getLastArgValue(options::OPT_mstack_alignment); 4094 CmdArgs.push_back(Args.MakeArgString("-mstack-alignment=" + alignment)); 4095 } 4096 4097 if (Args.hasArg(options::OPT_mstack_probe_size)) { 4098 StringRef Size = Args.getLastArgValue(options::OPT_mstack_probe_size); 4099 4100 if (!Size.empty()) 4101 CmdArgs.push_back(Args.MakeArgString("-mstack-probe-size=" + Size)); 4102 else 4103 CmdArgs.push_back("-mstack-probe-size=0"); 4104 } 4105 4106 if (!Args.hasFlag(options::OPT_mstack_arg_probe, 4107 options::OPT_mno_stack_arg_probe, true)) 4108 CmdArgs.push_back(Args.MakeArgString("-mno-stack-arg-probe")); 4109 4110 if (Arg *A = Args.getLastArg(options::OPT_mrestrict_it, 4111 options::OPT_mno_restrict_it)) { 4112 if (A->getOption().matches(options::OPT_mrestrict_it)) { 4113 CmdArgs.push_back("-mllvm"); 4114 CmdArgs.push_back("-arm-restrict-it"); 4115 } else { 4116 CmdArgs.push_back("-mllvm"); 4117 CmdArgs.push_back("-arm-no-restrict-it"); 4118 } 4119 } else if (Triple.isOSWindows() && 4120 (Triple.getArch() == llvm::Triple::arm || 4121 Triple.getArch() == llvm::Triple::thumb)) { 4122 // Windows on ARM expects restricted IT blocks 4123 CmdArgs.push_back("-mllvm"); 4124 CmdArgs.push_back("-arm-restrict-it"); 4125 } 4126 4127 // Forward -cl options to -cc1 4128 RenderOpenCLOptions(Args, CmdArgs); 4129 4130 if (Arg *A = Args.getLastArg(options::OPT_fcf_protection_EQ)) { 4131 CmdArgs.push_back( 4132 Args.MakeArgString(Twine("-fcf-protection=") + A->getValue())); 4133 } 4134 4135 // Forward -f options with positive and negative forms; we translate 4136 // these by hand. 4137 if (Arg *A = getLastProfileSampleUseArg(Args)) { 4138 StringRef fname = A->getValue(); 4139 if (!llvm::sys::fs::exists(fname)) 4140 D.Diag(diag::err_drv_no_such_file) << fname; 4141 else 4142 A->render(Args, CmdArgs); 4143 } 4144 4145 RenderBuiltinOptions(getToolChain(), RawTriple, Args, CmdArgs); 4146 4147 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new, 4148 options::OPT_fno_assume_sane_operator_new)) 4149 CmdArgs.push_back("-fno-assume-sane-operator-new"); 4150 4151 // -fblocks=0 is default. 4152 if (Args.hasFlag(options::OPT_fblocks, options::OPT_fno_blocks, 4153 getToolChain().IsBlocksDefault()) || 4154 (Args.hasArg(options::OPT_fgnu_runtime) && 4155 Args.hasArg(options::OPT_fobjc_nonfragile_abi) && 4156 !Args.hasArg(options::OPT_fno_blocks))) { 4157 CmdArgs.push_back("-fblocks"); 4158 4159 if (!Args.hasArg(options::OPT_fgnu_runtime) && 4160 !getToolChain().hasBlocksRuntime()) 4161 CmdArgs.push_back("-fblocks-runtime-optional"); 4162 } 4163 4164 // -fencode-extended-block-signature=1 is default. 4165 if (getToolChain().IsEncodeExtendedBlockSignatureDefault()) 4166 CmdArgs.push_back("-fencode-extended-block-signature"); 4167 4168 if (Args.hasFlag(options::OPT_fcoroutines_ts, options::OPT_fno_coroutines_ts, 4169 false) && 4170 types::isCXX(InputType)) { 4171 CmdArgs.push_back("-fcoroutines-ts"); 4172 } 4173 4174 Args.AddLastArg(CmdArgs, options::OPT_fdouble_square_bracket_attributes, 4175 options::OPT_fno_double_square_bracket_attributes); 4176 4177 bool HaveModules = false; 4178 RenderModulesOptions(C, D, Args, Input, Output, CmdArgs, HaveModules); 4179 4180 // -faccess-control is default. 4181 if (Args.hasFlag(options::OPT_fno_access_control, 4182 options::OPT_faccess_control, false)) 4183 CmdArgs.push_back("-fno-access-control"); 4184 4185 // -felide-constructors is the default. 4186 if (Args.hasFlag(options::OPT_fno_elide_constructors, 4187 options::OPT_felide_constructors, false)) 4188 CmdArgs.push_back("-fno-elide-constructors"); 4189 4190 ToolChain::RTTIMode RTTIMode = getToolChain().getRTTIMode(); 4191 4192 if (KernelOrKext || (types::isCXX(InputType) && 4193 (RTTIMode == ToolChain::RM_Disabled))) 4194 CmdArgs.push_back("-fno-rtti"); 4195 4196 // -fshort-enums=0 is default for all architectures except Hexagon. 4197 if (Args.hasFlag(options::OPT_fshort_enums, options::OPT_fno_short_enums, 4198 getToolChain().getArch() == llvm::Triple::hexagon)) 4199 CmdArgs.push_back("-fshort-enums"); 4200 4201 RenderCharacterOptions(Args, AuxTriple ? *AuxTriple : RawTriple, CmdArgs); 4202 4203 // -fuse-cxa-atexit is default. 4204 if (!Args.hasFlag( 4205 options::OPT_fuse_cxa_atexit, options::OPT_fno_use_cxa_atexit, 4206 !RawTriple.isOSWindows() && 4207 RawTriple.getOS() != llvm::Triple::Solaris && 4208 getToolChain().getArch() != llvm::Triple::hexagon && 4209 getToolChain().getArch() != llvm::Triple::xcore && 4210 ((RawTriple.getVendor() != llvm::Triple::MipsTechnologies) || 4211 RawTriple.hasEnvironment())) || 4212 KernelOrKext) 4213 CmdArgs.push_back("-fno-use-cxa-atexit"); 4214 4215 if (Args.hasFlag(options::OPT_fregister_global_dtors_with_atexit, 4216 options::OPT_fno_register_global_dtors_with_atexit, 4217 RawTriple.isOSDarwin() && !KernelOrKext)) 4218 CmdArgs.push_back("-fregister-global-dtors-with-atexit"); 4219 4220 // -fms-extensions=0 is default. 4221 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions, 4222 IsWindowsMSVC)) 4223 CmdArgs.push_back("-fms-extensions"); 4224 4225 // -fno-use-line-directives is default. 4226 if (Args.hasFlag(options::OPT_fuse_line_directives, 4227 options::OPT_fno_use_line_directives, false)) 4228 CmdArgs.push_back("-fuse-line-directives"); 4229 4230 // -fms-compatibility=0 is default. 4231 if (Args.hasFlag(options::OPT_fms_compatibility, 4232 options::OPT_fno_ms_compatibility, 4233 (IsWindowsMSVC && 4234 Args.hasFlag(options::OPT_fms_extensions, 4235 options::OPT_fno_ms_extensions, true)))) 4236 CmdArgs.push_back("-fms-compatibility"); 4237 4238 VersionTuple MSVT = getToolChain().computeMSVCVersion(&D, Args); 4239 if (!MSVT.empty()) 4240 CmdArgs.push_back( 4241 Args.MakeArgString("-fms-compatibility-version=" + MSVT.getAsString())); 4242 4243 bool IsMSVC2015Compatible = MSVT.getMajor() >= 19; 4244 if (ImplyVCPPCXXVer) { 4245 StringRef LanguageStandard; 4246 if (const Arg *StdArg = Args.getLastArg(options::OPT__SLASH_std)) { 4247 LanguageStandard = llvm::StringSwitch<StringRef>(StdArg->getValue()) 4248 .Case("c++14", "-std=c++14") 4249 .Case("c++17", "-std=c++17") 4250 .Case("c++latest", "-std=c++2a") 4251 .Default(""); 4252 if (LanguageStandard.empty()) 4253 D.Diag(clang::diag::warn_drv_unused_argument) 4254 << StdArg->getAsString(Args); 4255 } 4256 4257 if (LanguageStandard.empty()) { 4258 if (IsMSVC2015Compatible) 4259 LanguageStandard = "-std=c++14"; 4260 else 4261 LanguageStandard = "-std=c++11"; 4262 } 4263 4264 CmdArgs.push_back(LanguageStandard.data()); 4265 } 4266 4267 // -fno-borland-extensions is default. 4268 if (Args.hasFlag(options::OPT_fborland_extensions, 4269 options::OPT_fno_borland_extensions, false)) 4270 CmdArgs.push_back("-fborland-extensions"); 4271 4272 // -fno-declspec is default, except for PS4. 4273 if (Args.hasFlag(options::OPT_fdeclspec, options::OPT_fno_declspec, 4274 RawTriple.isPS4())) 4275 CmdArgs.push_back("-fdeclspec"); 4276 else if (Args.hasArg(options::OPT_fno_declspec)) 4277 CmdArgs.push_back("-fno-declspec"); // Explicitly disabling __declspec. 4278 4279 // -fthreadsafe-static is default, except for MSVC compatibility versions less 4280 // than 19. 4281 if (!Args.hasFlag(options::OPT_fthreadsafe_statics, 4282 options::OPT_fno_threadsafe_statics, 4283 !IsWindowsMSVC || IsMSVC2015Compatible)) 4284 CmdArgs.push_back("-fno-threadsafe-statics"); 4285 4286 // -fno-delayed-template-parsing is default, except when targeting MSVC. 4287 // Many old Windows SDK versions require this to parse. 4288 // FIXME: MSVC introduced /Zc:twoPhase- to disable this behavior in their 4289 // compiler. We should be able to disable this by default at some point. 4290 if (Args.hasFlag(options::OPT_fdelayed_template_parsing, 4291 options::OPT_fno_delayed_template_parsing, IsWindowsMSVC)) 4292 CmdArgs.push_back("-fdelayed-template-parsing"); 4293 4294 // -fgnu-keywords default varies depending on language; only pass if 4295 // specified. 4296 if (Arg *A = Args.getLastArg(options::OPT_fgnu_keywords, 4297 options::OPT_fno_gnu_keywords)) 4298 A->render(Args, CmdArgs); 4299 4300 if (Args.hasFlag(options::OPT_fgnu89_inline, options::OPT_fno_gnu89_inline, 4301 false)) 4302 CmdArgs.push_back("-fgnu89-inline"); 4303 4304 if (Args.hasArg(options::OPT_fno_inline)) 4305 CmdArgs.push_back("-fno-inline"); 4306 4307 if (Arg* InlineArg = Args.getLastArg(options::OPT_finline_functions, 4308 options::OPT_finline_hint_functions, 4309 options::OPT_fno_inline_functions)) 4310 InlineArg->render(Args, CmdArgs); 4311 4312 Args.AddLastArg(CmdArgs, options::OPT_fexperimental_new_pass_manager, 4313 options::OPT_fno_experimental_new_pass_manager); 4314 4315 ObjCRuntime Runtime = AddObjCRuntimeArgs(Args, CmdArgs, rewriteKind); 4316 RenderObjCOptions(getToolChain(), D, RawTriple, Args, Runtime, 4317 rewriteKind != RK_None, Input, CmdArgs); 4318 4319 if (Args.hasFlag(options::OPT_fapplication_extension, 4320 options::OPT_fno_application_extension, false)) 4321 CmdArgs.push_back("-fapplication-extension"); 4322 4323 // Handle GCC-style exception args. 4324 if (!C.getDriver().IsCLMode()) 4325 addExceptionArgs(Args, InputType, getToolChain(), KernelOrKext, Runtime, 4326 CmdArgs); 4327 4328 // Handle exception personalities 4329 Arg *A = Args.getLastArg(options::OPT_fsjlj_exceptions, 4330 options::OPT_fseh_exceptions, 4331 options::OPT_fdwarf_exceptions); 4332 if (A) { 4333 const Option &Opt = A->getOption(); 4334 if (Opt.matches(options::OPT_fsjlj_exceptions)) 4335 CmdArgs.push_back("-fsjlj-exceptions"); 4336 if (Opt.matches(options::OPT_fseh_exceptions)) 4337 CmdArgs.push_back("-fseh-exceptions"); 4338 if (Opt.matches(options::OPT_fdwarf_exceptions)) 4339 CmdArgs.push_back("-fdwarf-exceptions"); 4340 } else { 4341 switch (getToolChain().GetExceptionModel(Args)) { 4342 default: 4343 break; 4344 case llvm::ExceptionHandling::DwarfCFI: 4345 CmdArgs.push_back("-fdwarf-exceptions"); 4346 break; 4347 case llvm::ExceptionHandling::SjLj: 4348 CmdArgs.push_back("-fsjlj-exceptions"); 4349 break; 4350 case llvm::ExceptionHandling::WinEH: 4351 CmdArgs.push_back("-fseh-exceptions"); 4352 break; 4353 } 4354 } 4355 4356 // C++ "sane" operator new. 4357 if (!Args.hasFlag(options::OPT_fassume_sane_operator_new, 4358 options::OPT_fno_assume_sane_operator_new)) 4359 CmdArgs.push_back("-fno-assume-sane-operator-new"); 4360 4361 // -frelaxed-template-template-args is off by default, as it is a severe 4362 // breaking change until a corresponding change to template partial ordering 4363 // is provided. 4364 if (Args.hasFlag(options::OPT_frelaxed_template_template_args, 4365 options::OPT_fno_relaxed_template_template_args, false)) 4366 CmdArgs.push_back("-frelaxed-template-template-args"); 4367 4368 // -fsized-deallocation is off by default, as it is an ABI-breaking change for 4369 // most platforms. 4370 if (Args.hasFlag(options::OPT_fsized_deallocation, 4371 options::OPT_fno_sized_deallocation, false)) 4372 CmdArgs.push_back("-fsized-deallocation"); 4373 4374 // -faligned-allocation is on by default in C++17 onwards and otherwise off 4375 // by default. 4376 if (Arg *A = Args.getLastArg(options::OPT_faligned_allocation, 4377 options::OPT_fno_aligned_allocation, 4378 options::OPT_faligned_new_EQ)) { 4379 if (A->getOption().matches(options::OPT_fno_aligned_allocation)) 4380 CmdArgs.push_back("-fno-aligned-allocation"); 4381 else 4382 CmdArgs.push_back("-faligned-allocation"); 4383 } 4384 4385 // The default new alignment can be specified using a dedicated option or via 4386 // a GCC-compatible option that also turns on aligned allocation. 4387 if (Arg *A = Args.getLastArg(options::OPT_fnew_alignment_EQ, 4388 options::OPT_faligned_new_EQ)) 4389 CmdArgs.push_back( 4390 Args.MakeArgString(Twine("-fnew-alignment=") + A->getValue())); 4391 4392 // -fconstant-cfstrings is default, and may be subject to argument translation 4393 // on Darwin. 4394 if (!Args.hasFlag(options::OPT_fconstant_cfstrings, 4395 options::OPT_fno_constant_cfstrings) || 4396 !Args.hasFlag(options::OPT_mconstant_cfstrings, 4397 options::OPT_mno_constant_cfstrings)) 4398 CmdArgs.push_back("-fno-constant-cfstrings"); 4399 4400 // -fno-pascal-strings is default, only pass non-default. 4401 if (Args.hasFlag(options::OPT_fpascal_strings, 4402 options::OPT_fno_pascal_strings, false)) 4403 CmdArgs.push_back("-fpascal-strings"); 4404 4405 // Honor -fpack-struct= and -fpack-struct, if given. Note that 4406 // -fno-pack-struct doesn't apply to -fpack-struct=. 4407 if (Arg *A = Args.getLastArg(options::OPT_fpack_struct_EQ)) { 4408 std::string PackStructStr = "-fpack-struct="; 4409 PackStructStr += A->getValue(); 4410 CmdArgs.push_back(Args.MakeArgString(PackStructStr)); 4411 } else if (Args.hasFlag(options::OPT_fpack_struct, 4412 options::OPT_fno_pack_struct, false)) { 4413 CmdArgs.push_back("-fpack-struct=1"); 4414 } 4415 4416 // Handle -fmax-type-align=N and -fno-type-align 4417 bool SkipMaxTypeAlign = Args.hasArg(options::OPT_fno_max_type_align); 4418 if (Arg *A = Args.getLastArg(options::OPT_fmax_type_align_EQ)) { 4419 if (!SkipMaxTypeAlign) { 4420 std::string MaxTypeAlignStr = "-fmax-type-align="; 4421 MaxTypeAlignStr += A->getValue(); 4422 CmdArgs.push_back(Args.MakeArgString(MaxTypeAlignStr)); 4423 } 4424 } else if (RawTriple.isOSDarwin()) { 4425 if (!SkipMaxTypeAlign) { 4426 std::string MaxTypeAlignStr = "-fmax-type-align=16"; 4427 CmdArgs.push_back(Args.MakeArgString(MaxTypeAlignStr)); 4428 } 4429 } 4430 4431 if (!Args.hasFlag(options::OPT_Qy, options::OPT_Qn, true)) 4432 CmdArgs.push_back("-Qn"); 4433 4434 // -fcommon is the default unless compiling kernel code or the target says so 4435 bool NoCommonDefault = KernelOrKext || isNoCommonDefault(RawTriple); 4436 if (!Args.hasFlag(options::OPT_fcommon, options::OPT_fno_common, 4437 !NoCommonDefault)) 4438 CmdArgs.push_back("-fno-common"); 4439 4440 // -fsigned-bitfields is default, and clang doesn't yet support 4441 // -funsigned-bitfields. 4442 if (!Args.hasFlag(options::OPT_fsigned_bitfields, 4443 options::OPT_funsigned_bitfields)) 4444 D.Diag(diag::warn_drv_clang_unsupported) 4445 << Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args); 4446 4447 // -fsigned-bitfields is default, and clang doesn't support -fno-for-scope. 4448 if (!Args.hasFlag(options::OPT_ffor_scope, options::OPT_fno_for_scope)) 4449 D.Diag(diag::err_drv_clang_unsupported) 4450 << Args.getLastArg(options::OPT_fno_for_scope)->getAsString(Args); 4451 4452 // -finput_charset=UTF-8 is default. Reject others 4453 if (Arg *inputCharset = Args.getLastArg(options::OPT_finput_charset_EQ)) { 4454 StringRef value = inputCharset->getValue(); 4455 if (!value.equals_lower("utf-8")) 4456 D.Diag(diag::err_drv_invalid_value) << inputCharset->getAsString(Args) 4457 << value; 4458 } 4459 4460 // -fexec_charset=UTF-8 is default. Reject others 4461 if (Arg *execCharset = Args.getLastArg(options::OPT_fexec_charset_EQ)) { 4462 StringRef value = execCharset->getValue(); 4463 if (!value.equals_lower("utf-8")) 4464 D.Diag(diag::err_drv_invalid_value) << execCharset->getAsString(Args) 4465 << value; 4466 } 4467 4468 RenderDiagnosticsOptions(D, Args, CmdArgs); 4469 4470 // -fno-asm-blocks is default. 4471 if (Args.hasFlag(options::OPT_fasm_blocks, options::OPT_fno_asm_blocks, 4472 false)) 4473 CmdArgs.push_back("-fasm-blocks"); 4474 4475 // -fgnu-inline-asm is default. 4476 if (!Args.hasFlag(options::OPT_fgnu_inline_asm, 4477 options::OPT_fno_gnu_inline_asm, true)) 4478 CmdArgs.push_back("-fno-gnu-inline-asm"); 4479 4480 // Enable vectorization per default according to the optimization level 4481 // selected. For optimization levels that want vectorization we use the alias 4482 // option to simplify the hasFlag logic. 4483 bool EnableVec = shouldEnableVectorizerAtOLevel(Args, false); 4484 OptSpecifier VectorizeAliasOption = 4485 EnableVec ? options::OPT_O_Group : options::OPT_fvectorize; 4486 if (Args.hasFlag(options::OPT_fvectorize, VectorizeAliasOption, 4487 options::OPT_fno_vectorize, EnableVec)) 4488 CmdArgs.push_back("-vectorize-loops"); 4489 4490 // -fslp-vectorize is enabled based on the optimization level selected. 4491 bool EnableSLPVec = shouldEnableVectorizerAtOLevel(Args, true); 4492 OptSpecifier SLPVectAliasOption = 4493 EnableSLPVec ? options::OPT_O_Group : options::OPT_fslp_vectorize; 4494 if (Args.hasFlag(options::OPT_fslp_vectorize, SLPVectAliasOption, 4495 options::OPT_fno_slp_vectorize, EnableSLPVec)) 4496 CmdArgs.push_back("-vectorize-slp"); 4497 4498 ParseMPreferVectorWidth(D, Args, CmdArgs); 4499 4500 if (Arg *A = Args.getLastArg(options::OPT_fshow_overloads_EQ)) 4501 A->render(Args, CmdArgs); 4502 4503 if (Arg *A = Args.getLastArg( 4504 options::OPT_fsanitize_undefined_strip_path_components_EQ)) 4505 A->render(Args, CmdArgs); 4506 4507 // -fdollars-in-identifiers default varies depending on platform and 4508 // language; only pass if specified. 4509 if (Arg *A = Args.getLastArg(options::OPT_fdollars_in_identifiers, 4510 options::OPT_fno_dollars_in_identifiers)) { 4511 if (A->getOption().matches(options::OPT_fdollars_in_identifiers)) 4512 CmdArgs.push_back("-fdollars-in-identifiers"); 4513 else 4514 CmdArgs.push_back("-fno-dollars-in-identifiers"); 4515 } 4516 4517 // -funit-at-a-time is default, and we don't support -fno-unit-at-a-time for 4518 // practical purposes. 4519 if (Arg *A = Args.getLastArg(options::OPT_funit_at_a_time, 4520 options::OPT_fno_unit_at_a_time)) { 4521 if (A->getOption().matches(options::OPT_fno_unit_at_a_time)) 4522 D.Diag(diag::warn_drv_clang_unsupported) << A->getAsString(Args); 4523 } 4524 4525 if (Args.hasFlag(options::OPT_fapple_pragma_pack, 4526 options::OPT_fno_apple_pragma_pack, false)) 4527 CmdArgs.push_back("-fapple-pragma-pack"); 4528 4529 if (Args.hasFlag(options::OPT_fsave_optimization_record, 4530 options::OPT_foptimization_record_file_EQ, 4531 options::OPT_fno_save_optimization_record, false)) { 4532 CmdArgs.push_back("-opt-record-file"); 4533 4534 const Arg *A = Args.getLastArg(options::OPT_foptimization_record_file_EQ); 4535 if (A) { 4536 CmdArgs.push_back(A->getValue()); 4537 } else { 4538 SmallString<128> F; 4539 4540 if (Args.hasArg(options::OPT_c) || Args.hasArg(options::OPT_S)) { 4541 if (Arg *FinalOutput = Args.getLastArg(options::OPT_o)) 4542 F = FinalOutput->getValue(); 4543 } 4544 4545 if (F.empty()) { 4546 // Use the input filename. 4547 F = llvm::sys::path::stem(Input.getBaseInput()); 4548 4549 // If we're compiling for an offload architecture (i.e. a CUDA device), 4550 // we need to make the file name for the device compilation different 4551 // from the host compilation. 4552 if (!JA.isDeviceOffloading(Action::OFK_None) && 4553 !JA.isDeviceOffloading(Action::OFK_Host)) { 4554 llvm::sys::path::replace_extension(F, ""); 4555 F += Action::GetOffloadingFileNamePrefix(JA.getOffloadingDeviceKind(), 4556 Triple.normalize()); 4557 F += "-"; 4558 F += JA.getOffloadingArch(); 4559 } 4560 } 4561 4562 llvm::sys::path::replace_extension(F, "opt.yaml"); 4563 CmdArgs.push_back(Args.MakeArgString(F)); 4564 } 4565 } 4566 4567 bool RewriteImports = Args.hasFlag(options::OPT_frewrite_imports, 4568 options::OPT_fno_rewrite_imports, false); 4569 if (RewriteImports) 4570 CmdArgs.push_back("-frewrite-imports"); 4571 4572 // Enable rewrite includes if the user's asked for it or if we're generating 4573 // diagnostics. 4574 // TODO: Once -module-dependency-dir works with -frewrite-includes it'd be 4575 // nice to enable this when doing a crashdump for modules as well. 4576 if (Args.hasFlag(options::OPT_frewrite_includes, 4577 options::OPT_fno_rewrite_includes, false) || 4578 (C.isForDiagnostics() && (RewriteImports || !HaveModules))) 4579 CmdArgs.push_back("-frewrite-includes"); 4580 4581 // Only allow -traditional or -traditional-cpp outside in preprocessing modes. 4582 if (Arg *A = Args.getLastArg(options::OPT_traditional, 4583 options::OPT_traditional_cpp)) { 4584 if (isa<PreprocessJobAction>(JA)) 4585 CmdArgs.push_back("-traditional-cpp"); 4586 else 4587 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args); 4588 } 4589 4590 Args.AddLastArg(CmdArgs, options::OPT_dM); 4591 Args.AddLastArg(CmdArgs, options::OPT_dD); 4592 4593 // Handle serialized diagnostics. 4594 if (Arg *A = Args.getLastArg(options::OPT__serialize_diags)) { 4595 CmdArgs.push_back("-serialize-diagnostic-file"); 4596 CmdArgs.push_back(Args.MakeArgString(A->getValue())); 4597 } 4598 4599 if (Args.hasArg(options::OPT_fretain_comments_from_system_headers)) 4600 CmdArgs.push_back("-fretain-comments-from-system-headers"); 4601 4602 // Forward -fcomment-block-commands to -cc1. 4603 Args.AddAllArgs(CmdArgs, options::OPT_fcomment_block_commands); 4604 // Forward -fparse-all-comments to -cc1. 4605 Args.AddAllArgs(CmdArgs, options::OPT_fparse_all_comments); 4606 4607 // Turn -fplugin=name.so into -load name.so 4608 for (const Arg *A : Args.filtered(options::OPT_fplugin_EQ)) { 4609 CmdArgs.push_back("-load"); 4610 CmdArgs.push_back(A->getValue()); 4611 A->claim(); 4612 } 4613 4614 // Setup statistics file output. 4615 SmallString<128> StatsFile = getStatsFileName(Args, Output, Input, D); 4616 if (!StatsFile.empty()) 4617 CmdArgs.push_back(Args.MakeArgString(Twine("-stats-file=") + StatsFile)); 4618 4619 // Forward -Xclang arguments to -cc1, and -mllvm arguments to the LLVM option 4620 // parser. 4621 // -finclude-default-header flag is for preprocessor, 4622 // do not pass it to other cc1 commands when save-temps is enabled 4623 if (C.getDriver().isSaveTempsEnabled() && 4624 !isa<PreprocessJobAction>(JA)) { 4625 for (auto Arg : Args.filtered(options::OPT_Xclang)) { 4626 Arg->claim(); 4627 if (StringRef(Arg->getValue()) != "-finclude-default-header") 4628 CmdArgs.push_back(Arg->getValue()); 4629 } 4630 } 4631 else { 4632 Args.AddAllArgValues(CmdArgs, options::OPT_Xclang); 4633 } 4634 for (const Arg *A : Args.filtered(options::OPT_mllvm)) { 4635 A->claim(); 4636 4637 // We translate this by hand to the -cc1 argument, since nightly test uses 4638 // it and developers have been trained to spell it with -mllvm. Both 4639 // spellings are now deprecated and should be removed. 4640 if (StringRef(A->getValue(0)) == "-disable-llvm-optzns") { 4641 CmdArgs.push_back("-disable-llvm-optzns"); 4642 } else { 4643 A->render(Args, CmdArgs); 4644 } 4645 } 4646 4647 // With -save-temps, we want to save the unoptimized bitcode output from the 4648 // CompileJobAction, use -disable-llvm-passes to get pristine IR generated 4649 // by the frontend. 4650 // When -fembed-bitcode is enabled, optimized bitcode is emitted because it 4651 // has slightly different breakdown between stages. 4652 // FIXME: -fembed-bitcode -save-temps will save optimized bitcode instead of 4653 // pristine IR generated by the frontend. Ideally, a new compile action should 4654 // be added so both IR can be captured. 4655 if (C.getDriver().isSaveTempsEnabled() && 4656 !(C.getDriver().embedBitcodeInObject() && !C.getDriver().isUsingLTO()) && 4657 isa<CompileJobAction>(JA)) 4658 CmdArgs.push_back("-disable-llvm-passes"); 4659 4660 if (Output.getType() == types::TY_Dependencies) { 4661 // Handled with other dependency code. 4662 } else if (Output.isFilename()) { 4663 CmdArgs.push_back("-o"); 4664 CmdArgs.push_back(Output.getFilename()); 4665 } else { 4666 assert(Output.isNothing() && "Invalid output."); 4667 } 4668 4669 addDashXForInput(Args, Input, CmdArgs); 4670 4671 if (Input.isFilename()) 4672 CmdArgs.push_back(Input.getFilename()); 4673 else 4674 Input.getInputArg().renderAsInput(Args, CmdArgs); 4675 4676 Args.AddAllArgs(CmdArgs, options::OPT_undef); 4677 4678 const char *Exec = D.getClangProgramPath(); 4679 4680 // Optionally embed the -cc1 level arguments into the debug info, for build 4681 // analysis. 4682 // Also record command line arguments into the debug info if 4683 // -grecord-gcc-switches options is set on. 4684 // By default, -gno-record-gcc-switches is set on and no recording. 4685 if (getToolChain().UseDwarfDebugFlags() || 4686 Args.hasFlag(options::OPT_grecord_gcc_switches, 4687 options::OPT_gno_record_gcc_switches, false)) { 4688 ArgStringList OriginalArgs; 4689 for (const auto &Arg : Args) 4690 Arg->render(Args, OriginalArgs); 4691 4692 SmallString<256> Flags; 4693 Flags += Exec; 4694 for (const char *OriginalArg : OriginalArgs) { 4695 SmallString<128> EscapedArg; 4696 EscapeSpacesAndBackslashes(OriginalArg, EscapedArg); 4697 Flags += " "; 4698 Flags += EscapedArg; 4699 } 4700 CmdArgs.push_back("-dwarf-debug-flags"); 4701 CmdArgs.push_back(Args.MakeArgString(Flags)); 4702 } 4703 4704 if (IsCuda) { 4705 // Host-side cuda compilation receives all device-side outputs in a single 4706 // fatbin as Inputs[1]. Include the binary with -fcuda-include-gpubinary. 4707 if (Inputs.size() > 1) { 4708 assert(Inputs.size() == 2 && "More than one GPU binary!"); 4709 CmdArgs.push_back("-fcuda-include-gpubinary"); 4710 CmdArgs.push_back(Inputs[1].getFilename()); 4711 } 4712 4713 if (Args.hasFlag(options::OPT_fcuda_rdc, options::OPT_fno_cuda_rdc, false)) 4714 CmdArgs.push_back("-fcuda-rdc"); 4715 if (Args.hasFlag(options::OPT_fcuda_short_ptr, 4716 options::OPT_fno_cuda_short_ptr, false)) 4717 CmdArgs.push_back("-fcuda-short-ptr"); 4718 } 4719 4720 // OpenMP offloading device jobs take the argument -fopenmp-host-ir-file-path 4721 // to specify the result of the compile phase on the host, so the meaningful 4722 // device declarations can be identified. Also, -fopenmp-is-device is passed 4723 // along to tell the frontend that it is generating code for a device, so that 4724 // only the relevant declarations are emitted. 4725 if (IsOpenMPDevice) { 4726 CmdArgs.push_back("-fopenmp-is-device"); 4727 if (Inputs.size() == 2) { 4728 CmdArgs.push_back("-fopenmp-host-ir-file-path"); 4729 CmdArgs.push_back(Args.MakeArgString(Inputs.back().getFilename())); 4730 } 4731 } 4732 4733 // For all the host OpenMP offloading compile jobs we need to pass the targets 4734 // information using -fopenmp-targets= option. 4735 if (isa<CompileJobAction>(JA) && JA.isHostOffloading(Action::OFK_OpenMP)) { 4736 SmallString<128> TargetInfo("-fopenmp-targets="); 4737 4738 Arg *Tgts = Args.getLastArg(options::OPT_fopenmp_targets_EQ); 4739 assert(Tgts && Tgts->getNumValues() && 4740 "OpenMP offloading has to have targets specified."); 4741 for (unsigned i = 0; i < Tgts->getNumValues(); ++i) { 4742 if (i) 4743 TargetInfo += ','; 4744 // We need to get the string from the triple because it may be not exactly 4745 // the same as the one we get directly from the arguments. 4746 llvm::Triple T(Tgts->getValue(i)); 4747 TargetInfo += T.getTriple(); 4748 } 4749 CmdArgs.push_back(Args.MakeArgString(TargetInfo.str())); 4750 } 4751 4752 bool WholeProgramVTables = 4753 Args.hasFlag(options::OPT_fwhole_program_vtables, 4754 options::OPT_fno_whole_program_vtables, false); 4755 if (WholeProgramVTables) { 4756 if (!D.isUsingLTO()) 4757 D.Diag(diag::err_drv_argument_only_allowed_with) 4758 << "-fwhole-program-vtables" 4759 << "-flto"; 4760 CmdArgs.push_back("-fwhole-program-vtables"); 4761 } 4762 4763 if (Arg *A = Args.getLastArg(options::OPT_fexperimental_isel, 4764 options::OPT_fno_experimental_isel)) { 4765 CmdArgs.push_back("-mllvm"); 4766 if (A->getOption().matches(options::OPT_fexperimental_isel)) { 4767 CmdArgs.push_back("-global-isel=1"); 4768 4769 // GISel is on by default on AArch64 -O0, so don't bother adding 4770 // the fallback remarks for it. Other combinations will add a warning of 4771 // some kind. 4772 bool IsArchSupported = Triple.getArch() == llvm::Triple::aarch64; 4773 bool IsOptLevelSupported = false; 4774 4775 Arg *A = Args.getLastArg(options::OPT_O_Group); 4776 if (Triple.getArch() == llvm::Triple::aarch64) { 4777 if (!A || A->getOption().matches(options::OPT_O0)) 4778 IsOptLevelSupported = true; 4779 } 4780 if (!IsArchSupported || !IsOptLevelSupported) { 4781 CmdArgs.push_back("-mllvm"); 4782 CmdArgs.push_back("-global-isel-abort=2"); 4783 4784 if (!IsArchSupported) 4785 D.Diag(diag::warn_drv_experimental_isel_incomplete) << Triple.getArchName(); 4786 else 4787 D.Diag(diag::warn_drv_experimental_isel_incomplete_opt); 4788 } 4789 } else { 4790 CmdArgs.push_back("-global-isel=0"); 4791 } 4792 } 4793 4794 if (Arg *A = Args.getLastArg(options::OPT_fforce_enable_int128, 4795 options::OPT_fno_force_enable_int128)) { 4796 if (A->getOption().matches(options::OPT_fforce_enable_int128)) 4797 CmdArgs.push_back("-fforce-enable-int128"); 4798 } 4799 4800 if (Args.hasFlag(options::OPT_fcomplete_member_pointers, 4801 options::OPT_fno_complete_member_pointers, false)) 4802 CmdArgs.push_back("-fcomplete-member-pointers"); 4803 4804 if (Args.hasFlag(options::OPT_moutline, options::OPT_mno_outline, false)) { 4805 // We only support -moutline in AArch64 right now. If we're not compiling 4806 // for AArch64, emit a warning and ignore the flag. Otherwise, add the 4807 // proper mllvm flags. 4808 if (Triple.getArch() != llvm::Triple::aarch64) { 4809 D.Diag(diag::warn_drv_moutline_unsupported_opt) << Triple.getArchName(); 4810 } else { 4811 CmdArgs.push_back("-mllvm"); 4812 CmdArgs.push_back("-enable-machine-outliner"); 4813 4814 // The outliner shouldn't compete with linkers that dedupe linkonceodr 4815 // functions in LTO. Enable that behaviour by default when compiling with 4816 // LTO. 4817 if (getToolChain().getDriver().isUsingLTO()) { 4818 CmdArgs.push_back("-mllvm"); 4819 CmdArgs.push_back("-enable-linkonceodr-outlining"); 4820 } 4821 } 4822 } 4823 4824 // Finally add the compile command to the compilation. 4825 if (Args.hasArg(options::OPT__SLASH_fallback) && 4826 Output.getType() == types::TY_Object && 4827 (InputType == types::TY_C || InputType == types::TY_CXX)) { 4828 auto CLCommand = 4829 getCLFallback()->GetCommand(C, JA, Output, Inputs, Args, LinkingOutput); 4830 C.addCommand(llvm::make_unique<FallbackCommand>( 4831 JA, *this, Exec, CmdArgs, Inputs, std::move(CLCommand))); 4832 } else if (Args.hasArg(options::OPT__SLASH_fallback) && 4833 isa<PrecompileJobAction>(JA)) { 4834 // In /fallback builds, run the main compilation even if the pch generation 4835 // fails, so that the main compilation's fallback to cl.exe runs. 4836 C.addCommand(llvm::make_unique<ForceSuccessCommand>(JA, *this, Exec, 4837 CmdArgs, Inputs)); 4838 } else { 4839 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs)); 4840 } 4841 4842 if (Arg *A = Args.getLastArg(options::OPT_pg)) 4843 if (Args.hasArg(options::OPT_fomit_frame_pointer)) 4844 D.Diag(diag::err_drv_argument_not_allowed_with) << "-fomit-frame-pointer" 4845 << A->getAsString(Args); 4846 4847 // Claim some arguments which clang supports automatically. 4848 4849 // -fpch-preprocess is used with gcc to add a special marker in the output to 4850 // include the PCH file. Clang's PTH solution is completely transparent, so we 4851 // do not need to deal with it at all. 4852 Args.ClaimAllArgs(options::OPT_fpch_preprocess); 4853 4854 // Claim some arguments which clang doesn't support, but we don't 4855 // care to warn the user about. 4856 Args.ClaimAllArgs(options::OPT_clang_ignored_f_Group); 4857 Args.ClaimAllArgs(options::OPT_clang_ignored_m_Group); 4858 4859 // Disable warnings for clang -E -emit-llvm foo.c 4860 Args.ClaimAllArgs(options::OPT_emit_llvm); 4861 } 4862 4863 Clang::Clang(const ToolChain &TC) 4864 // CAUTION! The first constructor argument ("clang") is not arbitrary, 4865 // as it is for other tools. Some operations on a Tool actually test 4866 // whether that tool is Clang based on the Tool's Name as a string. 4867 : Tool("clang", "clang frontend", TC, RF_Full) {} 4868 4869 Clang::~Clang() {} 4870 4871 /// Add options related to the Objective-C runtime/ABI. 4872 /// 4873 /// Returns true if the runtime is non-fragile. 4874 ObjCRuntime Clang::AddObjCRuntimeArgs(const ArgList &args, 4875 ArgStringList &cmdArgs, 4876 RewriteKind rewriteKind) const { 4877 // Look for the controlling runtime option. 4878 Arg *runtimeArg = 4879 args.getLastArg(options::OPT_fnext_runtime, options::OPT_fgnu_runtime, 4880 options::OPT_fobjc_runtime_EQ); 4881 4882 // Just forward -fobjc-runtime= to the frontend. This supercedes 4883 // options about fragility. 4884 if (runtimeArg && 4885 runtimeArg->getOption().matches(options::OPT_fobjc_runtime_EQ)) { 4886 ObjCRuntime runtime; 4887 StringRef value = runtimeArg->getValue(); 4888 if (runtime.tryParse(value)) { 4889 getToolChain().getDriver().Diag(diag::err_drv_unknown_objc_runtime) 4890 << value; 4891 } 4892 if ((runtime.getKind() == ObjCRuntime::GNUstep) && 4893 (runtime.getVersion() >= VersionTuple(2, 0))) 4894 if (!getToolChain().getTriple().isOSBinFormatELF()) { 4895 getToolChain().getDriver().Diag( 4896 diag::err_drv_gnustep_objc_runtime_incompatible_binary) 4897 << runtime.getVersion().getMajor(); 4898 } 4899 4900 runtimeArg->render(args, cmdArgs); 4901 return runtime; 4902 } 4903 4904 // Otherwise, we'll need the ABI "version". Version numbers are 4905 // slightly confusing for historical reasons: 4906 // 1 - Traditional "fragile" ABI 4907 // 2 - Non-fragile ABI, version 1 4908 // 3 - Non-fragile ABI, version 2 4909 unsigned objcABIVersion = 1; 4910 // If -fobjc-abi-version= is present, use that to set the version. 4911 if (Arg *abiArg = args.getLastArg(options::OPT_fobjc_abi_version_EQ)) { 4912 StringRef value = abiArg->getValue(); 4913 if (value == "1") 4914 objcABIVersion = 1; 4915 else if (value == "2") 4916 objcABIVersion = 2; 4917 else if (value == "3") 4918 objcABIVersion = 3; 4919 else 4920 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported) << value; 4921 } else { 4922 // Otherwise, determine if we are using the non-fragile ABI. 4923 bool nonFragileABIIsDefault = 4924 (rewriteKind == RK_NonFragile || 4925 (rewriteKind == RK_None && 4926 getToolChain().IsObjCNonFragileABIDefault())); 4927 if (args.hasFlag(options::OPT_fobjc_nonfragile_abi, 4928 options::OPT_fno_objc_nonfragile_abi, 4929 nonFragileABIIsDefault)) { 4930 // Determine the non-fragile ABI version to use. 4931 #ifdef DISABLE_DEFAULT_NONFRAGILEABI_TWO 4932 unsigned nonFragileABIVersion = 1; 4933 #else 4934 unsigned nonFragileABIVersion = 2; 4935 #endif 4936 4937 if (Arg *abiArg = 4938 args.getLastArg(options::OPT_fobjc_nonfragile_abi_version_EQ)) { 4939 StringRef value = abiArg->getValue(); 4940 if (value == "1") 4941 nonFragileABIVersion = 1; 4942 else if (value == "2") 4943 nonFragileABIVersion = 2; 4944 else 4945 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported) 4946 << value; 4947 } 4948 4949 objcABIVersion = 1 + nonFragileABIVersion; 4950 } else { 4951 objcABIVersion = 1; 4952 } 4953 } 4954 4955 // We don't actually care about the ABI version other than whether 4956 // it's non-fragile. 4957 bool isNonFragile = objcABIVersion != 1; 4958 4959 // If we have no runtime argument, ask the toolchain for its default runtime. 4960 // However, the rewriter only really supports the Mac runtime, so assume that. 4961 ObjCRuntime runtime; 4962 if (!runtimeArg) { 4963 switch (rewriteKind) { 4964 case RK_None: 4965 runtime = getToolChain().getDefaultObjCRuntime(isNonFragile); 4966 break; 4967 case RK_Fragile: 4968 runtime = ObjCRuntime(ObjCRuntime::FragileMacOSX, VersionTuple()); 4969 break; 4970 case RK_NonFragile: 4971 runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple()); 4972 break; 4973 } 4974 4975 // -fnext-runtime 4976 } else if (runtimeArg->getOption().matches(options::OPT_fnext_runtime)) { 4977 // On Darwin, make this use the default behavior for the toolchain. 4978 if (getToolChain().getTriple().isOSDarwin()) { 4979 runtime = getToolChain().getDefaultObjCRuntime(isNonFragile); 4980 4981 // Otherwise, build for a generic macosx port. 4982 } else { 4983 runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple()); 4984 } 4985 4986 // -fgnu-runtime 4987 } else { 4988 assert(runtimeArg->getOption().matches(options::OPT_fgnu_runtime)); 4989 // Legacy behaviour is to target the gnustep runtime if we are in 4990 // non-fragile mode or the GCC runtime in fragile mode. 4991 if (isNonFragile) 4992 runtime = ObjCRuntime(ObjCRuntime::GNUstep, VersionTuple(2, 0)); 4993 else 4994 runtime = ObjCRuntime(ObjCRuntime::GCC, VersionTuple()); 4995 } 4996 4997 cmdArgs.push_back( 4998 args.MakeArgString("-fobjc-runtime=" + runtime.getAsString())); 4999 return runtime; 5000 } 5001 5002 static bool maybeConsumeDash(const std::string &EH, size_t &I) { 5003 bool HaveDash = (I + 1 < EH.size() && EH[I + 1] == '-'); 5004 I += HaveDash; 5005 return !HaveDash; 5006 } 5007 5008 namespace { 5009 struct EHFlags { 5010 bool Synch = false; 5011 bool Asynch = false; 5012 bool NoUnwindC = false; 5013 }; 5014 } // end anonymous namespace 5015 5016 /// /EH controls whether to run destructor cleanups when exceptions are 5017 /// thrown. There are three modifiers: 5018 /// - s: Cleanup after "synchronous" exceptions, aka C++ exceptions. 5019 /// - a: Cleanup after "asynchronous" exceptions, aka structured exceptions. 5020 /// The 'a' modifier is unimplemented and fundamentally hard in LLVM IR. 5021 /// - c: Assume that extern "C" functions are implicitly nounwind. 5022 /// The default is /EHs-c-, meaning cleanups are disabled. 5023 static EHFlags parseClangCLEHFlags(const Driver &D, const ArgList &Args) { 5024 EHFlags EH; 5025 5026 std::vector<std::string> EHArgs = 5027 Args.getAllArgValues(options::OPT__SLASH_EH); 5028 for (auto EHVal : EHArgs) { 5029 for (size_t I = 0, E = EHVal.size(); I != E; ++I) { 5030 switch (EHVal[I]) { 5031 case 'a': 5032 EH.Asynch = maybeConsumeDash(EHVal, I); 5033 if (EH.Asynch) 5034 EH.Synch = false; 5035 continue; 5036 case 'c': 5037 EH.NoUnwindC = maybeConsumeDash(EHVal, I); 5038 continue; 5039 case 's': 5040 EH.Synch = maybeConsumeDash(EHVal, I); 5041 if (EH.Synch) 5042 EH.Asynch = false; 5043 continue; 5044 default: 5045 break; 5046 } 5047 D.Diag(clang::diag::err_drv_invalid_value) << "/EH" << EHVal; 5048 break; 5049 } 5050 } 5051 // The /GX, /GX- flags are only processed if there are not /EH flags. 5052 // The default is that /GX is not specified. 5053 if (EHArgs.empty() && 5054 Args.hasFlag(options::OPT__SLASH_GX, options::OPT__SLASH_GX_, 5055 /*default=*/false)) { 5056 EH.Synch = true; 5057 EH.NoUnwindC = true; 5058 } 5059 5060 return EH; 5061 } 5062 5063 void Clang::AddClangCLArgs(const ArgList &Args, types::ID InputType, 5064 ArgStringList &CmdArgs, 5065 codegenoptions::DebugInfoKind *DebugInfoKind, 5066 bool *EmitCodeView) const { 5067 unsigned RTOptionID = options::OPT__SLASH_MT; 5068 5069 if (Args.hasArg(options::OPT__SLASH_LDd)) 5070 // The /LDd option implies /MTd. The dependent lib part can be overridden, 5071 // but defining _DEBUG is sticky. 5072 RTOptionID = options::OPT__SLASH_MTd; 5073 5074 if (Arg *A = Args.getLastArg(options::OPT__SLASH_M_Group)) 5075 RTOptionID = A->getOption().getID(); 5076 5077 StringRef FlagForCRT; 5078 switch (RTOptionID) { 5079 case options::OPT__SLASH_MD: 5080 if (Args.hasArg(options::OPT__SLASH_LDd)) 5081 CmdArgs.push_back("-D_DEBUG"); 5082 CmdArgs.push_back("-D_MT"); 5083 CmdArgs.push_back("-D_DLL"); 5084 FlagForCRT = "--dependent-lib=msvcrt"; 5085 break; 5086 case options::OPT__SLASH_MDd: 5087 CmdArgs.push_back("-D_DEBUG"); 5088 CmdArgs.push_back("-D_MT"); 5089 CmdArgs.push_back("-D_DLL"); 5090 FlagForCRT = "--dependent-lib=msvcrtd"; 5091 break; 5092 case options::OPT__SLASH_MT: 5093 if (Args.hasArg(options::OPT__SLASH_LDd)) 5094 CmdArgs.push_back("-D_DEBUG"); 5095 CmdArgs.push_back("-D_MT"); 5096 CmdArgs.push_back("-flto-visibility-public-std"); 5097 FlagForCRT = "--dependent-lib=libcmt"; 5098 break; 5099 case options::OPT__SLASH_MTd: 5100 CmdArgs.push_back("-D_DEBUG"); 5101 CmdArgs.push_back("-D_MT"); 5102 CmdArgs.push_back("-flto-visibility-public-std"); 5103 FlagForCRT = "--dependent-lib=libcmtd"; 5104 break; 5105 default: 5106 llvm_unreachable("Unexpected option ID."); 5107 } 5108 5109 if (Args.hasArg(options::OPT__SLASH_Zl)) { 5110 CmdArgs.push_back("-D_VC_NODEFAULTLIB"); 5111 } else { 5112 CmdArgs.push_back(FlagForCRT.data()); 5113 5114 // This provides POSIX compatibility (maps 'open' to '_open'), which most 5115 // users want. The /Za flag to cl.exe turns this off, but it's not 5116 // implemented in clang. 5117 CmdArgs.push_back("--dependent-lib=oldnames"); 5118 } 5119 5120 if (Arg *A = Args.getLastArg(options::OPT_show_includes)) 5121 A->render(Args, CmdArgs); 5122 5123 // This controls whether or not we emit RTTI data for polymorphic types. 5124 if (Args.hasFlag(options::OPT__SLASH_GR_, options::OPT__SLASH_GR, 5125 /*default=*/false)) 5126 CmdArgs.push_back("-fno-rtti-data"); 5127 5128 // This controls whether or not we emit stack-protector instrumentation. 5129 // In MSVC, Buffer Security Check (/GS) is on by default. 5130 if (Args.hasFlag(options::OPT__SLASH_GS, options::OPT__SLASH_GS_, 5131 /*default=*/true)) { 5132 CmdArgs.push_back("-stack-protector"); 5133 CmdArgs.push_back(Args.MakeArgString(Twine(LangOptions::SSPStrong))); 5134 } 5135 5136 // Emit CodeView if -Z7, -Zd, or -gline-tables-only are present. 5137 if (Arg *DebugInfoArg = 5138 Args.getLastArg(options::OPT__SLASH_Z7, options::OPT__SLASH_Zd, 5139 options::OPT_gline_tables_only)) { 5140 *EmitCodeView = true; 5141 if (DebugInfoArg->getOption().matches(options::OPT__SLASH_Z7)) 5142 *DebugInfoKind = codegenoptions::LimitedDebugInfo; 5143 else 5144 *DebugInfoKind = codegenoptions::DebugLineTablesOnly; 5145 CmdArgs.push_back("-gcodeview"); 5146 } else { 5147 *EmitCodeView = false; 5148 } 5149 5150 const Driver &D = getToolChain().getDriver(); 5151 EHFlags EH = parseClangCLEHFlags(D, Args); 5152 if (EH.Synch || EH.Asynch) { 5153 if (types::isCXX(InputType)) 5154 CmdArgs.push_back("-fcxx-exceptions"); 5155 CmdArgs.push_back("-fexceptions"); 5156 } 5157 if (types::isCXX(InputType) && EH.Synch && EH.NoUnwindC) 5158 CmdArgs.push_back("-fexternc-nounwind"); 5159 5160 // /EP should expand to -E -P. 5161 if (Args.hasArg(options::OPT__SLASH_EP)) { 5162 CmdArgs.push_back("-E"); 5163 CmdArgs.push_back("-P"); 5164 } 5165 5166 unsigned VolatileOptionID; 5167 if (getToolChain().getArch() == llvm::Triple::x86_64 || 5168 getToolChain().getArch() == llvm::Triple::x86) 5169 VolatileOptionID = options::OPT__SLASH_volatile_ms; 5170 else 5171 VolatileOptionID = options::OPT__SLASH_volatile_iso; 5172 5173 if (Arg *A = Args.getLastArg(options::OPT__SLASH_volatile_Group)) 5174 VolatileOptionID = A->getOption().getID(); 5175 5176 if (VolatileOptionID == options::OPT__SLASH_volatile_ms) 5177 CmdArgs.push_back("-fms-volatile"); 5178 5179 Arg *MostGeneralArg = Args.getLastArg(options::OPT__SLASH_vmg); 5180 Arg *BestCaseArg = Args.getLastArg(options::OPT__SLASH_vmb); 5181 if (MostGeneralArg && BestCaseArg) 5182 D.Diag(clang::diag::err_drv_argument_not_allowed_with) 5183 << MostGeneralArg->getAsString(Args) << BestCaseArg->getAsString(Args); 5184 5185 if (MostGeneralArg) { 5186 Arg *SingleArg = Args.getLastArg(options::OPT__SLASH_vms); 5187 Arg *MultipleArg = Args.getLastArg(options::OPT__SLASH_vmm); 5188 Arg *VirtualArg = Args.getLastArg(options::OPT__SLASH_vmv); 5189 5190 Arg *FirstConflict = SingleArg ? SingleArg : MultipleArg; 5191 Arg *SecondConflict = VirtualArg ? VirtualArg : MultipleArg; 5192 if (FirstConflict && SecondConflict && FirstConflict != SecondConflict) 5193 D.Diag(clang::diag::err_drv_argument_not_allowed_with) 5194 << FirstConflict->getAsString(Args) 5195 << SecondConflict->getAsString(Args); 5196 5197 if (SingleArg) 5198 CmdArgs.push_back("-fms-memptr-rep=single"); 5199 else if (MultipleArg) 5200 CmdArgs.push_back("-fms-memptr-rep=multiple"); 5201 else 5202 CmdArgs.push_back("-fms-memptr-rep=virtual"); 5203 } 5204 5205 // Parse the default calling convention options. 5206 if (Arg *CCArg = 5207 Args.getLastArg(options::OPT__SLASH_Gd, options::OPT__SLASH_Gr, 5208 options::OPT__SLASH_Gz, options::OPT__SLASH_Gv, 5209 options::OPT__SLASH_Gregcall)) { 5210 unsigned DCCOptId = CCArg->getOption().getID(); 5211 const char *DCCFlag = nullptr; 5212 bool ArchSupported = true; 5213 llvm::Triple::ArchType Arch = getToolChain().getArch(); 5214 switch (DCCOptId) { 5215 case options::OPT__SLASH_Gd: 5216 DCCFlag = "-fdefault-calling-conv=cdecl"; 5217 break; 5218 case options::OPT__SLASH_Gr: 5219 ArchSupported = Arch == llvm::Triple::x86; 5220 DCCFlag = "-fdefault-calling-conv=fastcall"; 5221 break; 5222 case options::OPT__SLASH_Gz: 5223 ArchSupported = Arch == llvm::Triple::x86; 5224 DCCFlag = "-fdefault-calling-conv=stdcall"; 5225 break; 5226 case options::OPT__SLASH_Gv: 5227 ArchSupported = Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64; 5228 DCCFlag = "-fdefault-calling-conv=vectorcall"; 5229 break; 5230 case options::OPT__SLASH_Gregcall: 5231 ArchSupported = Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64; 5232 DCCFlag = "-fdefault-calling-conv=regcall"; 5233 break; 5234 } 5235 5236 // MSVC doesn't warn if /Gr or /Gz is used on x64, so we don't either. 5237 if (ArchSupported && DCCFlag) 5238 CmdArgs.push_back(DCCFlag); 5239 } 5240 5241 if (Arg *A = Args.getLastArg(options::OPT_vtordisp_mode_EQ)) 5242 A->render(Args, CmdArgs); 5243 5244 if (!Args.hasArg(options::OPT_fdiagnostics_format_EQ)) { 5245 CmdArgs.push_back("-fdiagnostics-format"); 5246 if (Args.hasArg(options::OPT__SLASH_fallback)) 5247 CmdArgs.push_back("msvc-fallback"); 5248 else 5249 CmdArgs.push_back("msvc"); 5250 } 5251 5252 if (Args.hasArg(options::OPT__SLASH_Guard) && 5253 Args.getLastArgValue(options::OPT__SLASH_Guard).equals_lower("cf")) 5254 CmdArgs.push_back("-cfguard"); 5255 } 5256 5257 visualstudio::Compiler *Clang::getCLFallback() const { 5258 if (!CLFallback) 5259 CLFallback.reset(new visualstudio::Compiler(getToolChain())); 5260 return CLFallback.get(); 5261 } 5262 5263 5264 const char *Clang::getBaseInputName(const ArgList &Args, 5265 const InputInfo &Input) { 5266 return Args.MakeArgString(llvm::sys::path::filename(Input.getBaseInput())); 5267 } 5268 5269 const char *Clang::getBaseInputStem(const ArgList &Args, 5270 const InputInfoList &Inputs) { 5271 const char *Str = getBaseInputName(Args, Inputs[0]); 5272 5273 if (const char *End = strrchr(Str, '.')) 5274 return Args.MakeArgString(std::string(Str, End)); 5275 5276 return Str; 5277 } 5278 5279 const char *Clang::getDependencyFileName(const ArgList &Args, 5280 const InputInfoList &Inputs) { 5281 // FIXME: Think about this more. 5282 std::string Res; 5283 5284 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) { 5285 std::string Str(OutputOpt->getValue()); 5286 Res = Str.substr(0, Str.rfind('.')); 5287 } else { 5288 Res = getBaseInputStem(Args, Inputs); 5289 } 5290 return Args.MakeArgString(Res + ".d"); 5291 } 5292 5293 // Begin ClangAs 5294 5295 void ClangAs::AddMIPSTargetArgs(const ArgList &Args, 5296 ArgStringList &CmdArgs) const { 5297 StringRef CPUName; 5298 StringRef ABIName; 5299 const llvm::Triple &Triple = getToolChain().getTriple(); 5300 mips::getMipsCPUAndABI(Args, Triple, CPUName, ABIName); 5301 5302 CmdArgs.push_back("-target-abi"); 5303 CmdArgs.push_back(ABIName.data()); 5304 } 5305 5306 void ClangAs::AddX86TargetArgs(const ArgList &Args, 5307 ArgStringList &CmdArgs) const { 5308 if (Arg *A = Args.getLastArg(options::OPT_masm_EQ)) { 5309 StringRef Value = A->getValue(); 5310 if (Value == "intel" || Value == "att") { 5311 CmdArgs.push_back("-mllvm"); 5312 CmdArgs.push_back(Args.MakeArgString("-x86-asm-syntax=" + Value)); 5313 } else { 5314 getToolChain().getDriver().Diag(diag::err_drv_unsupported_option_argument) 5315 << A->getOption().getName() << Value; 5316 } 5317 } 5318 } 5319 5320 void ClangAs::ConstructJob(Compilation &C, const JobAction &JA, 5321 const InputInfo &Output, const InputInfoList &Inputs, 5322 const ArgList &Args, 5323 const char *LinkingOutput) const { 5324 ArgStringList CmdArgs; 5325 5326 assert(Inputs.size() == 1 && "Unexpected number of inputs."); 5327 const InputInfo &Input = Inputs[0]; 5328 5329 const llvm::Triple &Triple = getToolChain().getEffectiveTriple(); 5330 const std::string &TripleStr = Triple.getTriple(); 5331 const auto &D = getToolChain().getDriver(); 5332 5333 // Don't warn about "clang -w -c foo.s" 5334 Args.ClaimAllArgs(options::OPT_w); 5335 // and "clang -emit-llvm -c foo.s" 5336 Args.ClaimAllArgs(options::OPT_emit_llvm); 5337 5338 claimNoWarnArgs(Args); 5339 5340 // Invoke ourselves in -cc1as mode. 5341 // 5342 // FIXME: Implement custom jobs for internal actions. 5343 CmdArgs.push_back("-cc1as"); 5344 5345 // Add the "effective" target triple. 5346 CmdArgs.push_back("-triple"); 5347 CmdArgs.push_back(Args.MakeArgString(TripleStr)); 5348 5349 // Set the output mode, we currently only expect to be used as a real 5350 // assembler. 5351 CmdArgs.push_back("-filetype"); 5352 CmdArgs.push_back("obj"); 5353 5354 // Set the main file name, so that debug info works even with 5355 // -save-temps or preprocessed assembly. 5356 CmdArgs.push_back("-main-file-name"); 5357 CmdArgs.push_back(Clang::getBaseInputName(Args, Input)); 5358 5359 // Add the target cpu 5360 std::string CPU = getCPUName(Args, Triple, /*FromAs*/ true); 5361 if (!CPU.empty()) { 5362 CmdArgs.push_back("-target-cpu"); 5363 CmdArgs.push_back(Args.MakeArgString(CPU)); 5364 } 5365 5366 // Add the target features 5367 getTargetFeatures(getToolChain(), Triple, Args, CmdArgs, true); 5368 5369 // Ignore explicit -force_cpusubtype_ALL option. 5370 (void)Args.hasArg(options::OPT_force__cpusubtype__ALL); 5371 5372 // Pass along any -I options so we get proper .include search paths. 5373 Args.AddAllArgs(CmdArgs, options::OPT_I_Group); 5374 5375 // Determine the original source input. 5376 const Action *SourceAction = &JA; 5377 while (SourceAction->getKind() != Action::InputClass) { 5378 assert(!SourceAction->getInputs().empty() && "unexpected root action!"); 5379 SourceAction = SourceAction->getInputs()[0]; 5380 } 5381 5382 // Forward -g and handle debug info related flags, assuming we are dealing 5383 // with an actual assembly file. 5384 bool WantDebug = false; 5385 unsigned DwarfVersion = 0; 5386 Args.ClaimAllArgs(options::OPT_g_Group); 5387 if (Arg *A = Args.getLastArg(options::OPT_g_Group)) { 5388 WantDebug = !A->getOption().matches(options::OPT_g0) && 5389 !A->getOption().matches(options::OPT_ggdb0); 5390 if (WantDebug) 5391 DwarfVersion = DwarfVersionNum(A->getSpelling()); 5392 } 5393 if (DwarfVersion == 0) 5394 DwarfVersion = getToolChain().GetDefaultDwarfVersion(); 5395 5396 codegenoptions::DebugInfoKind DebugInfoKind = codegenoptions::NoDebugInfo; 5397 5398 if (SourceAction->getType() == types::TY_Asm || 5399 SourceAction->getType() == types::TY_PP_Asm) { 5400 // You might think that it would be ok to set DebugInfoKind outside of 5401 // the guard for source type, however there is a test which asserts 5402 // that some assembler invocation receives no -debug-info-kind, 5403 // and it's not clear whether that test is just overly restrictive. 5404 DebugInfoKind = (WantDebug ? codegenoptions::LimitedDebugInfo 5405 : codegenoptions::NoDebugInfo); 5406 // Add the -fdebug-compilation-dir flag if needed. 5407 addDebugCompDirArg(Args, CmdArgs); 5408 5409 // Set the AT_producer to the clang version when using the integrated 5410 // assembler on assembly source files. 5411 CmdArgs.push_back("-dwarf-debug-producer"); 5412 CmdArgs.push_back(Args.MakeArgString(getClangFullVersion())); 5413 5414 // And pass along -I options 5415 Args.AddAllArgs(CmdArgs, options::OPT_I); 5416 } 5417 RenderDebugEnablingArgs(Args, CmdArgs, DebugInfoKind, DwarfVersion, 5418 llvm::DebuggerKind::Default); 5419 RenderDebugInfoCompressionArgs(Args, CmdArgs, D); 5420 5421 5422 // Handle -fPIC et al -- the relocation-model affects the assembler 5423 // for some targets. 5424 llvm::Reloc::Model RelocationModel; 5425 unsigned PICLevel; 5426 bool IsPIE; 5427 std::tie(RelocationModel, PICLevel, IsPIE) = 5428 ParsePICArgs(getToolChain(), Args); 5429 5430 const char *RMName = RelocationModelName(RelocationModel); 5431 if (RMName) { 5432 CmdArgs.push_back("-mrelocation-model"); 5433 CmdArgs.push_back(RMName); 5434 } 5435 5436 // Optionally embed the -cc1as level arguments into the debug info, for build 5437 // analysis. 5438 if (getToolChain().UseDwarfDebugFlags()) { 5439 ArgStringList OriginalArgs; 5440 for (const auto &Arg : Args) 5441 Arg->render(Args, OriginalArgs); 5442 5443 SmallString<256> Flags; 5444 const char *Exec = getToolChain().getDriver().getClangProgramPath(); 5445 Flags += Exec; 5446 for (const char *OriginalArg : OriginalArgs) { 5447 SmallString<128> EscapedArg; 5448 EscapeSpacesAndBackslashes(OriginalArg, EscapedArg); 5449 Flags += " "; 5450 Flags += EscapedArg; 5451 } 5452 CmdArgs.push_back("-dwarf-debug-flags"); 5453 CmdArgs.push_back(Args.MakeArgString(Flags)); 5454 } 5455 5456 // FIXME: Add -static support, once we have it. 5457 5458 // Add target specific flags. 5459 switch (getToolChain().getArch()) { 5460 default: 5461 break; 5462 5463 case llvm::Triple::mips: 5464 case llvm::Triple::mipsel: 5465 case llvm::Triple::mips64: 5466 case llvm::Triple::mips64el: 5467 AddMIPSTargetArgs(Args, CmdArgs); 5468 break; 5469 5470 case llvm::Triple::x86: 5471 case llvm::Triple::x86_64: 5472 AddX86TargetArgs(Args, CmdArgs); 5473 break; 5474 5475 case llvm::Triple::arm: 5476 case llvm::Triple::armeb: 5477 case llvm::Triple::thumb: 5478 case llvm::Triple::thumbeb: 5479 // This isn't in AddARMTargetArgs because we want to do this for assembly 5480 // only, not C/C++. 5481 if (Args.hasFlag(options::OPT_mdefault_build_attributes, 5482 options::OPT_mno_default_build_attributes, true)) { 5483 CmdArgs.push_back("-mllvm"); 5484 CmdArgs.push_back("-arm-add-build-attributes"); 5485 } 5486 break; 5487 } 5488 5489 // Consume all the warning flags. Usually this would be handled more 5490 // gracefully by -cc1 (warning about unknown warning flags, etc) but -cc1as 5491 // doesn't handle that so rather than warning about unused flags that are 5492 // actually used, we'll lie by omission instead. 5493 // FIXME: Stop lying and consume only the appropriate driver flags 5494 Args.ClaimAllArgs(options::OPT_W_Group); 5495 5496 CollectArgsForIntegratedAssembler(C, Args, CmdArgs, 5497 getToolChain().getDriver()); 5498 5499 Args.AddAllArgs(CmdArgs, options::OPT_mllvm); 5500 5501 assert(Output.isFilename() && "Unexpected lipo output."); 5502 CmdArgs.push_back("-o"); 5503 CmdArgs.push_back(Output.getFilename()); 5504 5505 if (Args.hasArg(options::OPT_gsplit_dwarf) && 5506 getToolChain().getTriple().isOSLinux()) { 5507 CmdArgs.push_back("-split-dwarf-file"); 5508 CmdArgs.push_back(SplitDebugName(Args, Input)); 5509 } 5510 5511 assert(Input.isFilename() && "Invalid input."); 5512 CmdArgs.push_back(Input.getFilename()); 5513 5514 const char *Exec = getToolChain().getDriver().getClangProgramPath(); 5515 C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs)); 5516 } 5517 5518 // Begin OffloadBundler 5519 5520 void OffloadBundler::ConstructJob(Compilation &C, const JobAction &JA, 5521 const InputInfo &Output, 5522 const InputInfoList &Inputs, 5523 const llvm::opt::ArgList &TCArgs, 5524 const char *LinkingOutput) const { 5525 // The version with only one output is expected to refer to a bundling job. 5526 assert(isa<OffloadBundlingJobAction>(JA) && "Expecting bundling job!"); 5527 5528 // The bundling command looks like this: 5529 // clang-offload-bundler -type=bc 5530 // -targets=host-triple,openmp-triple1,openmp-triple2 5531 // -outputs=input_file 5532 // -inputs=unbundle_file_host,unbundle_file_tgt1,unbundle_file_tgt2" 5533 5534 ArgStringList CmdArgs; 5535 5536 // Get the type. 5537 CmdArgs.push_back(TCArgs.MakeArgString( 5538 Twine("-type=") + types::getTypeTempSuffix(Output.getType()))); 5539 5540 assert(JA.getInputs().size() == Inputs.size() && 5541 "Not have inputs for all dependence actions??"); 5542 5543 // Get the targets. 5544 SmallString<128> Triples; 5545 Triples += "-targets="; 5546 for (unsigned I = 0; I < Inputs.size(); ++I) { 5547 if (I) 5548 Triples += ','; 5549 5550 // Find ToolChain for this input. 5551 Action::OffloadKind CurKind = Action::OFK_Host; 5552 const ToolChain *CurTC = &getToolChain(); 5553 const Action *CurDep = JA.getInputs()[I]; 5554 5555 if (const auto *OA = dyn_cast<OffloadAction>(CurDep)) { 5556 CurTC = nullptr; 5557 OA->doOnEachDependence([&](Action *A, const ToolChain *TC, const char *) { 5558 assert(CurTC == nullptr && "Expected one dependence!"); 5559 CurKind = A->getOffloadingDeviceKind(); 5560 CurTC = TC; 5561 }); 5562 } 5563 Triples += Action::GetOffloadKindName(CurKind); 5564 Triples += '-'; 5565 Triples += CurTC->getTriple().normalize(); 5566 if (CurKind == Action::OFK_HIP && CurDep->getOffloadingArch()) { 5567 Triples += '-'; 5568 Triples += CurDep->getOffloadingArch(); 5569 } 5570 } 5571 CmdArgs.push_back(TCArgs.MakeArgString(Triples)); 5572 5573 // Get bundled file command. 5574 CmdArgs.push_back( 5575 TCArgs.MakeArgString(Twine("-outputs=") + Output.getFilename())); 5576 5577 // Get unbundled files command. 5578 SmallString<128> UB; 5579 UB += "-inputs="; 5580 for (unsigned I = 0; I < Inputs.size(); ++I) { 5581 if (I) 5582 UB += ','; 5583 5584 // Find ToolChain for this input. 5585 const ToolChain *CurTC = &getToolChain(); 5586 if (const auto *OA = dyn_cast<OffloadAction>(JA.getInputs()[I])) { 5587 CurTC = nullptr; 5588 OA->doOnEachDependence([&](Action *, const ToolChain *TC, const char *) { 5589 assert(CurTC == nullptr && "Expected one dependence!"); 5590 CurTC = TC; 5591 }); 5592 } 5593 UB += CurTC->getInputFilename(Inputs[I]); 5594 } 5595 CmdArgs.push_back(TCArgs.MakeArgString(UB)); 5596 5597 // All the inputs are encoded as commands. 5598 C.addCommand(llvm::make_unique<Command>( 5599 JA, *this, 5600 TCArgs.MakeArgString(getToolChain().GetProgramPath(getShortName())), 5601 CmdArgs, None)); 5602 } 5603 5604 void OffloadBundler::ConstructJobMultipleOutputs( 5605 Compilation &C, const JobAction &JA, const InputInfoList &Outputs, 5606 const InputInfoList &Inputs, const llvm::opt::ArgList &TCArgs, 5607 const char *LinkingOutput) const { 5608 // The version with multiple outputs is expected to refer to a unbundling job. 5609 auto &UA = cast<OffloadUnbundlingJobAction>(JA); 5610 5611 // The unbundling command looks like this: 5612 // clang-offload-bundler -type=bc 5613 // -targets=host-triple,openmp-triple1,openmp-triple2 5614 // -inputs=input_file 5615 // -outputs=unbundle_file_host,unbundle_file_tgt1,unbundle_file_tgt2" 5616 // -unbundle 5617 5618 ArgStringList CmdArgs; 5619 5620 assert(Inputs.size() == 1 && "Expecting to unbundle a single file!"); 5621 InputInfo Input = Inputs.front(); 5622 5623 // Get the type. 5624 CmdArgs.push_back(TCArgs.MakeArgString( 5625 Twine("-type=") + types::getTypeTempSuffix(Input.getType()))); 5626 5627 // Get the targets. 5628 SmallString<128> Triples; 5629 Triples += "-targets="; 5630 auto DepInfo = UA.getDependentActionsInfo(); 5631 for (unsigned I = 0; I < DepInfo.size(); ++I) { 5632 if (I) 5633 Triples += ','; 5634 5635 auto &Dep = DepInfo[I]; 5636 Triples += Action::GetOffloadKindName(Dep.DependentOffloadKind); 5637 Triples += '-'; 5638 Triples += Dep.DependentToolChain->getTriple().normalize(); 5639 if (Dep.DependentOffloadKind == Action::OFK_HIP && 5640 !Dep.DependentBoundArch.empty()) { 5641 Triples += '-'; 5642 Triples += Dep.DependentBoundArch; 5643 } 5644 } 5645 5646 CmdArgs.push_back(TCArgs.MakeArgString(Triples)); 5647 5648 // Get bundled file command. 5649 CmdArgs.push_back( 5650 TCArgs.MakeArgString(Twine("-inputs=") + Input.getFilename())); 5651 5652 // Get unbundled files command. 5653 SmallString<128> UB; 5654 UB += "-outputs="; 5655 for (unsigned I = 0; I < Outputs.size(); ++I) { 5656 if (I) 5657 UB += ','; 5658 UB += DepInfo[I].DependentToolChain->getInputFilename(Outputs[I]); 5659 } 5660 CmdArgs.push_back(TCArgs.MakeArgString(UB)); 5661 CmdArgs.push_back("-unbundle"); 5662 5663 // All the inputs are encoded as commands. 5664 C.addCommand(llvm::make_unique<Command>( 5665 JA, *this, 5666 TCArgs.MakeArgString(getToolChain().GetProgramPath(getShortName())), 5667 CmdArgs, None)); 5668 } 5669