1 //===-- Clang.cpp - Clang+LLVM ToolChain Implementations --------*- C++ -*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include "Clang.h" 10 #include "AMDGPU.h" 11 #include "Arch/AArch64.h" 12 #include "Arch/ARM.h" 13 #include "Arch/CSKY.h" 14 #include "Arch/M68k.h" 15 #include "Arch/Mips.h" 16 #include "Arch/PPC.h" 17 #include "Arch/RISCV.h" 18 #include "Arch/Sparc.h" 19 #include "Arch/SystemZ.h" 20 #include "Arch/VE.h" 21 #include "Arch/X86.h" 22 #include "CommonArgs.h" 23 #include "Hexagon.h" 24 #include "MSP430.h" 25 #include "PS4CPU.h" 26 #include "clang/Basic/CLWarnings.h" 27 #include "clang/Basic/CharInfo.h" 28 #include "clang/Basic/CodeGenOptions.h" 29 #include "clang/Basic/LangOptions.h" 30 #include "clang/Basic/MakeSupport.h" 31 #include "clang/Basic/ObjCRuntime.h" 32 #include "clang/Basic/Version.h" 33 #include "clang/Config/config.h" 34 #include "clang/Driver/Action.h" 35 #include "clang/Driver/Distro.h" 36 #include "clang/Driver/DriverDiagnostic.h" 37 #include "clang/Driver/InputInfo.h" 38 #include "clang/Driver/Options.h" 39 #include "clang/Driver/SanitizerArgs.h" 40 #include "clang/Driver/Types.h" 41 #include "clang/Driver/XRayArgs.h" 42 #include "llvm/ADT/SmallSet.h" 43 #include "llvm/ADT/StringExtras.h" 44 #include "llvm/Config/llvm-config.h" 45 #include "llvm/Option/ArgList.h" 46 #include "llvm/Support/CodeGen.h" 47 #include "llvm/Support/Compiler.h" 48 #include "llvm/Support/Compression.h" 49 #include "llvm/Support/FileSystem.h" 50 #include "llvm/Support/Host.h" 51 #include "llvm/Support/Path.h" 52 #include "llvm/Support/Process.h" 53 #include "llvm/Support/TargetParser.h" 54 #include "llvm/Support/YAMLParser.h" 55 #include <cctype> 56 57 using namespace clang::driver; 58 using namespace clang::driver::tools; 59 using namespace clang; 60 using namespace llvm::opt; 61 62 static void CheckPreprocessingOptions(const Driver &D, const ArgList &Args) { 63 if (Arg *A = Args.getLastArg(clang::driver::options::OPT_C, options::OPT_CC, 64 options::OPT_fminimize_whitespace, 65 options::OPT_fno_minimize_whitespace)) { 66 if (!Args.hasArg(options::OPT_E) && !Args.hasArg(options::OPT__SLASH_P) && 67 !Args.hasArg(options::OPT__SLASH_EP) && !D.CCCIsCPP()) { 68 D.Diag(clang::diag::err_drv_argument_only_allowed_with) 69 << A->getBaseArg().getAsString(Args) 70 << (D.IsCLMode() ? "/E, /P or /EP" : "-E"); 71 } 72 } 73 } 74 75 static void CheckCodeGenerationOptions(const Driver &D, const ArgList &Args) { 76 // In gcc, only ARM checks this, but it seems reasonable to check universally. 77 if (Args.hasArg(options::OPT_static)) 78 if (const Arg *A = 79 Args.getLastArg(options::OPT_dynamic, options::OPT_mdynamic_no_pic)) 80 D.Diag(diag::err_drv_argument_not_allowed_with) << A->getAsString(Args) 81 << "-static"; 82 } 83 84 // Add backslashes to escape spaces and other backslashes. 85 // This is used for the space-separated argument list specified with 86 // the -dwarf-debug-flags option. 87 static void EscapeSpacesAndBackslashes(const char *Arg, 88 SmallVectorImpl<char> &Res) { 89 for (; *Arg; ++Arg) { 90 switch (*Arg) { 91 default: 92 break; 93 case ' ': 94 case '\\': 95 Res.push_back('\\'); 96 break; 97 } 98 Res.push_back(*Arg); 99 } 100 } 101 102 /// Apply \a Work on the current tool chain \a RegularToolChain and any other 103 /// offloading tool chain that is associated with the current action \a JA. 104 static void 105 forAllAssociatedToolChains(Compilation &C, const JobAction &JA, 106 const ToolChain &RegularToolChain, 107 llvm::function_ref<void(const ToolChain &)> Work) { 108 // Apply Work on the current/regular tool chain. 109 Work(RegularToolChain); 110 111 // Apply Work on all the offloading tool chains associated with the current 112 // action. 113 if (JA.isHostOffloading(Action::OFK_Cuda)) 114 Work(*C.getSingleOffloadToolChain<Action::OFK_Cuda>()); 115 else if (JA.isDeviceOffloading(Action::OFK_Cuda)) 116 Work(*C.getSingleOffloadToolChain<Action::OFK_Host>()); 117 else if (JA.isHostOffloading(Action::OFK_HIP)) 118 Work(*C.getSingleOffloadToolChain<Action::OFK_HIP>()); 119 else if (JA.isDeviceOffloading(Action::OFK_HIP)) 120 Work(*C.getSingleOffloadToolChain<Action::OFK_Host>()); 121 122 if (JA.isHostOffloading(Action::OFK_OpenMP)) { 123 auto TCs = C.getOffloadToolChains<Action::OFK_OpenMP>(); 124 for (auto II = TCs.first, IE = TCs.second; II != IE; ++II) 125 Work(*II->second); 126 } else if (JA.isDeviceOffloading(Action::OFK_OpenMP)) 127 Work(*C.getSingleOffloadToolChain<Action::OFK_Host>()); 128 129 // 130 // TODO: Add support for other offloading programming models here. 131 // 132 } 133 134 /// This is a helper function for validating the optional refinement step 135 /// parameter in reciprocal argument strings. Return false if there is an error 136 /// parsing the refinement step. Otherwise, return true and set the Position 137 /// of the refinement step in the input string. 138 static bool getRefinementStep(StringRef In, const Driver &D, 139 const Arg &A, size_t &Position) { 140 const char RefinementStepToken = ':'; 141 Position = In.find(RefinementStepToken); 142 if (Position != StringRef::npos) { 143 StringRef Option = A.getOption().getName(); 144 StringRef RefStep = In.substr(Position + 1); 145 // Allow exactly one numeric character for the additional refinement 146 // step parameter. This is reasonable for all currently-supported 147 // operations and architectures because we would expect that a larger value 148 // of refinement steps would cause the estimate "optimization" to 149 // under-perform the native operation. Also, if the estimate does not 150 // converge quickly, it probably will not ever converge, so further 151 // refinement steps will not produce a better answer. 152 if (RefStep.size() != 1) { 153 D.Diag(diag::err_drv_invalid_value) << Option << RefStep; 154 return false; 155 } 156 char RefStepChar = RefStep[0]; 157 if (RefStepChar < '0' || RefStepChar > '9') { 158 D.Diag(diag::err_drv_invalid_value) << Option << RefStep; 159 return false; 160 } 161 } 162 return true; 163 } 164 165 /// The -mrecip flag requires processing of many optional parameters. 166 static void ParseMRecip(const Driver &D, const ArgList &Args, 167 ArgStringList &OutStrings) { 168 StringRef DisabledPrefixIn = "!"; 169 StringRef DisabledPrefixOut = "!"; 170 StringRef EnabledPrefixOut = ""; 171 StringRef Out = "-mrecip="; 172 173 Arg *A = Args.getLastArg(options::OPT_mrecip, options::OPT_mrecip_EQ); 174 if (!A) 175 return; 176 177 unsigned NumOptions = A->getNumValues(); 178 if (NumOptions == 0) { 179 // No option is the same as "all". 180 OutStrings.push_back(Args.MakeArgString(Out + "all")); 181 return; 182 } 183 184 // Pass through "all", "none", or "default" with an optional refinement step. 185 if (NumOptions == 1) { 186 StringRef Val = A->getValue(0); 187 size_t RefStepLoc; 188 if (!getRefinementStep(Val, D, *A, RefStepLoc)) 189 return; 190 StringRef ValBase = Val.slice(0, RefStepLoc); 191 if (ValBase == "all" || ValBase == "none" || ValBase == "default") { 192 OutStrings.push_back(Args.MakeArgString(Out + Val)); 193 return; 194 } 195 } 196 197 // Each reciprocal type may be enabled or disabled individually. 198 // Check each input value for validity, concatenate them all back together, 199 // and pass through. 200 201 llvm::StringMap<bool> OptionStrings; 202 OptionStrings.insert(std::make_pair("divd", false)); 203 OptionStrings.insert(std::make_pair("divf", false)); 204 OptionStrings.insert(std::make_pair("divh", false)); 205 OptionStrings.insert(std::make_pair("vec-divd", false)); 206 OptionStrings.insert(std::make_pair("vec-divf", false)); 207 OptionStrings.insert(std::make_pair("vec-divh", false)); 208 OptionStrings.insert(std::make_pair("sqrtd", false)); 209 OptionStrings.insert(std::make_pair("sqrtf", false)); 210 OptionStrings.insert(std::make_pair("sqrth", false)); 211 OptionStrings.insert(std::make_pair("vec-sqrtd", false)); 212 OptionStrings.insert(std::make_pair("vec-sqrtf", false)); 213 OptionStrings.insert(std::make_pair("vec-sqrth", false)); 214 215 for (unsigned i = 0; i != NumOptions; ++i) { 216 StringRef Val = A->getValue(i); 217 218 bool IsDisabled = Val.startswith(DisabledPrefixIn); 219 // Ignore the disablement token for string matching. 220 if (IsDisabled) 221 Val = Val.substr(1); 222 223 size_t RefStep; 224 if (!getRefinementStep(Val, D, *A, RefStep)) 225 return; 226 227 StringRef ValBase = Val.slice(0, RefStep); 228 llvm::StringMap<bool>::iterator OptionIter = OptionStrings.find(ValBase); 229 if (OptionIter == OptionStrings.end()) { 230 // Try again specifying float suffix. 231 OptionIter = OptionStrings.find(ValBase.str() + 'f'); 232 if (OptionIter == OptionStrings.end()) { 233 // The input name did not match any known option string. 234 D.Diag(diag::err_drv_unknown_argument) << Val; 235 return; 236 } 237 // The option was specified without a half or float or double suffix. 238 // Make sure that the double or half entry was not already specified. 239 // The float entry will be checked below. 240 if (OptionStrings[ValBase.str() + 'd'] || 241 OptionStrings[ValBase.str() + 'h']) { 242 D.Diag(diag::err_drv_invalid_value) << A->getOption().getName() << Val; 243 return; 244 } 245 } 246 247 if (OptionIter->second == true) { 248 // Duplicate option specified. 249 D.Diag(diag::err_drv_invalid_value) << A->getOption().getName() << Val; 250 return; 251 } 252 253 // Mark the matched option as found. Do not allow duplicate specifiers. 254 OptionIter->second = true; 255 256 // If the precision was not specified, also mark the double and half entry 257 // as found. 258 if (ValBase.back() != 'f' && ValBase.back() != 'd' && ValBase.back() != 'h') { 259 OptionStrings[ValBase.str() + 'd'] = true; 260 OptionStrings[ValBase.str() + 'h'] = true; 261 } 262 263 // Build the output string. 264 StringRef Prefix = IsDisabled ? DisabledPrefixOut : EnabledPrefixOut; 265 Out = Args.MakeArgString(Out + Prefix + Val); 266 if (i != NumOptions - 1) 267 Out = Args.MakeArgString(Out + ","); 268 } 269 270 OutStrings.push_back(Args.MakeArgString(Out)); 271 } 272 273 /// The -mprefer-vector-width option accepts either a positive integer 274 /// or the string "none". 275 static void ParseMPreferVectorWidth(const Driver &D, const ArgList &Args, 276 ArgStringList &CmdArgs) { 277 Arg *A = Args.getLastArg(options::OPT_mprefer_vector_width_EQ); 278 if (!A) 279 return; 280 281 StringRef Value = A->getValue(); 282 if (Value == "none") { 283 CmdArgs.push_back("-mprefer-vector-width=none"); 284 } else { 285 unsigned Width; 286 if (Value.getAsInteger(10, Width)) { 287 D.Diag(diag::err_drv_invalid_value) << A->getOption().getName() << Value; 288 return; 289 } 290 CmdArgs.push_back(Args.MakeArgString("-mprefer-vector-width=" + Value)); 291 } 292 } 293 294 static void getWebAssemblyTargetFeatures(const ArgList &Args, 295 std::vector<StringRef> &Features) { 296 handleTargetFeaturesGroup(Args, Features, options::OPT_m_wasm_Features_Group); 297 } 298 299 static void getTargetFeatures(const Driver &D, const llvm::Triple &Triple, 300 const ArgList &Args, ArgStringList &CmdArgs, 301 bool ForAS, bool IsAux = false) { 302 std::vector<StringRef> Features; 303 switch (Triple.getArch()) { 304 default: 305 break; 306 case llvm::Triple::mips: 307 case llvm::Triple::mipsel: 308 case llvm::Triple::mips64: 309 case llvm::Triple::mips64el: 310 mips::getMIPSTargetFeatures(D, Triple, Args, Features); 311 break; 312 313 case llvm::Triple::arm: 314 case llvm::Triple::armeb: 315 case llvm::Triple::thumb: 316 case llvm::Triple::thumbeb: 317 arm::getARMTargetFeatures(D, Triple, Args, Features, ForAS); 318 break; 319 320 case llvm::Triple::ppc: 321 case llvm::Triple::ppcle: 322 case llvm::Triple::ppc64: 323 case llvm::Triple::ppc64le: 324 ppc::getPPCTargetFeatures(D, Triple, Args, Features); 325 break; 326 case llvm::Triple::riscv32: 327 case llvm::Triple::riscv64: 328 riscv::getRISCVTargetFeatures(D, Triple, Args, Features); 329 break; 330 case llvm::Triple::systemz: 331 systemz::getSystemZTargetFeatures(D, Args, Features); 332 break; 333 case llvm::Triple::aarch64: 334 case llvm::Triple::aarch64_32: 335 case llvm::Triple::aarch64_be: 336 aarch64::getAArch64TargetFeatures(D, Triple, Args, Features, ForAS); 337 break; 338 case llvm::Triple::x86: 339 case llvm::Triple::x86_64: 340 x86::getX86TargetFeatures(D, Triple, Args, Features); 341 break; 342 case llvm::Triple::hexagon: 343 hexagon::getHexagonTargetFeatures(D, Args, Features); 344 break; 345 case llvm::Triple::wasm32: 346 case llvm::Triple::wasm64: 347 getWebAssemblyTargetFeatures(Args, Features); 348 break; 349 case llvm::Triple::sparc: 350 case llvm::Triple::sparcel: 351 case llvm::Triple::sparcv9: 352 sparc::getSparcTargetFeatures(D, Args, Features); 353 break; 354 case llvm::Triple::r600: 355 case llvm::Triple::amdgcn: 356 amdgpu::getAMDGPUTargetFeatures(D, Triple, Args, Features); 357 break; 358 case llvm::Triple::nvptx: 359 case llvm::Triple::nvptx64: 360 NVPTX::getNVPTXTargetFeatures(D, Triple, Args, Features); 361 break; 362 case llvm::Triple::m68k: 363 m68k::getM68kTargetFeatures(D, Triple, Args, Features); 364 break; 365 case llvm::Triple::msp430: 366 msp430::getMSP430TargetFeatures(D, Args, Features); 367 break; 368 case llvm::Triple::ve: 369 ve::getVETargetFeatures(D, Args, Features); 370 break; 371 case llvm::Triple::csky: 372 csky::getCSKYTargetFeatures(D, Triple, Args, CmdArgs, Features); 373 break; 374 } 375 376 for (auto Feature : unifyTargetFeatures(Features)) { 377 CmdArgs.push_back(IsAux ? "-aux-target-feature" : "-target-feature"); 378 CmdArgs.push_back(Feature.data()); 379 } 380 } 381 382 static bool 383 shouldUseExceptionTablesForObjCExceptions(const ObjCRuntime &runtime, 384 const llvm::Triple &Triple) { 385 // We use the zero-cost exception tables for Objective-C if the non-fragile 386 // ABI is enabled or when compiling for x86_64 and ARM on Snow Leopard and 387 // later. 388 if (runtime.isNonFragile()) 389 return true; 390 391 if (!Triple.isMacOSX()) 392 return false; 393 394 return (!Triple.isMacOSXVersionLT(10, 5) && 395 (Triple.getArch() == llvm::Triple::x86_64 || 396 Triple.getArch() == llvm::Triple::arm)); 397 } 398 399 /// Adds exception related arguments to the driver command arguments. There's a 400 /// main flag, -fexceptions and also language specific flags to enable/disable 401 /// C++ and Objective-C exceptions. This makes it possible to for example 402 /// disable C++ exceptions but enable Objective-C exceptions. 403 static bool addExceptionArgs(const ArgList &Args, types::ID InputType, 404 const ToolChain &TC, bool KernelOrKext, 405 const ObjCRuntime &objcRuntime, 406 ArgStringList &CmdArgs) { 407 const llvm::Triple &Triple = TC.getTriple(); 408 409 if (KernelOrKext) { 410 // -mkernel and -fapple-kext imply no exceptions, so claim exception related 411 // arguments now to avoid warnings about unused arguments. 412 Args.ClaimAllArgs(options::OPT_fexceptions); 413 Args.ClaimAllArgs(options::OPT_fno_exceptions); 414 Args.ClaimAllArgs(options::OPT_fobjc_exceptions); 415 Args.ClaimAllArgs(options::OPT_fno_objc_exceptions); 416 Args.ClaimAllArgs(options::OPT_fcxx_exceptions); 417 Args.ClaimAllArgs(options::OPT_fno_cxx_exceptions); 418 Args.ClaimAllArgs(options::OPT_fasync_exceptions); 419 Args.ClaimAllArgs(options::OPT_fno_async_exceptions); 420 return false; 421 } 422 423 // See if the user explicitly enabled exceptions. 424 bool EH = Args.hasFlag(options::OPT_fexceptions, options::OPT_fno_exceptions, 425 false); 426 427 bool EHa = Args.hasFlag(options::OPT_fasync_exceptions, 428 options::OPT_fno_async_exceptions, false); 429 if (EHa) { 430 CmdArgs.push_back("-fasync-exceptions"); 431 EH = true; 432 } 433 434 // Obj-C exceptions are enabled by default, regardless of -fexceptions. This 435 // is not necessarily sensible, but follows GCC. 436 if (types::isObjC(InputType) && 437 Args.hasFlag(options::OPT_fobjc_exceptions, 438 options::OPT_fno_objc_exceptions, true)) { 439 CmdArgs.push_back("-fobjc-exceptions"); 440 441 EH |= shouldUseExceptionTablesForObjCExceptions(objcRuntime, Triple); 442 } 443 444 if (types::isCXX(InputType)) { 445 // Disable C++ EH by default on XCore and PS4/PS5. 446 bool CXXExceptionsEnabled = Triple.getArch() != llvm::Triple::xcore && 447 !Triple.isPS() && !Triple.isDriverKit(); 448 Arg *ExceptionArg = Args.getLastArg( 449 options::OPT_fcxx_exceptions, options::OPT_fno_cxx_exceptions, 450 options::OPT_fexceptions, options::OPT_fno_exceptions); 451 if (ExceptionArg) 452 CXXExceptionsEnabled = 453 ExceptionArg->getOption().matches(options::OPT_fcxx_exceptions) || 454 ExceptionArg->getOption().matches(options::OPT_fexceptions); 455 456 if (CXXExceptionsEnabled) { 457 CmdArgs.push_back("-fcxx-exceptions"); 458 459 EH = true; 460 } 461 } 462 463 // OPT_fignore_exceptions means exception could still be thrown, 464 // but no clean up or catch would happen in current module. 465 // So we do not set EH to false. 466 Args.AddLastArg(CmdArgs, options::OPT_fignore_exceptions); 467 468 if (EH) 469 CmdArgs.push_back("-fexceptions"); 470 return EH; 471 } 472 473 static bool ShouldEnableAutolink(const ArgList &Args, const ToolChain &TC, 474 const JobAction &JA) { 475 bool Default = true; 476 if (TC.getTriple().isOSDarwin()) { 477 // The native darwin assembler doesn't support the linker_option directives, 478 // so we disable them if we think the .s file will be passed to it. 479 Default = TC.useIntegratedAs(); 480 } 481 // The linker_option directives are intended for host compilation. 482 if (JA.isDeviceOffloading(Action::OFK_Cuda) || 483 JA.isDeviceOffloading(Action::OFK_HIP)) 484 Default = false; 485 return Args.hasFlag(options::OPT_fautolink, options::OPT_fno_autolink, 486 Default); 487 } 488 489 // Convert an arg of the form "-gN" or "-ggdbN" or one of their aliases 490 // to the corresponding DebugInfoKind. 491 static codegenoptions::DebugInfoKind DebugLevelToInfoKind(const Arg &A) { 492 assert(A.getOption().matches(options::OPT_gN_Group) && 493 "Not a -g option that specifies a debug-info level"); 494 if (A.getOption().matches(options::OPT_g0) || 495 A.getOption().matches(options::OPT_ggdb0)) 496 return codegenoptions::NoDebugInfo; 497 if (A.getOption().matches(options::OPT_gline_tables_only) || 498 A.getOption().matches(options::OPT_ggdb1)) 499 return codegenoptions::DebugLineTablesOnly; 500 if (A.getOption().matches(options::OPT_gline_directives_only)) 501 return codegenoptions::DebugDirectivesOnly; 502 return codegenoptions::DebugInfoConstructor; 503 } 504 505 static bool mustUseNonLeafFramePointerForTarget(const llvm::Triple &Triple) { 506 switch (Triple.getArch()){ 507 default: 508 return false; 509 case llvm::Triple::arm: 510 case llvm::Triple::thumb: 511 // ARM Darwin targets require a frame pointer to be always present to aid 512 // offline debugging via backtraces. 513 return Triple.isOSDarwin(); 514 } 515 } 516 517 static bool useFramePointerForTargetByDefault(const ArgList &Args, 518 const llvm::Triple &Triple) { 519 if (Args.hasArg(options::OPT_pg) && !Args.hasArg(options::OPT_mfentry)) 520 return true; 521 522 switch (Triple.getArch()) { 523 case llvm::Triple::xcore: 524 case llvm::Triple::wasm32: 525 case llvm::Triple::wasm64: 526 case llvm::Triple::msp430: 527 // XCore never wants frame pointers, regardless of OS. 528 // WebAssembly never wants frame pointers. 529 return false; 530 case llvm::Triple::ppc: 531 case llvm::Triple::ppcle: 532 case llvm::Triple::ppc64: 533 case llvm::Triple::ppc64le: 534 case llvm::Triple::riscv32: 535 case llvm::Triple::riscv64: 536 case llvm::Triple::amdgcn: 537 case llvm::Triple::r600: 538 case llvm::Triple::csky: 539 return !areOptimizationsEnabled(Args); 540 default: 541 break; 542 } 543 544 if (Triple.isOSFuchsia() || Triple.isOSNetBSD()) { 545 return !areOptimizationsEnabled(Args); 546 } 547 548 if (Triple.isOSLinux() || Triple.getOS() == llvm::Triple::CloudABI || 549 Triple.isOSHurd()) { 550 switch (Triple.getArch()) { 551 // Don't use a frame pointer on linux if optimizing for certain targets. 552 case llvm::Triple::arm: 553 case llvm::Triple::armeb: 554 case llvm::Triple::thumb: 555 case llvm::Triple::thumbeb: 556 if (Triple.isAndroid()) 557 return true; 558 LLVM_FALLTHROUGH; 559 case llvm::Triple::mips64: 560 case llvm::Triple::mips64el: 561 case llvm::Triple::mips: 562 case llvm::Triple::mipsel: 563 case llvm::Triple::systemz: 564 case llvm::Triple::x86: 565 case llvm::Triple::x86_64: 566 return !areOptimizationsEnabled(Args); 567 default: 568 return true; 569 } 570 } 571 572 if (Triple.isOSWindows()) { 573 switch (Triple.getArch()) { 574 case llvm::Triple::x86: 575 return !areOptimizationsEnabled(Args); 576 case llvm::Triple::x86_64: 577 return Triple.isOSBinFormatMachO(); 578 case llvm::Triple::arm: 579 case llvm::Triple::thumb: 580 // Windows on ARM builds with FPO disabled to aid fast stack walking 581 return true; 582 default: 583 // All other supported Windows ISAs use xdata unwind information, so frame 584 // pointers are not generally useful. 585 return false; 586 } 587 } 588 589 return true; 590 } 591 592 static CodeGenOptions::FramePointerKind 593 getFramePointerKind(const ArgList &Args, const llvm::Triple &Triple) { 594 // We have 4 states: 595 // 596 // 00) leaf retained, non-leaf retained 597 // 01) leaf retained, non-leaf omitted (this is invalid) 598 // 10) leaf omitted, non-leaf retained 599 // (what -momit-leaf-frame-pointer was designed for) 600 // 11) leaf omitted, non-leaf omitted 601 // 602 // "omit" options taking precedence over "no-omit" options is the only way 603 // to make 3 valid states representable 604 Arg *A = Args.getLastArg(options::OPT_fomit_frame_pointer, 605 options::OPT_fno_omit_frame_pointer); 606 bool OmitFP = A && A->getOption().matches(options::OPT_fomit_frame_pointer); 607 bool NoOmitFP = 608 A && A->getOption().matches(options::OPT_fno_omit_frame_pointer); 609 bool OmitLeafFP = 610 Args.hasFlag(options::OPT_momit_leaf_frame_pointer, 611 options::OPT_mno_omit_leaf_frame_pointer, 612 Triple.isAArch64() || Triple.isPS() || Triple.isVE()); 613 if (NoOmitFP || mustUseNonLeafFramePointerForTarget(Triple) || 614 (!OmitFP && useFramePointerForTargetByDefault(Args, Triple))) { 615 if (OmitLeafFP) 616 return CodeGenOptions::FramePointerKind::NonLeaf; 617 return CodeGenOptions::FramePointerKind::All; 618 } 619 return CodeGenOptions::FramePointerKind::None; 620 } 621 622 /// Add a CC1 option to specify the debug compilation directory. 623 static const char *addDebugCompDirArg(const ArgList &Args, 624 ArgStringList &CmdArgs, 625 const llvm::vfs::FileSystem &VFS) { 626 if (Arg *A = Args.getLastArg(options::OPT_ffile_compilation_dir_EQ, 627 options::OPT_fdebug_compilation_dir_EQ)) { 628 if (A->getOption().matches(options::OPT_ffile_compilation_dir_EQ)) 629 CmdArgs.push_back(Args.MakeArgString(Twine("-fdebug-compilation-dir=") + 630 A->getValue())); 631 else 632 A->render(Args, CmdArgs); 633 } else if (llvm::ErrorOr<std::string> CWD = 634 VFS.getCurrentWorkingDirectory()) { 635 CmdArgs.push_back(Args.MakeArgString("-fdebug-compilation-dir=" + *CWD)); 636 } 637 StringRef Path(CmdArgs.back()); 638 return Path.substr(Path.find('=') + 1).data(); 639 } 640 641 static void addDebugObjectName(const ArgList &Args, ArgStringList &CmdArgs, 642 const char *DebugCompilationDir, 643 const char *OutputFileName) { 644 // No need to generate a value for -object-file-name if it was provided. 645 for (auto *Arg : Args.filtered(options::OPT_Xclang)) 646 if (StringRef(Arg->getValue()).startswith("-object-file-name")) 647 return; 648 649 if (Args.hasArg(options::OPT_object_file_name_EQ)) 650 return; 651 652 SmallString<128> ObjFileNameForDebug(OutputFileName); 653 if (ObjFileNameForDebug != "-" && 654 !llvm::sys::path::is_absolute(ObjFileNameForDebug) && 655 (!DebugCompilationDir || 656 llvm::sys::path::is_absolute(DebugCompilationDir))) { 657 // Make the path absolute in the debug infos like MSVC does. 658 llvm::sys::fs::make_absolute(ObjFileNameForDebug); 659 } 660 CmdArgs.push_back( 661 Args.MakeArgString(Twine("-object-file-name=") + ObjFileNameForDebug)); 662 } 663 664 /// Add a CC1 and CC1AS option to specify the debug file path prefix map. 665 static void addDebugPrefixMapArg(const Driver &D, const ToolChain &TC, 666 const ArgList &Args, ArgStringList &CmdArgs) { 667 auto AddOneArg = [&](StringRef Map, StringRef Name) { 668 if (!Map.contains('=')) 669 D.Diag(diag::err_drv_invalid_argument_to_option) << Map << Name; 670 else 671 CmdArgs.push_back(Args.MakeArgString("-fdebug-prefix-map=" + Map)); 672 }; 673 674 for (const Arg *A : Args.filtered(options::OPT_ffile_prefix_map_EQ, 675 options::OPT_fdebug_prefix_map_EQ)) { 676 AddOneArg(A->getValue(), A->getOption().getName()); 677 A->claim(); 678 } 679 std::string GlobalRemapEntry = TC.GetGlobalDebugPathRemapping(); 680 if (GlobalRemapEntry.empty()) 681 return; 682 AddOneArg(GlobalRemapEntry, "environment"); 683 } 684 685 /// Add a CC1 and CC1AS option to specify the macro file path prefix map. 686 static void addMacroPrefixMapArg(const Driver &D, const ArgList &Args, 687 ArgStringList &CmdArgs) { 688 for (const Arg *A : Args.filtered(options::OPT_ffile_prefix_map_EQ, 689 options::OPT_fmacro_prefix_map_EQ)) { 690 StringRef Map = A->getValue(); 691 if (!Map.contains('=')) 692 D.Diag(diag::err_drv_invalid_argument_to_option) 693 << Map << A->getOption().getName(); 694 else 695 CmdArgs.push_back(Args.MakeArgString("-fmacro-prefix-map=" + Map)); 696 A->claim(); 697 } 698 } 699 700 /// Add a CC1 and CC1AS option to specify the coverage file path prefix map. 701 static void addCoveragePrefixMapArg(const Driver &D, const ArgList &Args, 702 ArgStringList &CmdArgs) { 703 for (const Arg *A : Args.filtered(options::OPT_ffile_prefix_map_EQ, 704 options::OPT_fcoverage_prefix_map_EQ)) { 705 StringRef Map = A->getValue(); 706 if (!Map.contains('=')) 707 D.Diag(diag::err_drv_invalid_argument_to_option) 708 << Map << A->getOption().getName(); 709 else 710 CmdArgs.push_back(Args.MakeArgString("-fcoverage-prefix-map=" + Map)); 711 A->claim(); 712 } 713 } 714 715 /// Vectorize at all optimization levels greater than 1 except for -Oz. 716 /// For -Oz the loop vectorizer is disabled, while the slp vectorizer is 717 /// enabled. 718 static bool shouldEnableVectorizerAtOLevel(const ArgList &Args, bool isSlpVec) { 719 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) { 720 if (A->getOption().matches(options::OPT_O4) || 721 A->getOption().matches(options::OPT_Ofast)) 722 return true; 723 724 if (A->getOption().matches(options::OPT_O0)) 725 return false; 726 727 assert(A->getOption().matches(options::OPT_O) && "Must have a -O flag"); 728 729 // Vectorize -Os. 730 StringRef S(A->getValue()); 731 if (S == "s") 732 return true; 733 734 // Don't vectorize -Oz, unless it's the slp vectorizer. 735 if (S == "z") 736 return isSlpVec; 737 738 unsigned OptLevel = 0; 739 if (S.getAsInteger(10, OptLevel)) 740 return false; 741 742 return OptLevel > 1; 743 } 744 745 return false; 746 } 747 748 /// Add -x lang to \p CmdArgs for \p Input. 749 static void addDashXForInput(const ArgList &Args, const InputInfo &Input, 750 ArgStringList &CmdArgs) { 751 // When using -verify-pch, we don't want to provide the type 752 // 'precompiled-header' if it was inferred from the file extension 753 if (Args.hasArg(options::OPT_verify_pch) && Input.getType() == types::TY_PCH) 754 return; 755 756 CmdArgs.push_back("-x"); 757 if (Args.hasArg(options::OPT_rewrite_objc)) 758 CmdArgs.push_back(types::getTypeName(types::TY_PP_ObjCXX)); 759 else { 760 // Map the driver type to the frontend type. This is mostly an identity 761 // mapping, except that the distinction between module interface units 762 // and other source files does not exist at the frontend layer. 763 const char *ClangType; 764 switch (Input.getType()) { 765 case types::TY_CXXModule: 766 ClangType = "c++"; 767 break; 768 case types::TY_PP_CXXModule: 769 ClangType = "c++-cpp-output"; 770 break; 771 default: 772 ClangType = types::getTypeName(Input.getType()); 773 break; 774 } 775 CmdArgs.push_back(ClangType); 776 } 777 } 778 779 static void addPGOAndCoverageFlags(const ToolChain &TC, Compilation &C, 780 const Driver &D, const InputInfo &Output, 781 const ArgList &Args, SanitizerArgs &SanArgs, 782 ArgStringList &CmdArgs) { 783 784 auto *PGOGenerateArg = Args.getLastArg(options::OPT_fprofile_generate, 785 options::OPT_fprofile_generate_EQ, 786 options::OPT_fno_profile_generate); 787 if (PGOGenerateArg && 788 PGOGenerateArg->getOption().matches(options::OPT_fno_profile_generate)) 789 PGOGenerateArg = nullptr; 790 791 auto *CSPGOGenerateArg = Args.getLastArg(options::OPT_fcs_profile_generate, 792 options::OPT_fcs_profile_generate_EQ, 793 options::OPT_fno_profile_generate); 794 if (CSPGOGenerateArg && 795 CSPGOGenerateArg->getOption().matches(options::OPT_fno_profile_generate)) 796 CSPGOGenerateArg = nullptr; 797 798 auto *ProfileGenerateArg = Args.getLastArg( 799 options::OPT_fprofile_instr_generate, 800 options::OPT_fprofile_instr_generate_EQ, 801 options::OPT_fno_profile_instr_generate); 802 if (ProfileGenerateArg && 803 ProfileGenerateArg->getOption().matches( 804 options::OPT_fno_profile_instr_generate)) 805 ProfileGenerateArg = nullptr; 806 807 if (PGOGenerateArg && ProfileGenerateArg) 808 D.Diag(diag::err_drv_argument_not_allowed_with) 809 << PGOGenerateArg->getSpelling() << ProfileGenerateArg->getSpelling(); 810 811 auto *ProfileUseArg = getLastProfileUseArg(Args); 812 813 if (PGOGenerateArg && ProfileUseArg) 814 D.Diag(diag::err_drv_argument_not_allowed_with) 815 << ProfileUseArg->getSpelling() << PGOGenerateArg->getSpelling(); 816 817 if (ProfileGenerateArg && ProfileUseArg) 818 D.Diag(diag::err_drv_argument_not_allowed_with) 819 << ProfileGenerateArg->getSpelling() << ProfileUseArg->getSpelling(); 820 821 if (CSPGOGenerateArg && PGOGenerateArg) { 822 D.Diag(diag::err_drv_argument_not_allowed_with) 823 << CSPGOGenerateArg->getSpelling() << PGOGenerateArg->getSpelling(); 824 PGOGenerateArg = nullptr; 825 } 826 827 if (TC.getTriple().isOSAIX()) { 828 if (ProfileGenerateArg) 829 D.Diag(diag::err_drv_unsupported_opt_for_target) 830 << ProfileGenerateArg->getSpelling() << TC.getTriple().str(); 831 if (Arg *ProfileSampleUseArg = getLastProfileSampleUseArg(Args)) 832 D.Diag(diag::err_drv_unsupported_opt_for_target) 833 << ProfileSampleUseArg->getSpelling() << TC.getTriple().str(); 834 } 835 836 if (ProfileGenerateArg) { 837 if (ProfileGenerateArg->getOption().matches( 838 options::OPT_fprofile_instr_generate_EQ)) 839 CmdArgs.push_back(Args.MakeArgString(Twine("-fprofile-instrument-path=") + 840 ProfileGenerateArg->getValue())); 841 // The default is to use Clang Instrumentation. 842 CmdArgs.push_back("-fprofile-instrument=clang"); 843 if (TC.getTriple().isWindowsMSVCEnvironment()) { 844 // Add dependent lib for clang_rt.profile 845 CmdArgs.push_back(Args.MakeArgString( 846 "--dependent-lib=" + TC.getCompilerRTBasename(Args, "profile"))); 847 } 848 } 849 850 Arg *PGOGenArg = nullptr; 851 if (PGOGenerateArg) { 852 assert(!CSPGOGenerateArg); 853 PGOGenArg = PGOGenerateArg; 854 CmdArgs.push_back("-fprofile-instrument=llvm"); 855 } 856 if (CSPGOGenerateArg) { 857 assert(!PGOGenerateArg); 858 PGOGenArg = CSPGOGenerateArg; 859 CmdArgs.push_back("-fprofile-instrument=csllvm"); 860 } 861 if (PGOGenArg) { 862 if (TC.getTriple().isWindowsMSVCEnvironment()) { 863 // Add dependent lib for clang_rt.profile 864 CmdArgs.push_back(Args.MakeArgString( 865 "--dependent-lib=" + TC.getCompilerRTBasename(Args, "profile"))); 866 } 867 if (PGOGenArg->getOption().matches( 868 PGOGenerateArg ? options::OPT_fprofile_generate_EQ 869 : options::OPT_fcs_profile_generate_EQ)) { 870 SmallString<128> Path(PGOGenArg->getValue()); 871 llvm::sys::path::append(Path, "default_%m.profraw"); 872 CmdArgs.push_back( 873 Args.MakeArgString(Twine("-fprofile-instrument-path=") + Path)); 874 } 875 } 876 877 if (ProfileUseArg) { 878 if (ProfileUseArg->getOption().matches(options::OPT_fprofile_instr_use_EQ)) 879 CmdArgs.push_back(Args.MakeArgString( 880 Twine("-fprofile-instrument-use-path=") + ProfileUseArg->getValue())); 881 else if ((ProfileUseArg->getOption().matches( 882 options::OPT_fprofile_use_EQ) || 883 ProfileUseArg->getOption().matches( 884 options::OPT_fprofile_instr_use))) { 885 SmallString<128> Path( 886 ProfileUseArg->getNumValues() == 0 ? "" : ProfileUseArg->getValue()); 887 if (Path.empty() || llvm::sys::fs::is_directory(Path)) 888 llvm::sys::path::append(Path, "default.profdata"); 889 CmdArgs.push_back( 890 Args.MakeArgString(Twine("-fprofile-instrument-use-path=") + Path)); 891 } 892 } 893 894 bool EmitCovNotes = Args.hasFlag(options::OPT_ftest_coverage, 895 options::OPT_fno_test_coverage, false) || 896 Args.hasArg(options::OPT_coverage); 897 bool EmitCovData = TC.needsGCovInstrumentation(Args); 898 if (EmitCovNotes) 899 CmdArgs.push_back("-ftest-coverage"); 900 if (EmitCovData) 901 CmdArgs.push_back("-fprofile-arcs"); 902 903 if (Args.hasFlag(options::OPT_fcoverage_mapping, 904 options::OPT_fno_coverage_mapping, false)) { 905 if (!ProfileGenerateArg) 906 D.Diag(clang::diag::err_drv_argument_only_allowed_with) 907 << "-fcoverage-mapping" 908 << "-fprofile-instr-generate"; 909 910 CmdArgs.push_back("-fcoverage-mapping"); 911 } 912 913 if (Arg *A = Args.getLastArg(options::OPT_ffile_compilation_dir_EQ, 914 options::OPT_fcoverage_compilation_dir_EQ)) { 915 if (A->getOption().matches(options::OPT_ffile_compilation_dir_EQ)) 916 CmdArgs.push_back(Args.MakeArgString( 917 Twine("-fcoverage-compilation-dir=") + A->getValue())); 918 else 919 A->render(Args, CmdArgs); 920 } else if (llvm::ErrorOr<std::string> CWD = 921 D.getVFS().getCurrentWorkingDirectory()) { 922 CmdArgs.push_back(Args.MakeArgString("-fcoverage-compilation-dir=" + *CWD)); 923 } 924 925 if (Args.hasArg(options::OPT_fprofile_exclude_files_EQ)) { 926 auto *Arg = Args.getLastArg(options::OPT_fprofile_exclude_files_EQ); 927 if (!Args.hasArg(options::OPT_coverage)) 928 D.Diag(clang::diag::err_drv_argument_only_allowed_with) 929 << "-fprofile-exclude-files=" 930 << "--coverage"; 931 932 StringRef v = Arg->getValue(); 933 CmdArgs.push_back( 934 Args.MakeArgString(Twine("-fprofile-exclude-files=" + v))); 935 } 936 937 if (Args.hasArg(options::OPT_fprofile_filter_files_EQ)) { 938 auto *Arg = Args.getLastArg(options::OPT_fprofile_filter_files_EQ); 939 if (!Args.hasArg(options::OPT_coverage)) 940 D.Diag(clang::diag::err_drv_argument_only_allowed_with) 941 << "-fprofile-filter-files=" 942 << "--coverage"; 943 944 StringRef v = Arg->getValue(); 945 CmdArgs.push_back(Args.MakeArgString(Twine("-fprofile-filter-files=" + v))); 946 } 947 948 if (const auto *A = Args.getLastArg(options::OPT_fprofile_update_EQ)) { 949 StringRef Val = A->getValue(); 950 if (Val == "atomic" || Val == "prefer-atomic") 951 CmdArgs.push_back("-fprofile-update=atomic"); 952 else if (Val != "single") 953 D.Diag(diag::err_drv_unsupported_option_argument) 954 << A->getOption().getName() << Val; 955 } else if (SanArgs.needsTsanRt()) { 956 CmdArgs.push_back("-fprofile-update=atomic"); 957 } 958 959 int FunctionGroups = 1; 960 int SelectedFunctionGroup = 0; 961 if (const auto *A = Args.getLastArg(options::OPT_fprofile_function_groups)) { 962 StringRef Val = A->getValue(); 963 if (Val.getAsInteger(0, FunctionGroups) || FunctionGroups < 1) 964 D.Diag(diag::err_drv_invalid_int_value) << A->getAsString(Args) << Val; 965 } 966 if (const auto *A = 967 Args.getLastArg(options::OPT_fprofile_selected_function_group)) { 968 StringRef Val = A->getValue(); 969 if (Val.getAsInteger(0, SelectedFunctionGroup) || 970 SelectedFunctionGroup < 0 || SelectedFunctionGroup >= FunctionGroups) 971 D.Diag(diag::err_drv_invalid_int_value) << A->getAsString(Args) << Val; 972 } 973 if (FunctionGroups != 1) 974 CmdArgs.push_back(Args.MakeArgString("-fprofile-function-groups=" + 975 Twine(FunctionGroups))); 976 if (SelectedFunctionGroup != 0) 977 CmdArgs.push_back(Args.MakeArgString("-fprofile-selected-function-group=" + 978 Twine(SelectedFunctionGroup))); 979 980 // Leave -fprofile-dir= an unused argument unless .gcda emission is 981 // enabled. To be polite, with '-fprofile-arcs -fno-profile-arcs' consider 982 // the flag used. There is no -fno-profile-dir, so the user has no 983 // targeted way to suppress the warning. 984 Arg *FProfileDir = nullptr; 985 if (Args.hasArg(options::OPT_fprofile_arcs) || 986 Args.hasArg(options::OPT_coverage)) 987 FProfileDir = Args.getLastArg(options::OPT_fprofile_dir); 988 989 // Put the .gcno and .gcda files (if needed) next to the object file or 990 // bitcode file in the case of LTO. 991 // FIXME: There should be a simpler way to find the object file for this 992 // input, and this code probably does the wrong thing for commands that 993 // compile and link all at once. 994 if ((Args.hasArg(options::OPT_c) || Args.hasArg(options::OPT_S)) && 995 (EmitCovNotes || EmitCovData) && Output.isFilename()) { 996 SmallString<128> OutputFilename; 997 if (Arg *FinalOutput = C.getArgs().getLastArg(options::OPT__SLASH_Fo)) 998 OutputFilename = FinalOutput->getValue(); 999 else if (Arg *FinalOutput = C.getArgs().getLastArg(options::OPT_o)) 1000 OutputFilename = FinalOutput->getValue(); 1001 else 1002 OutputFilename = llvm::sys::path::filename(Output.getBaseInput()); 1003 SmallString<128> CoverageFilename = OutputFilename; 1004 if (llvm::sys::path::is_relative(CoverageFilename)) 1005 (void)D.getVFS().makeAbsolute(CoverageFilename); 1006 llvm::sys::path::replace_extension(CoverageFilename, "gcno"); 1007 1008 CmdArgs.push_back("-coverage-notes-file"); 1009 CmdArgs.push_back(Args.MakeArgString(CoverageFilename)); 1010 1011 if (EmitCovData) { 1012 if (FProfileDir) { 1013 CoverageFilename = FProfileDir->getValue(); 1014 llvm::sys::path::append(CoverageFilename, OutputFilename); 1015 } 1016 llvm::sys::path::replace_extension(CoverageFilename, "gcda"); 1017 CmdArgs.push_back("-coverage-data-file"); 1018 CmdArgs.push_back(Args.MakeArgString(CoverageFilename)); 1019 } 1020 } 1021 } 1022 1023 /// Check whether the given input tree contains any compilation actions. 1024 static bool ContainsCompileAction(const Action *A) { 1025 if (isa<CompileJobAction>(A) || isa<BackendJobAction>(A)) 1026 return true; 1027 1028 return llvm::any_of(A->inputs(), ContainsCompileAction); 1029 } 1030 1031 /// Check if -relax-all should be passed to the internal assembler. 1032 /// This is done by default when compiling non-assembler source with -O0. 1033 static bool UseRelaxAll(Compilation &C, const ArgList &Args) { 1034 bool RelaxDefault = true; 1035 1036 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) 1037 RelaxDefault = A->getOption().matches(options::OPT_O0); 1038 1039 if (RelaxDefault) { 1040 RelaxDefault = false; 1041 for (const auto &Act : C.getActions()) { 1042 if (ContainsCompileAction(Act)) { 1043 RelaxDefault = true; 1044 break; 1045 } 1046 } 1047 } 1048 1049 return Args.hasFlag(options::OPT_mrelax_all, options::OPT_mno_relax_all, 1050 RelaxDefault); 1051 } 1052 1053 // Extract the integer N from a string spelled "-dwarf-N", returning 0 1054 // on mismatch. The StringRef input (rather than an Arg) allows 1055 // for use by the "-Xassembler" option parser. 1056 static unsigned DwarfVersionNum(StringRef ArgValue) { 1057 return llvm::StringSwitch<unsigned>(ArgValue) 1058 .Case("-gdwarf-2", 2) 1059 .Case("-gdwarf-3", 3) 1060 .Case("-gdwarf-4", 4) 1061 .Case("-gdwarf-5", 5) 1062 .Default(0); 1063 } 1064 1065 // Find a DWARF format version option. 1066 // This function is a complementary for DwarfVersionNum(). 1067 static const Arg *getDwarfNArg(const ArgList &Args) { 1068 return Args.getLastArg(options::OPT_gdwarf_2, options::OPT_gdwarf_3, 1069 options::OPT_gdwarf_4, options::OPT_gdwarf_5, 1070 options::OPT_gdwarf); 1071 } 1072 1073 static void RenderDebugEnablingArgs(const ArgList &Args, ArgStringList &CmdArgs, 1074 codegenoptions::DebugInfoKind DebugInfoKind, 1075 unsigned DwarfVersion, 1076 llvm::DebuggerKind DebuggerTuning) { 1077 switch (DebugInfoKind) { 1078 case codegenoptions::DebugDirectivesOnly: 1079 CmdArgs.push_back("-debug-info-kind=line-directives-only"); 1080 break; 1081 case codegenoptions::DebugLineTablesOnly: 1082 CmdArgs.push_back("-debug-info-kind=line-tables-only"); 1083 break; 1084 case codegenoptions::DebugInfoConstructor: 1085 CmdArgs.push_back("-debug-info-kind=constructor"); 1086 break; 1087 case codegenoptions::LimitedDebugInfo: 1088 CmdArgs.push_back("-debug-info-kind=limited"); 1089 break; 1090 case codegenoptions::FullDebugInfo: 1091 CmdArgs.push_back("-debug-info-kind=standalone"); 1092 break; 1093 case codegenoptions::UnusedTypeInfo: 1094 CmdArgs.push_back("-debug-info-kind=unused-types"); 1095 break; 1096 default: 1097 break; 1098 } 1099 if (DwarfVersion > 0) 1100 CmdArgs.push_back( 1101 Args.MakeArgString("-dwarf-version=" + Twine(DwarfVersion))); 1102 switch (DebuggerTuning) { 1103 case llvm::DebuggerKind::GDB: 1104 CmdArgs.push_back("-debugger-tuning=gdb"); 1105 break; 1106 case llvm::DebuggerKind::LLDB: 1107 CmdArgs.push_back("-debugger-tuning=lldb"); 1108 break; 1109 case llvm::DebuggerKind::SCE: 1110 CmdArgs.push_back("-debugger-tuning=sce"); 1111 break; 1112 case llvm::DebuggerKind::DBX: 1113 CmdArgs.push_back("-debugger-tuning=dbx"); 1114 break; 1115 default: 1116 break; 1117 } 1118 } 1119 1120 static bool checkDebugInfoOption(const Arg *A, const ArgList &Args, 1121 const Driver &D, const ToolChain &TC) { 1122 assert(A && "Expected non-nullptr argument."); 1123 if (TC.supportsDebugInfoOption(A)) 1124 return true; 1125 D.Diag(diag::warn_drv_unsupported_debug_info_opt_for_target) 1126 << A->getAsString(Args) << TC.getTripleString(); 1127 return false; 1128 } 1129 1130 static void RenderDebugInfoCompressionArgs(const ArgList &Args, 1131 ArgStringList &CmdArgs, 1132 const Driver &D, 1133 const ToolChain &TC) { 1134 const Arg *A = Args.getLastArg(options::OPT_gz_EQ); 1135 if (!A) 1136 return; 1137 if (checkDebugInfoOption(A, Args, D, TC)) { 1138 StringRef Value = A->getValue(); 1139 if (Value == "none") { 1140 CmdArgs.push_back("--compress-debug-sections=none"); 1141 } else if (Value == "zlib") { 1142 if (llvm::compression::zlib::isAvailable()) { 1143 CmdArgs.push_back( 1144 Args.MakeArgString("--compress-debug-sections=" + Twine(Value))); 1145 } else { 1146 D.Diag(diag::warn_debug_compression_unavailable); 1147 } 1148 } else { 1149 D.Diag(diag::err_drv_unsupported_option_argument) 1150 << A->getOption().getName() << Value; 1151 } 1152 } 1153 } 1154 1155 static const char *RelocationModelName(llvm::Reloc::Model Model) { 1156 switch (Model) { 1157 case llvm::Reloc::Static: 1158 return "static"; 1159 case llvm::Reloc::PIC_: 1160 return "pic"; 1161 case llvm::Reloc::DynamicNoPIC: 1162 return "dynamic-no-pic"; 1163 case llvm::Reloc::ROPI: 1164 return "ropi"; 1165 case llvm::Reloc::RWPI: 1166 return "rwpi"; 1167 case llvm::Reloc::ROPI_RWPI: 1168 return "ropi-rwpi"; 1169 } 1170 llvm_unreachable("Unknown Reloc::Model kind"); 1171 } 1172 static void handleAMDGPUCodeObjectVersionOptions(const Driver &D, 1173 const ArgList &Args, 1174 ArgStringList &CmdArgs, 1175 bool IsCC1As = false) { 1176 // If no version was requested by the user, use the default value from the 1177 // back end. This is consistent with the value returned from 1178 // getAMDGPUCodeObjectVersion. This lets clang emit IR for amdgpu without 1179 // requiring the corresponding llvm to have the AMDGPU target enabled, 1180 // provided the user (e.g. front end tests) can use the default. 1181 if (haveAMDGPUCodeObjectVersionArgument(D, Args)) { 1182 unsigned CodeObjVer = getAMDGPUCodeObjectVersion(D, Args); 1183 CmdArgs.insert(CmdArgs.begin() + 1, 1184 Args.MakeArgString(Twine("--amdhsa-code-object-version=") + 1185 Twine(CodeObjVer))); 1186 CmdArgs.insert(CmdArgs.begin() + 1, "-mllvm"); 1187 // -cc1as does not accept -mcode-object-version option. 1188 if (!IsCC1As) 1189 CmdArgs.insert(CmdArgs.begin() + 1, 1190 Args.MakeArgString(Twine("-mcode-object-version=") + 1191 Twine(CodeObjVer))); 1192 } 1193 } 1194 1195 void Clang::AddPreprocessingOptions(Compilation &C, const JobAction &JA, 1196 const Driver &D, const ArgList &Args, 1197 ArgStringList &CmdArgs, 1198 const InputInfo &Output, 1199 const InputInfoList &Inputs) const { 1200 const bool IsIAMCU = getToolChain().getTriple().isOSIAMCU(); 1201 1202 CheckPreprocessingOptions(D, Args); 1203 1204 Args.AddLastArg(CmdArgs, options::OPT_C); 1205 Args.AddLastArg(CmdArgs, options::OPT_CC); 1206 1207 // Handle dependency file generation. 1208 Arg *ArgM = Args.getLastArg(options::OPT_MM); 1209 if (!ArgM) 1210 ArgM = Args.getLastArg(options::OPT_M); 1211 Arg *ArgMD = Args.getLastArg(options::OPT_MMD); 1212 if (!ArgMD) 1213 ArgMD = Args.getLastArg(options::OPT_MD); 1214 1215 // -M and -MM imply -w. 1216 if (ArgM) 1217 CmdArgs.push_back("-w"); 1218 else 1219 ArgM = ArgMD; 1220 1221 if (ArgM) { 1222 // Determine the output location. 1223 const char *DepFile; 1224 if (Arg *MF = Args.getLastArg(options::OPT_MF)) { 1225 DepFile = MF->getValue(); 1226 C.addFailureResultFile(DepFile, &JA); 1227 } else if (Output.getType() == types::TY_Dependencies) { 1228 DepFile = Output.getFilename(); 1229 } else if (!ArgMD) { 1230 DepFile = "-"; 1231 } else { 1232 DepFile = getDependencyFileName(Args, Inputs); 1233 C.addFailureResultFile(DepFile, &JA); 1234 } 1235 CmdArgs.push_back("-dependency-file"); 1236 CmdArgs.push_back(DepFile); 1237 1238 bool HasTarget = false; 1239 for (const Arg *A : Args.filtered(options::OPT_MT, options::OPT_MQ)) { 1240 HasTarget = true; 1241 A->claim(); 1242 if (A->getOption().matches(options::OPT_MT)) { 1243 A->render(Args, CmdArgs); 1244 } else { 1245 CmdArgs.push_back("-MT"); 1246 SmallString<128> Quoted; 1247 quoteMakeTarget(A->getValue(), Quoted); 1248 CmdArgs.push_back(Args.MakeArgString(Quoted)); 1249 } 1250 } 1251 1252 // Add a default target if one wasn't specified. 1253 if (!HasTarget) { 1254 const char *DepTarget; 1255 1256 // If user provided -o, that is the dependency target, except 1257 // when we are only generating a dependency file. 1258 Arg *OutputOpt = Args.getLastArg(options::OPT_o); 1259 if (OutputOpt && Output.getType() != types::TY_Dependencies) { 1260 DepTarget = OutputOpt->getValue(); 1261 } else { 1262 // Otherwise derive from the base input. 1263 // 1264 // FIXME: This should use the computed output file location. 1265 SmallString<128> P(Inputs[0].getBaseInput()); 1266 llvm::sys::path::replace_extension(P, "o"); 1267 DepTarget = Args.MakeArgString(llvm::sys::path::filename(P)); 1268 } 1269 1270 CmdArgs.push_back("-MT"); 1271 SmallString<128> Quoted; 1272 quoteMakeTarget(DepTarget, Quoted); 1273 CmdArgs.push_back(Args.MakeArgString(Quoted)); 1274 } 1275 1276 if (ArgM->getOption().matches(options::OPT_M) || 1277 ArgM->getOption().matches(options::OPT_MD)) 1278 CmdArgs.push_back("-sys-header-deps"); 1279 if ((isa<PrecompileJobAction>(JA) && 1280 !Args.hasArg(options::OPT_fno_module_file_deps)) || 1281 Args.hasArg(options::OPT_fmodule_file_deps)) 1282 CmdArgs.push_back("-module-file-deps"); 1283 } 1284 1285 if (Args.hasArg(options::OPT_MG)) { 1286 if (!ArgM || ArgM->getOption().matches(options::OPT_MD) || 1287 ArgM->getOption().matches(options::OPT_MMD)) 1288 D.Diag(diag::err_drv_mg_requires_m_or_mm); 1289 CmdArgs.push_back("-MG"); 1290 } 1291 1292 Args.AddLastArg(CmdArgs, options::OPT_MP); 1293 Args.AddLastArg(CmdArgs, options::OPT_MV); 1294 1295 // Add offload include arguments specific for CUDA/HIP. This must happen 1296 // before we -I or -include anything else, because we must pick up the 1297 // CUDA/HIP headers from the particular CUDA/ROCm installation, rather than 1298 // from e.g. /usr/local/include. 1299 if (JA.isOffloading(Action::OFK_Cuda)) 1300 getToolChain().AddCudaIncludeArgs(Args, CmdArgs); 1301 if (JA.isOffloading(Action::OFK_HIP)) 1302 getToolChain().AddHIPIncludeArgs(Args, CmdArgs); 1303 1304 // If we are offloading to a target via OpenMP we need to include the 1305 // openmp_wrappers folder which contains alternative system headers. 1306 if (JA.isDeviceOffloading(Action::OFK_OpenMP) && 1307 !Args.hasArg(options::OPT_nostdinc) && 1308 (getToolChain().getTriple().isNVPTX() || 1309 getToolChain().getTriple().isAMDGCN())) { 1310 if (!Args.hasArg(options::OPT_nobuiltininc)) { 1311 // Add openmp_wrappers/* to our system include path. This lets us wrap 1312 // standard library headers. 1313 SmallString<128> P(D.ResourceDir); 1314 llvm::sys::path::append(P, "include"); 1315 llvm::sys::path::append(P, "openmp_wrappers"); 1316 CmdArgs.push_back("-internal-isystem"); 1317 CmdArgs.push_back(Args.MakeArgString(P)); 1318 } 1319 1320 CmdArgs.push_back("-include"); 1321 CmdArgs.push_back("__clang_openmp_device_functions.h"); 1322 } 1323 1324 // Add -i* options, and automatically translate to 1325 // -include-pch/-include-pth for transparent PCH support. It's 1326 // wonky, but we include looking for .gch so we can support seamless 1327 // replacement into a build system already set up to be generating 1328 // .gch files. 1329 1330 if (getToolChain().getDriver().IsCLMode()) { 1331 const Arg *YcArg = Args.getLastArg(options::OPT__SLASH_Yc); 1332 const Arg *YuArg = Args.getLastArg(options::OPT__SLASH_Yu); 1333 if (YcArg && JA.getKind() >= Action::PrecompileJobClass && 1334 JA.getKind() <= Action::AssembleJobClass) { 1335 CmdArgs.push_back(Args.MakeArgString("-building-pch-with-obj")); 1336 // -fpch-instantiate-templates is the default when creating 1337 // precomp using /Yc 1338 if (Args.hasFlag(options::OPT_fpch_instantiate_templates, 1339 options::OPT_fno_pch_instantiate_templates, true)) 1340 CmdArgs.push_back(Args.MakeArgString("-fpch-instantiate-templates")); 1341 } 1342 if (YcArg || YuArg) { 1343 StringRef ThroughHeader = YcArg ? YcArg->getValue() : YuArg->getValue(); 1344 if (!isa<PrecompileJobAction>(JA)) { 1345 CmdArgs.push_back("-include-pch"); 1346 CmdArgs.push_back(Args.MakeArgString(D.GetClPchPath( 1347 C, !ThroughHeader.empty() 1348 ? ThroughHeader 1349 : llvm::sys::path::filename(Inputs[0].getBaseInput())))); 1350 } 1351 1352 if (ThroughHeader.empty()) { 1353 CmdArgs.push_back(Args.MakeArgString( 1354 Twine("-pch-through-hdrstop-") + (YcArg ? "create" : "use"))); 1355 } else { 1356 CmdArgs.push_back( 1357 Args.MakeArgString(Twine("-pch-through-header=") + ThroughHeader)); 1358 } 1359 } 1360 } 1361 1362 bool RenderedImplicitInclude = false; 1363 for (const Arg *A : Args.filtered(options::OPT_clang_i_Group)) { 1364 if (A->getOption().matches(options::OPT_include) && 1365 D.getProbePrecompiled()) { 1366 // Handling of gcc-style gch precompiled headers. 1367 bool IsFirstImplicitInclude = !RenderedImplicitInclude; 1368 RenderedImplicitInclude = true; 1369 1370 bool FoundPCH = false; 1371 SmallString<128> P(A->getValue()); 1372 // We want the files to have a name like foo.h.pch. Add a dummy extension 1373 // so that replace_extension does the right thing. 1374 P += ".dummy"; 1375 llvm::sys::path::replace_extension(P, "pch"); 1376 if (D.getVFS().exists(P)) 1377 FoundPCH = true; 1378 1379 if (!FoundPCH) { 1380 llvm::sys::path::replace_extension(P, "gch"); 1381 if (D.getVFS().exists(P)) { 1382 FoundPCH = true; 1383 } 1384 } 1385 1386 if (FoundPCH) { 1387 if (IsFirstImplicitInclude) { 1388 A->claim(); 1389 CmdArgs.push_back("-include-pch"); 1390 CmdArgs.push_back(Args.MakeArgString(P)); 1391 continue; 1392 } else { 1393 // Ignore the PCH if not first on command line and emit warning. 1394 D.Diag(diag::warn_drv_pch_not_first_include) << P 1395 << A->getAsString(Args); 1396 } 1397 } 1398 } else if (A->getOption().matches(options::OPT_isystem_after)) { 1399 // Handling of paths which must come late. These entries are handled by 1400 // the toolchain itself after the resource dir is inserted in the right 1401 // search order. 1402 // Do not claim the argument so that the use of the argument does not 1403 // silently go unnoticed on toolchains which do not honour the option. 1404 continue; 1405 } else if (A->getOption().matches(options::OPT_stdlibxx_isystem)) { 1406 // Translated to -internal-isystem by the driver, no need to pass to cc1. 1407 continue; 1408 } 1409 1410 // Not translated, render as usual. 1411 A->claim(); 1412 A->render(Args, CmdArgs); 1413 } 1414 1415 Args.AddAllArgs(CmdArgs, 1416 {options::OPT_D, options::OPT_U, options::OPT_I_Group, 1417 options::OPT_F, options::OPT_index_header_map}); 1418 1419 // Add -Wp, and -Xpreprocessor if using the preprocessor. 1420 1421 // FIXME: There is a very unfortunate problem here, some troubled 1422 // souls abuse -Wp, to pass preprocessor options in gcc syntax. To 1423 // really support that we would have to parse and then translate 1424 // those options. :( 1425 Args.AddAllArgValues(CmdArgs, options::OPT_Wp_COMMA, 1426 options::OPT_Xpreprocessor); 1427 1428 // -I- is a deprecated GCC feature, reject it. 1429 if (Arg *A = Args.getLastArg(options::OPT_I_)) 1430 D.Diag(diag::err_drv_I_dash_not_supported) << A->getAsString(Args); 1431 1432 // If we have a --sysroot, and don't have an explicit -isysroot flag, add an 1433 // -isysroot to the CC1 invocation. 1434 StringRef sysroot = C.getSysRoot(); 1435 if (sysroot != "") { 1436 if (!Args.hasArg(options::OPT_isysroot)) { 1437 CmdArgs.push_back("-isysroot"); 1438 CmdArgs.push_back(C.getArgs().MakeArgString(sysroot)); 1439 } 1440 } 1441 1442 // Parse additional include paths from environment variables. 1443 // FIXME: We should probably sink the logic for handling these from the 1444 // frontend into the driver. It will allow deleting 4 otherwise unused flags. 1445 // CPATH - included following the user specified includes (but prior to 1446 // builtin and standard includes). 1447 addDirectoryList(Args, CmdArgs, "-I", "CPATH"); 1448 // C_INCLUDE_PATH - system includes enabled when compiling C. 1449 addDirectoryList(Args, CmdArgs, "-c-isystem", "C_INCLUDE_PATH"); 1450 // CPLUS_INCLUDE_PATH - system includes enabled when compiling C++. 1451 addDirectoryList(Args, CmdArgs, "-cxx-isystem", "CPLUS_INCLUDE_PATH"); 1452 // OBJC_INCLUDE_PATH - system includes enabled when compiling ObjC. 1453 addDirectoryList(Args, CmdArgs, "-objc-isystem", "OBJC_INCLUDE_PATH"); 1454 // OBJCPLUS_INCLUDE_PATH - system includes enabled when compiling ObjC++. 1455 addDirectoryList(Args, CmdArgs, "-objcxx-isystem", "OBJCPLUS_INCLUDE_PATH"); 1456 1457 // While adding the include arguments, we also attempt to retrieve the 1458 // arguments of related offloading toolchains or arguments that are specific 1459 // of an offloading programming model. 1460 1461 // Add C++ include arguments, if needed. 1462 if (types::isCXX(Inputs[0].getType())) { 1463 bool HasStdlibxxIsystem = Args.hasArg(options::OPT_stdlibxx_isystem); 1464 forAllAssociatedToolChains( 1465 C, JA, getToolChain(), 1466 [&Args, &CmdArgs, HasStdlibxxIsystem](const ToolChain &TC) { 1467 HasStdlibxxIsystem ? TC.AddClangCXXStdlibIsystemArgs(Args, CmdArgs) 1468 : TC.AddClangCXXStdlibIncludeArgs(Args, CmdArgs); 1469 }); 1470 } 1471 1472 // Add system include arguments for all targets but IAMCU. 1473 if (!IsIAMCU) 1474 forAllAssociatedToolChains(C, JA, getToolChain(), 1475 [&Args, &CmdArgs](const ToolChain &TC) { 1476 TC.AddClangSystemIncludeArgs(Args, CmdArgs); 1477 }); 1478 else { 1479 // For IAMCU add special include arguments. 1480 getToolChain().AddIAMCUIncludeArgs(Args, CmdArgs); 1481 } 1482 1483 addMacroPrefixMapArg(D, Args, CmdArgs); 1484 addCoveragePrefixMapArg(D, Args, CmdArgs); 1485 1486 Args.AddLastArg(CmdArgs, options::OPT_ffile_reproducible, 1487 options::OPT_fno_file_reproducible); 1488 } 1489 1490 // FIXME: Move to target hook. 1491 static bool isSignedCharDefault(const llvm::Triple &Triple) { 1492 switch (Triple.getArch()) { 1493 default: 1494 return true; 1495 1496 case llvm::Triple::aarch64: 1497 case llvm::Triple::aarch64_32: 1498 case llvm::Triple::aarch64_be: 1499 case llvm::Triple::arm: 1500 case llvm::Triple::armeb: 1501 case llvm::Triple::thumb: 1502 case llvm::Triple::thumbeb: 1503 if (Triple.isOSDarwin() || Triple.isOSWindows()) 1504 return true; 1505 return false; 1506 1507 case llvm::Triple::ppc: 1508 case llvm::Triple::ppc64: 1509 if (Triple.isOSDarwin()) 1510 return true; 1511 return false; 1512 1513 case llvm::Triple::hexagon: 1514 case llvm::Triple::ppcle: 1515 case llvm::Triple::ppc64le: 1516 case llvm::Triple::riscv32: 1517 case llvm::Triple::riscv64: 1518 case llvm::Triple::systemz: 1519 case llvm::Triple::xcore: 1520 return false; 1521 } 1522 } 1523 1524 static bool hasMultipleInvocations(const llvm::Triple &Triple, 1525 const ArgList &Args) { 1526 // Supported only on Darwin where we invoke the compiler multiple times 1527 // followed by an invocation to lipo. 1528 if (!Triple.isOSDarwin()) 1529 return false; 1530 // If more than one "-arch <arch>" is specified, we're targeting multiple 1531 // architectures resulting in a fat binary. 1532 return Args.getAllArgValues(options::OPT_arch).size() > 1; 1533 } 1534 1535 static bool checkRemarksOptions(const Driver &D, const ArgList &Args, 1536 const llvm::Triple &Triple) { 1537 // When enabling remarks, we need to error if: 1538 // * The remark file is specified but we're targeting multiple architectures, 1539 // which means more than one remark file is being generated. 1540 bool hasMultipleInvocations = ::hasMultipleInvocations(Triple, Args); 1541 bool hasExplicitOutputFile = 1542 Args.getLastArg(options::OPT_foptimization_record_file_EQ); 1543 if (hasMultipleInvocations && hasExplicitOutputFile) { 1544 D.Diag(diag::err_drv_invalid_output_with_multiple_archs) 1545 << "-foptimization-record-file"; 1546 return false; 1547 } 1548 return true; 1549 } 1550 1551 static void renderRemarksOptions(const ArgList &Args, ArgStringList &CmdArgs, 1552 const llvm::Triple &Triple, 1553 const InputInfo &Input, 1554 const InputInfo &Output, const JobAction &JA) { 1555 StringRef Format = "yaml"; 1556 if (const Arg *A = Args.getLastArg(options::OPT_fsave_optimization_record_EQ)) 1557 Format = A->getValue(); 1558 1559 CmdArgs.push_back("-opt-record-file"); 1560 1561 const Arg *A = Args.getLastArg(options::OPT_foptimization_record_file_EQ); 1562 if (A) { 1563 CmdArgs.push_back(A->getValue()); 1564 } else { 1565 bool hasMultipleArchs = 1566 Triple.isOSDarwin() && // Only supported on Darwin platforms. 1567 Args.getAllArgValues(options::OPT_arch).size() > 1; 1568 1569 SmallString<128> F; 1570 1571 if (Args.hasArg(options::OPT_c) || Args.hasArg(options::OPT_S)) { 1572 if (Arg *FinalOutput = Args.getLastArg(options::OPT_o)) 1573 F = FinalOutput->getValue(); 1574 } else { 1575 if (Format != "yaml" && // For YAML, keep the original behavior. 1576 Triple.isOSDarwin() && // Enable this only on darwin, since it's the only platform supporting .dSYM bundles. 1577 Output.isFilename()) 1578 F = Output.getFilename(); 1579 } 1580 1581 if (F.empty()) { 1582 // Use the input filename. 1583 F = llvm::sys::path::stem(Input.getBaseInput()); 1584 1585 // If we're compiling for an offload architecture (i.e. a CUDA device), 1586 // we need to make the file name for the device compilation different 1587 // from the host compilation. 1588 if (!JA.isDeviceOffloading(Action::OFK_None) && 1589 !JA.isDeviceOffloading(Action::OFK_Host)) { 1590 llvm::sys::path::replace_extension(F, ""); 1591 F += Action::GetOffloadingFileNamePrefix(JA.getOffloadingDeviceKind(), 1592 Triple.normalize()); 1593 F += "-"; 1594 F += JA.getOffloadingArch(); 1595 } 1596 } 1597 1598 // If we're having more than one "-arch", we should name the files 1599 // differently so that every cc1 invocation writes to a different file. 1600 // We're doing that by appending "-<arch>" with "<arch>" being the arch 1601 // name from the triple. 1602 if (hasMultipleArchs) { 1603 // First, remember the extension. 1604 SmallString<64> OldExtension = llvm::sys::path::extension(F); 1605 // then, remove it. 1606 llvm::sys::path::replace_extension(F, ""); 1607 // attach -<arch> to it. 1608 F += "-"; 1609 F += Triple.getArchName(); 1610 // put back the extension. 1611 llvm::sys::path::replace_extension(F, OldExtension); 1612 } 1613 1614 SmallString<32> Extension; 1615 Extension += "opt."; 1616 Extension += Format; 1617 1618 llvm::sys::path::replace_extension(F, Extension); 1619 CmdArgs.push_back(Args.MakeArgString(F)); 1620 } 1621 1622 if (const Arg *A = 1623 Args.getLastArg(options::OPT_foptimization_record_passes_EQ)) { 1624 CmdArgs.push_back("-opt-record-passes"); 1625 CmdArgs.push_back(A->getValue()); 1626 } 1627 1628 if (!Format.empty()) { 1629 CmdArgs.push_back("-opt-record-format"); 1630 CmdArgs.push_back(Format.data()); 1631 } 1632 } 1633 1634 void AddAAPCSVolatileBitfieldArgs(const ArgList &Args, ArgStringList &CmdArgs) { 1635 if (!Args.hasFlag(options::OPT_faapcs_bitfield_width, 1636 options::OPT_fno_aapcs_bitfield_width, true)) 1637 CmdArgs.push_back("-fno-aapcs-bitfield-width"); 1638 1639 if (Args.getLastArg(options::OPT_ForceAAPCSBitfieldLoad)) 1640 CmdArgs.push_back("-faapcs-bitfield-load"); 1641 } 1642 1643 namespace { 1644 void RenderARMABI(const Driver &D, const llvm::Triple &Triple, 1645 const ArgList &Args, ArgStringList &CmdArgs) { 1646 // Select the ABI to use. 1647 // FIXME: Support -meabi. 1648 // FIXME: Parts of this are duplicated in the backend, unify this somehow. 1649 const char *ABIName = nullptr; 1650 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) { 1651 ABIName = A->getValue(); 1652 } else { 1653 std::string CPU = getCPUName(D, Args, Triple, /*FromAs*/ false); 1654 ABIName = llvm::ARM::computeDefaultTargetABI(Triple, CPU).data(); 1655 } 1656 1657 CmdArgs.push_back("-target-abi"); 1658 CmdArgs.push_back(ABIName); 1659 } 1660 1661 void AddUnalignedAccessWarning(ArgStringList &CmdArgs) { 1662 auto StrictAlignIter = 1663 std::find_if(CmdArgs.rbegin(), CmdArgs.rend(), [](StringRef Arg) { 1664 return Arg == "+strict-align" || Arg == "-strict-align"; 1665 }); 1666 if (StrictAlignIter != CmdArgs.rend() && 1667 StringRef(*StrictAlignIter) == "+strict-align") 1668 CmdArgs.push_back("-Wunaligned-access"); 1669 } 1670 } 1671 1672 static void CollectARMPACBTIOptions(const ToolChain &TC, const ArgList &Args, 1673 ArgStringList &CmdArgs, bool isAArch64) { 1674 const Arg *A = isAArch64 1675 ? Args.getLastArg(options::OPT_msign_return_address_EQ, 1676 options::OPT_mbranch_protection_EQ) 1677 : Args.getLastArg(options::OPT_mbranch_protection_EQ); 1678 if (!A) 1679 return; 1680 1681 const Driver &D = TC.getDriver(); 1682 const llvm::Triple &Triple = TC.getEffectiveTriple(); 1683 if (!(isAArch64 || (Triple.isArmT32() && Triple.isArmMClass()))) 1684 D.Diag(diag::warn_incompatible_branch_protection_option) 1685 << Triple.getArchName(); 1686 1687 StringRef Scope, Key; 1688 bool IndirectBranches; 1689 1690 if (A->getOption().matches(options::OPT_msign_return_address_EQ)) { 1691 Scope = A->getValue(); 1692 if (Scope != "none" && Scope != "non-leaf" && Scope != "all") 1693 D.Diag(diag::err_drv_unsupported_option_argument) 1694 << A->getOption().getName() << Scope; 1695 Key = "a_key"; 1696 IndirectBranches = false; 1697 } else { 1698 StringRef DiagMsg; 1699 llvm::ARM::ParsedBranchProtection PBP; 1700 if (!llvm::ARM::parseBranchProtection(A->getValue(), PBP, DiagMsg)) 1701 D.Diag(diag::err_drv_unsupported_option_argument) 1702 << A->getOption().getName() << DiagMsg; 1703 if (!isAArch64 && PBP.Key == "b_key") 1704 D.Diag(diag::warn_unsupported_branch_protection) 1705 << "b-key" << A->getAsString(Args); 1706 Scope = PBP.Scope; 1707 Key = PBP.Key; 1708 IndirectBranches = PBP.BranchTargetEnforcement; 1709 } 1710 1711 CmdArgs.push_back( 1712 Args.MakeArgString(Twine("-msign-return-address=") + Scope)); 1713 if (!Scope.equals("none")) 1714 CmdArgs.push_back( 1715 Args.MakeArgString(Twine("-msign-return-address-key=") + Key)); 1716 if (IndirectBranches) 1717 CmdArgs.push_back("-mbranch-target-enforce"); 1718 } 1719 1720 void Clang::AddARMTargetArgs(const llvm::Triple &Triple, const ArgList &Args, 1721 ArgStringList &CmdArgs, bool KernelOrKext) const { 1722 RenderARMABI(getToolChain().getDriver(), Triple, Args, CmdArgs); 1723 1724 // Determine floating point ABI from the options & target defaults. 1725 arm::FloatABI ABI = arm::getARMFloatABI(getToolChain(), Args); 1726 if (ABI == arm::FloatABI::Soft) { 1727 // Floating point operations and argument passing are soft. 1728 // FIXME: This changes CPP defines, we need -target-soft-float. 1729 CmdArgs.push_back("-msoft-float"); 1730 CmdArgs.push_back("-mfloat-abi"); 1731 CmdArgs.push_back("soft"); 1732 } else if (ABI == arm::FloatABI::SoftFP) { 1733 // Floating point operations are hard, but argument passing is soft. 1734 CmdArgs.push_back("-mfloat-abi"); 1735 CmdArgs.push_back("soft"); 1736 } else { 1737 // Floating point operations and argument passing are hard. 1738 assert(ABI == arm::FloatABI::Hard && "Invalid float abi!"); 1739 CmdArgs.push_back("-mfloat-abi"); 1740 CmdArgs.push_back("hard"); 1741 } 1742 1743 // Forward the -mglobal-merge option for explicit control over the pass. 1744 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge, 1745 options::OPT_mno_global_merge)) { 1746 CmdArgs.push_back("-mllvm"); 1747 if (A->getOption().matches(options::OPT_mno_global_merge)) 1748 CmdArgs.push_back("-arm-global-merge=false"); 1749 else 1750 CmdArgs.push_back("-arm-global-merge=true"); 1751 } 1752 1753 if (!Args.hasFlag(options::OPT_mimplicit_float, 1754 options::OPT_mno_implicit_float, true)) 1755 CmdArgs.push_back("-no-implicit-float"); 1756 1757 if (Args.getLastArg(options::OPT_mcmse)) 1758 CmdArgs.push_back("-mcmse"); 1759 1760 AddAAPCSVolatileBitfieldArgs(Args, CmdArgs); 1761 1762 // Enable/disable return address signing and indirect branch targets. 1763 CollectARMPACBTIOptions(getToolChain(), Args, CmdArgs, false /*isAArch64*/); 1764 1765 AddUnalignedAccessWarning(CmdArgs); 1766 } 1767 1768 void Clang::RenderTargetOptions(const llvm::Triple &EffectiveTriple, 1769 const ArgList &Args, bool KernelOrKext, 1770 ArgStringList &CmdArgs) const { 1771 const ToolChain &TC = getToolChain(); 1772 1773 // Add the target features 1774 getTargetFeatures(TC.getDriver(), EffectiveTriple, Args, CmdArgs, false); 1775 1776 // Add target specific flags. 1777 switch (TC.getArch()) { 1778 default: 1779 break; 1780 1781 case llvm::Triple::arm: 1782 case llvm::Triple::armeb: 1783 case llvm::Triple::thumb: 1784 case llvm::Triple::thumbeb: 1785 // Use the effective triple, which takes into account the deployment target. 1786 AddARMTargetArgs(EffectiveTriple, Args, CmdArgs, KernelOrKext); 1787 CmdArgs.push_back("-fallow-half-arguments-and-returns"); 1788 break; 1789 1790 case llvm::Triple::aarch64: 1791 case llvm::Triple::aarch64_32: 1792 case llvm::Triple::aarch64_be: 1793 AddAArch64TargetArgs(Args, CmdArgs); 1794 CmdArgs.push_back("-fallow-half-arguments-and-returns"); 1795 break; 1796 1797 case llvm::Triple::mips: 1798 case llvm::Triple::mipsel: 1799 case llvm::Triple::mips64: 1800 case llvm::Triple::mips64el: 1801 AddMIPSTargetArgs(Args, CmdArgs); 1802 break; 1803 1804 case llvm::Triple::ppc: 1805 case llvm::Triple::ppcle: 1806 case llvm::Triple::ppc64: 1807 case llvm::Triple::ppc64le: 1808 AddPPCTargetArgs(Args, CmdArgs); 1809 break; 1810 1811 case llvm::Triple::riscv32: 1812 case llvm::Triple::riscv64: 1813 AddRISCVTargetArgs(Args, CmdArgs); 1814 break; 1815 1816 case llvm::Triple::sparc: 1817 case llvm::Triple::sparcel: 1818 case llvm::Triple::sparcv9: 1819 AddSparcTargetArgs(Args, CmdArgs); 1820 break; 1821 1822 case llvm::Triple::systemz: 1823 AddSystemZTargetArgs(Args, CmdArgs); 1824 break; 1825 1826 case llvm::Triple::x86: 1827 case llvm::Triple::x86_64: 1828 AddX86TargetArgs(Args, CmdArgs); 1829 break; 1830 1831 case llvm::Triple::lanai: 1832 AddLanaiTargetArgs(Args, CmdArgs); 1833 break; 1834 1835 case llvm::Triple::hexagon: 1836 AddHexagonTargetArgs(Args, CmdArgs); 1837 break; 1838 1839 case llvm::Triple::wasm32: 1840 case llvm::Triple::wasm64: 1841 AddWebAssemblyTargetArgs(Args, CmdArgs); 1842 break; 1843 1844 case llvm::Triple::ve: 1845 AddVETargetArgs(Args, CmdArgs); 1846 break; 1847 } 1848 } 1849 1850 namespace { 1851 void RenderAArch64ABI(const llvm::Triple &Triple, const ArgList &Args, 1852 ArgStringList &CmdArgs) { 1853 const char *ABIName = nullptr; 1854 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) 1855 ABIName = A->getValue(); 1856 else if (Triple.isOSDarwin()) 1857 ABIName = "darwinpcs"; 1858 else 1859 ABIName = "aapcs"; 1860 1861 CmdArgs.push_back("-target-abi"); 1862 CmdArgs.push_back(ABIName); 1863 } 1864 } 1865 1866 void Clang::AddAArch64TargetArgs(const ArgList &Args, 1867 ArgStringList &CmdArgs) const { 1868 const llvm::Triple &Triple = getToolChain().getEffectiveTriple(); 1869 1870 if (!Args.hasFlag(options::OPT_mred_zone, options::OPT_mno_red_zone, true) || 1871 Args.hasArg(options::OPT_mkernel) || 1872 Args.hasArg(options::OPT_fapple_kext)) 1873 CmdArgs.push_back("-disable-red-zone"); 1874 1875 if (!Args.hasFlag(options::OPT_mimplicit_float, 1876 options::OPT_mno_implicit_float, true)) 1877 CmdArgs.push_back("-no-implicit-float"); 1878 1879 RenderAArch64ABI(Triple, Args, CmdArgs); 1880 1881 // Forward the -mglobal-merge option for explicit control over the pass. 1882 if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge, 1883 options::OPT_mno_global_merge)) { 1884 CmdArgs.push_back("-mllvm"); 1885 if (A->getOption().matches(options::OPT_mno_global_merge)) 1886 CmdArgs.push_back("-aarch64-enable-global-merge=false"); 1887 else 1888 CmdArgs.push_back("-aarch64-enable-global-merge=true"); 1889 } 1890 1891 // Enable/disable return address signing and indirect branch targets. 1892 CollectARMPACBTIOptions(getToolChain(), Args, CmdArgs, true /*isAArch64*/); 1893 1894 // Handle -msve_vector_bits=<bits> 1895 if (Arg *A = Args.getLastArg(options::OPT_msve_vector_bits_EQ)) { 1896 StringRef Val = A->getValue(); 1897 const Driver &D = getToolChain().getDriver(); 1898 if (Val.equals("128") || Val.equals("256") || Val.equals("512") || 1899 Val.equals("1024") || Val.equals("2048") || Val.equals("128+") || 1900 Val.equals("256+") || Val.equals("512+") || Val.equals("1024+") || 1901 Val.equals("2048+")) { 1902 unsigned Bits = 0; 1903 if (Val.endswith("+")) 1904 Val = Val.substr(0, Val.size() - 1); 1905 else { 1906 bool Invalid = Val.getAsInteger(10, Bits); (void)Invalid; 1907 assert(!Invalid && "Failed to parse value"); 1908 CmdArgs.push_back( 1909 Args.MakeArgString("-mvscale-max=" + llvm::Twine(Bits / 128))); 1910 } 1911 1912 bool Invalid = Val.getAsInteger(10, Bits); (void)Invalid; 1913 assert(!Invalid && "Failed to parse value"); 1914 CmdArgs.push_back( 1915 Args.MakeArgString("-mvscale-min=" + llvm::Twine(Bits / 128))); 1916 // Silently drop requests for vector-length agnostic code as it's implied. 1917 } else if (!Val.equals("scalable")) 1918 // Handle the unsupported values passed to msve-vector-bits. 1919 D.Diag(diag::err_drv_unsupported_option_argument) 1920 << A->getOption().getName() << Val; 1921 } 1922 1923 AddAAPCSVolatileBitfieldArgs(Args, CmdArgs); 1924 1925 if (const Arg *A = Args.getLastArg(clang::driver::options::OPT_mtune_EQ)) { 1926 CmdArgs.push_back("-tune-cpu"); 1927 if (strcmp(A->getValue(), "native") == 0) 1928 CmdArgs.push_back(Args.MakeArgString(llvm::sys::getHostCPUName())); 1929 else 1930 CmdArgs.push_back(A->getValue()); 1931 } 1932 1933 AddUnalignedAccessWarning(CmdArgs); 1934 } 1935 1936 void Clang::AddMIPSTargetArgs(const ArgList &Args, 1937 ArgStringList &CmdArgs) const { 1938 const Driver &D = getToolChain().getDriver(); 1939 StringRef CPUName; 1940 StringRef ABIName; 1941 const llvm::Triple &Triple = getToolChain().getTriple(); 1942 mips::getMipsCPUAndABI(Args, Triple, CPUName, ABIName); 1943 1944 CmdArgs.push_back("-target-abi"); 1945 CmdArgs.push_back(ABIName.data()); 1946 1947 mips::FloatABI ABI = mips::getMipsFloatABI(D, Args, Triple); 1948 if (ABI == mips::FloatABI::Soft) { 1949 // Floating point operations and argument passing are soft. 1950 CmdArgs.push_back("-msoft-float"); 1951 CmdArgs.push_back("-mfloat-abi"); 1952 CmdArgs.push_back("soft"); 1953 } else { 1954 // Floating point operations and argument passing are hard. 1955 assert(ABI == mips::FloatABI::Hard && "Invalid float abi!"); 1956 CmdArgs.push_back("-mfloat-abi"); 1957 CmdArgs.push_back("hard"); 1958 } 1959 1960 if (Arg *A = Args.getLastArg(options::OPT_mldc1_sdc1, 1961 options::OPT_mno_ldc1_sdc1)) { 1962 if (A->getOption().matches(options::OPT_mno_ldc1_sdc1)) { 1963 CmdArgs.push_back("-mllvm"); 1964 CmdArgs.push_back("-mno-ldc1-sdc1"); 1965 } 1966 } 1967 1968 if (Arg *A = Args.getLastArg(options::OPT_mcheck_zero_division, 1969 options::OPT_mno_check_zero_division)) { 1970 if (A->getOption().matches(options::OPT_mno_check_zero_division)) { 1971 CmdArgs.push_back("-mllvm"); 1972 CmdArgs.push_back("-mno-check-zero-division"); 1973 } 1974 } 1975 1976 if (Args.getLastArg(options::OPT_mfix4300)) { 1977 CmdArgs.push_back("-mllvm"); 1978 CmdArgs.push_back("-mfix4300"); 1979 } 1980 1981 if (Arg *A = Args.getLastArg(options::OPT_G)) { 1982 StringRef v = A->getValue(); 1983 CmdArgs.push_back("-mllvm"); 1984 CmdArgs.push_back(Args.MakeArgString("-mips-ssection-threshold=" + v)); 1985 A->claim(); 1986 } 1987 1988 Arg *GPOpt = Args.getLastArg(options::OPT_mgpopt, options::OPT_mno_gpopt); 1989 Arg *ABICalls = 1990 Args.getLastArg(options::OPT_mabicalls, options::OPT_mno_abicalls); 1991 1992 // -mabicalls is the default for many MIPS environments, even with -fno-pic. 1993 // -mgpopt is the default for static, -fno-pic environments but these two 1994 // options conflict. We want to be certain that -mno-abicalls -mgpopt is 1995 // the only case where -mllvm -mgpopt is passed. 1996 // NOTE: We need a warning here or in the backend to warn when -mgpopt is 1997 // passed explicitly when compiling something with -mabicalls 1998 // (implictly) in affect. Currently the warning is in the backend. 1999 // 2000 // When the ABI in use is N64, we also need to determine the PIC mode that 2001 // is in use, as -fno-pic for N64 implies -mno-abicalls. 2002 bool NoABICalls = 2003 ABICalls && ABICalls->getOption().matches(options::OPT_mno_abicalls); 2004 2005 llvm::Reloc::Model RelocationModel; 2006 unsigned PICLevel; 2007 bool IsPIE; 2008 std::tie(RelocationModel, PICLevel, IsPIE) = 2009 ParsePICArgs(getToolChain(), Args); 2010 2011 NoABICalls = NoABICalls || 2012 (RelocationModel == llvm::Reloc::Static && ABIName == "n64"); 2013 2014 bool WantGPOpt = GPOpt && GPOpt->getOption().matches(options::OPT_mgpopt); 2015 // We quietly ignore -mno-gpopt as the backend defaults to -mno-gpopt. 2016 if (NoABICalls && (!GPOpt || WantGPOpt)) { 2017 CmdArgs.push_back("-mllvm"); 2018 CmdArgs.push_back("-mgpopt"); 2019 2020 Arg *LocalSData = Args.getLastArg(options::OPT_mlocal_sdata, 2021 options::OPT_mno_local_sdata); 2022 Arg *ExternSData = Args.getLastArg(options::OPT_mextern_sdata, 2023 options::OPT_mno_extern_sdata); 2024 Arg *EmbeddedData = Args.getLastArg(options::OPT_membedded_data, 2025 options::OPT_mno_embedded_data); 2026 if (LocalSData) { 2027 CmdArgs.push_back("-mllvm"); 2028 if (LocalSData->getOption().matches(options::OPT_mlocal_sdata)) { 2029 CmdArgs.push_back("-mlocal-sdata=1"); 2030 } else { 2031 CmdArgs.push_back("-mlocal-sdata=0"); 2032 } 2033 LocalSData->claim(); 2034 } 2035 2036 if (ExternSData) { 2037 CmdArgs.push_back("-mllvm"); 2038 if (ExternSData->getOption().matches(options::OPT_mextern_sdata)) { 2039 CmdArgs.push_back("-mextern-sdata=1"); 2040 } else { 2041 CmdArgs.push_back("-mextern-sdata=0"); 2042 } 2043 ExternSData->claim(); 2044 } 2045 2046 if (EmbeddedData) { 2047 CmdArgs.push_back("-mllvm"); 2048 if (EmbeddedData->getOption().matches(options::OPT_membedded_data)) { 2049 CmdArgs.push_back("-membedded-data=1"); 2050 } else { 2051 CmdArgs.push_back("-membedded-data=0"); 2052 } 2053 EmbeddedData->claim(); 2054 } 2055 2056 } else if ((!ABICalls || (!NoABICalls && ABICalls)) && WantGPOpt) 2057 D.Diag(diag::warn_drv_unsupported_gpopt) << (ABICalls ? 0 : 1); 2058 2059 if (GPOpt) 2060 GPOpt->claim(); 2061 2062 if (Arg *A = Args.getLastArg(options::OPT_mcompact_branches_EQ)) { 2063 StringRef Val = StringRef(A->getValue()); 2064 if (mips::hasCompactBranches(CPUName)) { 2065 if (Val == "never" || Val == "always" || Val == "optimal") { 2066 CmdArgs.push_back("-mllvm"); 2067 CmdArgs.push_back(Args.MakeArgString("-mips-compact-branches=" + Val)); 2068 } else 2069 D.Diag(diag::err_drv_unsupported_option_argument) 2070 << A->getOption().getName() << Val; 2071 } else 2072 D.Diag(diag::warn_target_unsupported_compact_branches) << CPUName; 2073 } 2074 2075 if (Arg *A = Args.getLastArg(options::OPT_mrelax_pic_calls, 2076 options::OPT_mno_relax_pic_calls)) { 2077 if (A->getOption().matches(options::OPT_mno_relax_pic_calls)) { 2078 CmdArgs.push_back("-mllvm"); 2079 CmdArgs.push_back("-mips-jalr-reloc=0"); 2080 } 2081 } 2082 } 2083 2084 void Clang::AddPPCTargetArgs(const ArgList &Args, 2085 ArgStringList &CmdArgs) const { 2086 // Select the ABI to use. 2087 const char *ABIName = nullptr; 2088 const llvm::Triple &T = getToolChain().getTriple(); 2089 if (T.isOSBinFormatELF()) { 2090 switch (getToolChain().getArch()) { 2091 case llvm::Triple::ppc64: { 2092 if ((T.isOSFreeBSD() && T.getOSMajorVersion() >= 13) || 2093 T.isOSOpenBSD() || T.isMusl()) 2094 ABIName = "elfv2"; 2095 else 2096 ABIName = "elfv1"; 2097 break; 2098 } 2099 case llvm::Triple::ppc64le: 2100 ABIName = "elfv2"; 2101 break; 2102 default: 2103 break; 2104 } 2105 } 2106 2107 bool IEEELongDouble = getToolChain().defaultToIEEELongDouble(); 2108 for (const Arg *A : Args.filtered(options::OPT_mabi_EQ)) { 2109 StringRef V = A->getValue(); 2110 if (V == "ieeelongdouble") 2111 IEEELongDouble = true; 2112 else if (V == "ibmlongdouble") 2113 IEEELongDouble = false; 2114 else if (V != "altivec") 2115 // The ppc64 linux abis are all "altivec" abis by default. Accept and ignore 2116 // the option if given as we don't have backend support for any targets 2117 // that don't use the altivec abi. 2118 ABIName = A->getValue(); 2119 } 2120 if (IEEELongDouble) 2121 CmdArgs.push_back("-mabi=ieeelongdouble"); 2122 2123 ppc::FloatABI FloatABI = 2124 ppc::getPPCFloatABI(getToolChain().getDriver(), Args); 2125 2126 if (FloatABI == ppc::FloatABI::Soft) { 2127 // Floating point operations and argument passing are soft. 2128 CmdArgs.push_back("-msoft-float"); 2129 CmdArgs.push_back("-mfloat-abi"); 2130 CmdArgs.push_back("soft"); 2131 } else { 2132 // Floating point operations and argument passing are hard. 2133 assert(FloatABI == ppc::FloatABI::Hard && "Invalid float abi!"); 2134 CmdArgs.push_back("-mfloat-abi"); 2135 CmdArgs.push_back("hard"); 2136 } 2137 2138 if (ABIName) { 2139 CmdArgs.push_back("-target-abi"); 2140 CmdArgs.push_back(ABIName); 2141 } 2142 } 2143 2144 static void SetRISCVSmallDataLimit(const ToolChain &TC, const ArgList &Args, 2145 ArgStringList &CmdArgs) { 2146 const Driver &D = TC.getDriver(); 2147 const llvm::Triple &Triple = TC.getTriple(); 2148 // Default small data limitation is eight. 2149 const char *SmallDataLimit = "8"; 2150 // Get small data limitation. 2151 if (Args.getLastArg(options::OPT_shared, options::OPT_fpic, 2152 options::OPT_fPIC)) { 2153 // Not support linker relaxation for PIC. 2154 SmallDataLimit = "0"; 2155 if (Args.hasArg(options::OPT_G)) { 2156 D.Diag(diag::warn_drv_unsupported_sdata); 2157 } 2158 } else if (Args.getLastArgValue(options::OPT_mcmodel_EQ) 2159 .equals_insensitive("large") && 2160 (Triple.getArch() == llvm::Triple::riscv64)) { 2161 // Not support linker relaxation for RV64 with large code model. 2162 SmallDataLimit = "0"; 2163 if (Args.hasArg(options::OPT_G)) { 2164 D.Diag(diag::warn_drv_unsupported_sdata); 2165 } 2166 } else if (Arg *A = Args.getLastArg(options::OPT_G)) { 2167 SmallDataLimit = A->getValue(); 2168 } 2169 // Forward the -msmall-data-limit= option. 2170 CmdArgs.push_back("-msmall-data-limit"); 2171 CmdArgs.push_back(SmallDataLimit); 2172 } 2173 2174 void Clang::AddRISCVTargetArgs(const ArgList &Args, 2175 ArgStringList &CmdArgs) const { 2176 const llvm::Triple &Triple = getToolChain().getTriple(); 2177 StringRef ABIName = riscv::getRISCVABI(Args, Triple); 2178 2179 CmdArgs.push_back("-target-abi"); 2180 CmdArgs.push_back(ABIName.data()); 2181 2182 SetRISCVSmallDataLimit(getToolChain(), Args, CmdArgs); 2183 2184 if (const Arg *A = Args.getLastArg(options::OPT_mtune_EQ)) { 2185 StringRef Name = 2186 llvm::RISCV::resolveTuneCPUAlias(A->getValue(), Triple.isArch64Bit()); 2187 CmdArgs.push_back("-tune-cpu"); 2188 CmdArgs.push_back(Name.data()); 2189 } 2190 } 2191 2192 void Clang::AddSparcTargetArgs(const ArgList &Args, 2193 ArgStringList &CmdArgs) const { 2194 sparc::FloatABI FloatABI = 2195 sparc::getSparcFloatABI(getToolChain().getDriver(), Args); 2196 2197 if (FloatABI == sparc::FloatABI::Soft) { 2198 // Floating point operations and argument passing are soft. 2199 CmdArgs.push_back("-msoft-float"); 2200 CmdArgs.push_back("-mfloat-abi"); 2201 CmdArgs.push_back("soft"); 2202 } else { 2203 // Floating point operations and argument passing are hard. 2204 assert(FloatABI == sparc::FloatABI::Hard && "Invalid float abi!"); 2205 CmdArgs.push_back("-mfloat-abi"); 2206 CmdArgs.push_back("hard"); 2207 } 2208 2209 if (const Arg *A = Args.getLastArg(clang::driver::options::OPT_mtune_EQ)) { 2210 StringRef Name = A->getValue(); 2211 std::string TuneCPU; 2212 if (Name == "native") 2213 TuneCPU = std::string(llvm::sys::getHostCPUName()); 2214 else 2215 TuneCPU = std::string(Name); 2216 2217 CmdArgs.push_back("-tune-cpu"); 2218 CmdArgs.push_back(Args.MakeArgString(TuneCPU)); 2219 } 2220 } 2221 2222 void Clang::AddSystemZTargetArgs(const ArgList &Args, 2223 ArgStringList &CmdArgs) const { 2224 if (const Arg *A = Args.getLastArg(options::OPT_mtune_EQ)) { 2225 CmdArgs.push_back("-tune-cpu"); 2226 if (strcmp(A->getValue(), "native") == 0) 2227 CmdArgs.push_back(Args.MakeArgString(llvm::sys::getHostCPUName())); 2228 else 2229 CmdArgs.push_back(A->getValue()); 2230 } 2231 2232 bool HasBackchain = 2233 Args.hasFlag(options::OPT_mbackchain, options::OPT_mno_backchain, false); 2234 bool HasPackedStack = Args.hasFlag(options::OPT_mpacked_stack, 2235 options::OPT_mno_packed_stack, false); 2236 systemz::FloatABI FloatABI = 2237 systemz::getSystemZFloatABI(getToolChain().getDriver(), Args); 2238 bool HasSoftFloat = (FloatABI == systemz::FloatABI::Soft); 2239 if (HasBackchain && HasPackedStack && !HasSoftFloat) { 2240 const Driver &D = getToolChain().getDriver(); 2241 D.Diag(diag::err_drv_unsupported_opt) 2242 << "-mpacked-stack -mbackchain -mhard-float"; 2243 } 2244 if (HasBackchain) 2245 CmdArgs.push_back("-mbackchain"); 2246 if (HasPackedStack) 2247 CmdArgs.push_back("-mpacked-stack"); 2248 if (HasSoftFloat) { 2249 // Floating point operations and argument passing are soft. 2250 CmdArgs.push_back("-msoft-float"); 2251 CmdArgs.push_back("-mfloat-abi"); 2252 CmdArgs.push_back("soft"); 2253 } 2254 } 2255 2256 void Clang::AddX86TargetArgs(const ArgList &Args, 2257 ArgStringList &CmdArgs) const { 2258 const Driver &D = getToolChain().getDriver(); 2259 addX86AlignBranchArgs(D, Args, CmdArgs, /*IsLTO=*/false); 2260 2261 if (!Args.hasFlag(options::OPT_mred_zone, options::OPT_mno_red_zone, true) || 2262 Args.hasArg(options::OPT_mkernel) || 2263 Args.hasArg(options::OPT_fapple_kext)) 2264 CmdArgs.push_back("-disable-red-zone"); 2265 2266 if (!Args.hasFlag(options::OPT_mtls_direct_seg_refs, 2267 options::OPT_mno_tls_direct_seg_refs, true)) 2268 CmdArgs.push_back("-mno-tls-direct-seg-refs"); 2269 2270 // Default to avoid implicit floating-point for kernel/kext code, but allow 2271 // that to be overridden with -mno-soft-float. 2272 bool NoImplicitFloat = (Args.hasArg(options::OPT_mkernel) || 2273 Args.hasArg(options::OPT_fapple_kext)); 2274 if (Arg *A = Args.getLastArg( 2275 options::OPT_msoft_float, options::OPT_mno_soft_float, 2276 options::OPT_mimplicit_float, options::OPT_mno_implicit_float)) { 2277 const Option &O = A->getOption(); 2278 NoImplicitFloat = (O.matches(options::OPT_mno_implicit_float) || 2279 O.matches(options::OPT_msoft_float)); 2280 } 2281 if (NoImplicitFloat) 2282 CmdArgs.push_back("-no-implicit-float"); 2283 2284 if (Arg *A = Args.getLastArg(options::OPT_masm_EQ)) { 2285 StringRef Value = A->getValue(); 2286 if (Value == "intel" || Value == "att") { 2287 CmdArgs.push_back("-mllvm"); 2288 CmdArgs.push_back(Args.MakeArgString("-x86-asm-syntax=" + Value)); 2289 CmdArgs.push_back(Args.MakeArgString("-inline-asm=" + Value)); 2290 } else { 2291 D.Diag(diag::err_drv_unsupported_option_argument) 2292 << A->getOption().getName() << Value; 2293 } 2294 } else if (D.IsCLMode()) { 2295 CmdArgs.push_back("-mllvm"); 2296 CmdArgs.push_back("-x86-asm-syntax=intel"); 2297 } 2298 2299 if (Arg *A = Args.getLastArg(options::OPT_mskip_rax_setup, 2300 options::OPT_mno_skip_rax_setup)) 2301 if (A->getOption().matches(options::OPT_mskip_rax_setup)) 2302 CmdArgs.push_back(Args.MakeArgString("-mskip-rax-setup")); 2303 2304 // Set flags to support MCU ABI. 2305 if (Args.hasFlag(options::OPT_miamcu, options::OPT_mno_iamcu, false)) { 2306 CmdArgs.push_back("-mfloat-abi"); 2307 CmdArgs.push_back("soft"); 2308 CmdArgs.push_back("-mstack-alignment=4"); 2309 } 2310 2311 // Handle -mtune. 2312 2313 // Default to "generic" unless -march is present or targetting the PS4/PS5. 2314 std::string TuneCPU; 2315 if (!Args.hasArg(clang::driver::options::OPT_march_EQ) && 2316 !getToolChain().getTriple().isPS()) 2317 TuneCPU = "generic"; 2318 2319 // Override based on -mtune. 2320 if (const Arg *A = Args.getLastArg(clang::driver::options::OPT_mtune_EQ)) { 2321 StringRef Name = A->getValue(); 2322 2323 if (Name == "native") { 2324 Name = llvm::sys::getHostCPUName(); 2325 if (!Name.empty()) 2326 TuneCPU = std::string(Name); 2327 } else 2328 TuneCPU = std::string(Name); 2329 } 2330 2331 if (!TuneCPU.empty()) { 2332 CmdArgs.push_back("-tune-cpu"); 2333 CmdArgs.push_back(Args.MakeArgString(TuneCPU)); 2334 } 2335 } 2336 2337 void Clang::AddHexagonTargetArgs(const ArgList &Args, 2338 ArgStringList &CmdArgs) const { 2339 CmdArgs.push_back("-mqdsp6-compat"); 2340 CmdArgs.push_back("-Wreturn-type"); 2341 2342 if (auto G = toolchains::HexagonToolChain::getSmallDataThreshold(Args)) { 2343 CmdArgs.push_back("-mllvm"); 2344 CmdArgs.push_back(Args.MakeArgString("-hexagon-small-data-threshold=" + 2345 Twine(G.value()))); 2346 } 2347 2348 if (!Args.hasArg(options::OPT_fno_short_enums)) 2349 CmdArgs.push_back("-fshort-enums"); 2350 if (Args.getLastArg(options::OPT_mieee_rnd_near)) { 2351 CmdArgs.push_back("-mllvm"); 2352 CmdArgs.push_back("-enable-hexagon-ieee-rnd-near"); 2353 } 2354 CmdArgs.push_back("-mllvm"); 2355 CmdArgs.push_back("-machine-sink-split=0"); 2356 } 2357 2358 void Clang::AddLanaiTargetArgs(const ArgList &Args, 2359 ArgStringList &CmdArgs) const { 2360 if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) { 2361 StringRef CPUName = A->getValue(); 2362 2363 CmdArgs.push_back("-target-cpu"); 2364 CmdArgs.push_back(Args.MakeArgString(CPUName)); 2365 } 2366 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) { 2367 StringRef Value = A->getValue(); 2368 // Only support mregparm=4 to support old usage. Report error for all other 2369 // cases. 2370 int Mregparm; 2371 if (Value.getAsInteger(10, Mregparm)) { 2372 if (Mregparm != 4) { 2373 getToolChain().getDriver().Diag( 2374 diag::err_drv_unsupported_option_argument) 2375 << A->getOption().getName() << Value; 2376 } 2377 } 2378 } 2379 } 2380 2381 void Clang::AddWebAssemblyTargetArgs(const ArgList &Args, 2382 ArgStringList &CmdArgs) const { 2383 // Default to "hidden" visibility. 2384 if (!Args.hasArg(options::OPT_fvisibility_EQ, 2385 options::OPT_fvisibility_ms_compat)) { 2386 CmdArgs.push_back("-fvisibility"); 2387 CmdArgs.push_back("hidden"); 2388 } 2389 } 2390 2391 void Clang::AddVETargetArgs(const ArgList &Args, ArgStringList &CmdArgs) const { 2392 // Floating point operations and argument passing are hard. 2393 CmdArgs.push_back("-mfloat-abi"); 2394 CmdArgs.push_back("hard"); 2395 } 2396 2397 void Clang::DumpCompilationDatabase(Compilation &C, StringRef Filename, 2398 StringRef Target, const InputInfo &Output, 2399 const InputInfo &Input, const ArgList &Args) const { 2400 // If this is a dry run, do not create the compilation database file. 2401 if (C.getArgs().hasArg(options::OPT__HASH_HASH_HASH)) 2402 return; 2403 2404 using llvm::yaml::escape; 2405 const Driver &D = getToolChain().getDriver(); 2406 2407 if (!CompilationDatabase) { 2408 std::error_code EC; 2409 auto File = std::make_unique<llvm::raw_fd_ostream>( 2410 Filename, EC, 2411 llvm::sys::fs::OF_TextWithCRLF | llvm::sys::fs::OF_Append); 2412 if (EC) { 2413 D.Diag(clang::diag::err_drv_compilationdatabase) << Filename 2414 << EC.message(); 2415 return; 2416 } 2417 CompilationDatabase = std::move(File); 2418 } 2419 auto &CDB = *CompilationDatabase; 2420 auto CWD = D.getVFS().getCurrentWorkingDirectory(); 2421 if (!CWD) 2422 CWD = "."; 2423 CDB << "{ \"directory\": \"" << escape(*CWD) << "\""; 2424 CDB << ", \"file\": \"" << escape(Input.getFilename()) << "\""; 2425 CDB << ", \"output\": \"" << escape(Output.getFilename()) << "\""; 2426 CDB << ", \"arguments\": [\"" << escape(D.ClangExecutable) << "\""; 2427 SmallString<128> Buf; 2428 Buf = "-x"; 2429 Buf += types::getTypeName(Input.getType()); 2430 CDB << ", \"" << escape(Buf) << "\""; 2431 if (!D.SysRoot.empty() && !Args.hasArg(options::OPT__sysroot_EQ)) { 2432 Buf = "--sysroot="; 2433 Buf += D.SysRoot; 2434 CDB << ", \"" << escape(Buf) << "\""; 2435 } 2436 CDB << ", \"" << escape(Input.getFilename()) << "\""; 2437 CDB << ", \"-o\", \"" << escape(Output.getFilename()) << "\""; 2438 for (auto &A: Args) { 2439 auto &O = A->getOption(); 2440 // Skip language selection, which is positional. 2441 if (O.getID() == options::OPT_x) 2442 continue; 2443 // Skip writing dependency output and the compilation database itself. 2444 if (O.getGroup().isValid() && O.getGroup().getID() == options::OPT_M_Group) 2445 continue; 2446 if (O.getID() == options::OPT_gen_cdb_fragment_path) 2447 continue; 2448 // Skip inputs. 2449 if (O.getKind() == Option::InputClass) 2450 continue; 2451 // Skip output. 2452 if (O.getID() == options::OPT_o) 2453 continue; 2454 // All other arguments are quoted and appended. 2455 ArgStringList ASL; 2456 A->render(Args, ASL); 2457 for (auto &it: ASL) 2458 CDB << ", \"" << escape(it) << "\""; 2459 } 2460 Buf = "--target="; 2461 Buf += Target; 2462 CDB << ", \"" << escape(Buf) << "\"]},\n"; 2463 } 2464 2465 void Clang::DumpCompilationDatabaseFragmentToDir( 2466 StringRef Dir, Compilation &C, StringRef Target, const InputInfo &Output, 2467 const InputInfo &Input, const llvm::opt::ArgList &Args) const { 2468 // If this is a dry run, do not create the compilation database file. 2469 if (C.getArgs().hasArg(options::OPT__HASH_HASH_HASH)) 2470 return; 2471 2472 if (CompilationDatabase) 2473 DumpCompilationDatabase(C, "", Target, Output, Input, Args); 2474 2475 SmallString<256> Path = Dir; 2476 const auto &Driver = C.getDriver(); 2477 Driver.getVFS().makeAbsolute(Path); 2478 auto Err = llvm::sys::fs::create_directory(Path, /*IgnoreExisting=*/true); 2479 if (Err) { 2480 Driver.Diag(diag::err_drv_compilationdatabase) << Dir << Err.message(); 2481 return; 2482 } 2483 2484 llvm::sys::path::append( 2485 Path, 2486 Twine(llvm::sys::path::filename(Input.getFilename())) + ".%%%%.json"); 2487 int FD; 2488 SmallString<256> TempPath; 2489 Err = llvm::sys::fs::createUniqueFile(Path, FD, TempPath, 2490 llvm::sys::fs::OF_Text); 2491 if (Err) { 2492 Driver.Diag(diag::err_drv_compilationdatabase) << Path << Err.message(); 2493 return; 2494 } 2495 CompilationDatabase = 2496 std::make_unique<llvm::raw_fd_ostream>(FD, /*shouldClose=*/true); 2497 DumpCompilationDatabase(C, "", Target, Output, Input, Args); 2498 } 2499 2500 static bool CheckARMImplicitITArg(StringRef Value) { 2501 return Value == "always" || Value == "never" || Value == "arm" || 2502 Value == "thumb"; 2503 } 2504 2505 static void AddARMImplicitITArgs(const ArgList &Args, ArgStringList &CmdArgs, 2506 StringRef Value) { 2507 CmdArgs.push_back("-mllvm"); 2508 CmdArgs.push_back(Args.MakeArgString("-arm-implicit-it=" + Value)); 2509 } 2510 2511 static void CollectArgsForIntegratedAssembler(Compilation &C, 2512 const ArgList &Args, 2513 ArgStringList &CmdArgs, 2514 const Driver &D) { 2515 if (UseRelaxAll(C, Args)) 2516 CmdArgs.push_back("-mrelax-all"); 2517 2518 // Only default to -mincremental-linker-compatible if we think we are 2519 // targeting the MSVC linker. 2520 bool DefaultIncrementalLinkerCompatible = 2521 C.getDefaultToolChain().getTriple().isWindowsMSVCEnvironment(); 2522 if (Args.hasFlag(options::OPT_mincremental_linker_compatible, 2523 options::OPT_mno_incremental_linker_compatible, 2524 DefaultIncrementalLinkerCompatible)) 2525 CmdArgs.push_back("-mincremental-linker-compatible"); 2526 2527 Args.AddLastArg(CmdArgs, options::OPT_femit_dwarf_unwind_EQ); 2528 2529 // If you add more args here, also add them to the block below that 2530 // starts with "// If CollectArgsForIntegratedAssembler() isn't called below". 2531 2532 // When passing -I arguments to the assembler we sometimes need to 2533 // unconditionally take the next argument. For example, when parsing 2534 // '-Wa,-I -Wa,foo' we need to accept the -Wa,foo arg after seeing the 2535 // -Wa,-I arg and when parsing '-Wa,-I,foo' we need to accept the 'foo' 2536 // arg after parsing the '-I' arg. 2537 bool TakeNextArg = false; 2538 2539 bool UseRelaxRelocations = C.getDefaultToolChain().useRelaxRelocations(); 2540 bool UseNoExecStack = false; 2541 const char *MipsTargetFeature = nullptr; 2542 StringRef ImplicitIt; 2543 for (const Arg *A : 2544 Args.filtered(options::OPT_Wa_COMMA, options::OPT_Xassembler, 2545 options::OPT_mimplicit_it_EQ)) { 2546 A->claim(); 2547 2548 if (A->getOption().getID() == options::OPT_mimplicit_it_EQ) { 2549 switch (C.getDefaultToolChain().getArch()) { 2550 case llvm::Triple::arm: 2551 case llvm::Triple::armeb: 2552 case llvm::Triple::thumb: 2553 case llvm::Triple::thumbeb: 2554 // Only store the value; the last value set takes effect. 2555 ImplicitIt = A->getValue(); 2556 if (!CheckARMImplicitITArg(ImplicitIt)) 2557 D.Diag(diag::err_drv_unsupported_option_argument) 2558 << A->getOption().getName() << ImplicitIt; 2559 continue; 2560 default: 2561 break; 2562 } 2563 } 2564 2565 for (StringRef Value : A->getValues()) { 2566 if (TakeNextArg) { 2567 CmdArgs.push_back(Value.data()); 2568 TakeNextArg = false; 2569 continue; 2570 } 2571 2572 if (C.getDefaultToolChain().getTriple().isOSBinFormatCOFF() && 2573 Value == "-mbig-obj") 2574 continue; // LLVM handles bigobj automatically 2575 2576 switch (C.getDefaultToolChain().getArch()) { 2577 default: 2578 break; 2579 case llvm::Triple::thumb: 2580 case llvm::Triple::thumbeb: 2581 case llvm::Triple::arm: 2582 case llvm::Triple::armeb: 2583 if (Value.startswith("-mimplicit-it=")) { 2584 // Only store the value; the last value set takes effect. 2585 ImplicitIt = Value.split("=").second; 2586 if (CheckARMImplicitITArg(ImplicitIt)) 2587 continue; 2588 } 2589 if (Value == "-mthumb") 2590 // -mthumb has already been processed in ComputeLLVMTriple() 2591 // recognize but skip over here. 2592 continue; 2593 break; 2594 case llvm::Triple::mips: 2595 case llvm::Triple::mipsel: 2596 case llvm::Triple::mips64: 2597 case llvm::Triple::mips64el: 2598 if (Value == "--trap") { 2599 CmdArgs.push_back("-target-feature"); 2600 CmdArgs.push_back("+use-tcc-in-div"); 2601 continue; 2602 } 2603 if (Value == "--break") { 2604 CmdArgs.push_back("-target-feature"); 2605 CmdArgs.push_back("-use-tcc-in-div"); 2606 continue; 2607 } 2608 if (Value.startswith("-msoft-float")) { 2609 CmdArgs.push_back("-target-feature"); 2610 CmdArgs.push_back("+soft-float"); 2611 continue; 2612 } 2613 if (Value.startswith("-mhard-float")) { 2614 CmdArgs.push_back("-target-feature"); 2615 CmdArgs.push_back("-soft-float"); 2616 continue; 2617 } 2618 2619 MipsTargetFeature = llvm::StringSwitch<const char *>(Value) 2620 .Case("-mips1", "+mips1") 2621 .Case("-mips2", "+mips2") 2622 .Case("-mips3", "+mips3") 2623 .Case("-mips4", "+mips4") 2624 .Case("-mips5", "+mips5") 2625 .Case("-mips32", "+mips32") 2626 .Case("-mips32r2", "+mips32r2") 2627 .Case("-mips32r3", "+mips32r3") 2628 .Case("-mips32r5", "+mips32r5") 2629 .Case("-mips32r6", "+mips32r6") 2630 .Case("-mips64", "+mips64") 2631 .Case("-mips64r2", "+mips64r2") 2632 .Case("-mips64r3", "+mips64r3") 2633 .Case("-mips64r5", "+mips64r5") 2634 .Case("-mips64r6", "+mips64r6") 2635 .Default(nullptr); 2636 if (MipsTargetFeature) 2637 continue; 2638 } 2639 2640 if (Value == "-force_cpusubtype_ALL") { 2641 // Do nothing, this is the default and we don't support anything else. 2642 } else if (Value == "-L") { 2643 CmdArgs.push_back("-msave-temp-labels"); 2644 } else if (Value == "--fatal-warnings") { 2645 CmdArgs.push_back("-massembler-fatal-warnings"); 2646 } else if (Value == "--no-warn" || Value == "-W") { 2647 CmdArgs.push_back("-massembler-no-warn"); 2648 } else if (Value == "--noexecstack") { 2649 UseNoExecStack = true; 2650 } else if (Value.startswith("-compress-debug-sections") || 2651 Value.startswith("--compress-debug-sections") || 2652 Value == "-nocompress-debug-sections" || 2653 Value == "--nocompress-debug-sections") { 2654 CmdArgs.push_back(Value.data()); 2655 } else if (Value == "-mrelax-relocations=yes" || 2656 Value == "--mrelax-relocations=yes") { 2657 UseRelaxRelocations = true; 2658 } else if (Value == "-mrelax-relocations=no" || 2659 Value == "--mrelax-relocations=no") { 2660 UseRelaxRelocations = false; 2661 } else if (Value.startswith("-I")) { 2662 CmdArgs.push_back(Value.data()); 2663 // We need to consume the next argument if the current arg is a plain 2664 // -I. The next arg will be the include directory. 2665 if (Value == "-I") 2666 TakeNextArg = true; 2667 } else if (Value.startswith("-gdwarf-")) { 2668 // "-gdwarf-N" options are not cc1as options. 2669 unsigned DwarfVersion = DwarfVersionNum(Value); 2670 if (DwarfVersion == 0) { // Send it onward, and let cc1as complain. 2671 CmdArgs.push_back(Value.data()); 2672 } else { 2673 RenderDebugEnablingArgs(Args, CmdArgs, 2674 codegenoptions::DebugInfoConstructor, 2675 DwarfVersion, llvm::DebuggerKind::Default); 2676 } 2677 } else if (Value.startswith("-mcpu") || Value.startswith("-mfpu") || 2678 Value.startswith("-mhwdiv") || Value.startswith("-march")) { 2679 // Do nothing, we'll validate it later. 2680 } else if (Value == "-defsym") { 2681 if (A->getNumValues() != 2) { 2682 D.Diag(diag::err_drv_defsym_invalid_format) << Value; 2683 break; 2684 } 2685 const char *S = A->getValue(1); 2686 auto Pair = StringRef(S).split('='); 2687 auto Sym = Pair.first; 2688 auto SVal = Pair.second; 2689 2690 if (Sym.empty() || SVal.empty()) { 2691 D.Diag(diag::err_drv_defsym_invalid_format) << S; 2692 break; 2693 } 2694 int64_t IVal; 2695 if (SVal.getAsInteger(0, IVal)) { 2696 D.Diag(diag::err_drv_defsym_invalid_symval) << SVal; 2697 break; 2698 } 2699 CmdArgs.push_back(Value.data()); 2700 TakeNextArg = true; 2701 } else if (Value == "-fdebug-compilation-dir") { 2702 CmdArgs.push_back("-fdebug-compilation-dir"); 2703 TakeNextArg = true; 2704 } else if (Value.consume_front("-fdebug-compilation-dir=")) { 2705 // The flag is a -Wa / -Xassembler argument and Options doesn't 2706 // parse the argument, so this isn't automatically aliased to 2707 // -fdebug-compilation-dir (without '=') here. 2708 CmdArgs.push_back("-fdebug-compilation-dir"); 2709 CmdArgs.push_back(Value.data()); 2710 } else if (Value == "--version") { 2711 D.PrintVersion(C, llvm::outs()); 2712 } else { 2713 D.Diag(diag::err_drv_unsupported_option_argument) 2714 << A->getOption().getName() << Value; 2715 } 2716 } 2717 } 2718 if (ImplicitIt.size()) 2719 AddARMImplicitITArgs(Args, CmdArgs, ImplicitIt); 2720 if (UseRelaxRelocations) 2721 CmdArgs.push_back("--mrelax-relocations"); 2722 if (UseNoExecStack) 2723 CmdArgs.push_back("-mnoexecstack"); 2724 if (MipsTargetFeature != nullptr) { 2725 CmdArgs.push_back("-target-feature"); 2726 CmdArgs.push_back(MipsTargetFeature); 2727 } 2728 2729 // forward -fembed-bitcode to assmebler 2730 if (C.getDriver().embedBitcodeEnabled() || 2731 C.getDriver().embedBitcodeMarkerOnly()) 2732 Args.AddLastArg(CmdArgs, options::OPT_fembed_bitcode_EQ); 2733 } 2734 2735 static void RenderFloatingPointOptions(const ToolChain &TC, const Driver &D, 2736 bool OFastEnabled, const ArgList &Args, 2737 ArgStringList &CmdArgs, 2738 const JobAction &JA) { 2739 // Handle various floating point optimization flags, mapping them to the 2740 // appropriate LLVM code generation flags. This is complicated by several 2741 // "umbrella" flags, so we do this by stepping through the flags incrementally 2742 // adjusting what we think is enabled/disabled, then at the end setting the 2743 // LLVM flags based on the final state. 2744 bool HonorINFs = true; 2745 bool HonorNaNs = true; 2746 bool ApproxFunc = false; 2747 // -fmath-errno is the default on some platforms, e.g. BSD-derived OSes. 2748 bool MathErrno = TC.IsMathErrnoDefault(); 2749 bool AssociativeMath = false; 2750 bool ReciprocalMath = false; 2751 bool SignedZeros = true; 2752 bool TrappingMath = false; // Implemented via -ffp-exception-behavior 2753 bool TrappingMathPresent = false; // Is trapping-math in args, and not 2754 // overriden by ffp-exception-behavior? 2755 bool RoundingFPMath = false; 2756 bool RoundingMathPresent = false; // Is rounding-math in args? 2757 // -ffp-model values: strict, fast, precise 2758 StringRef FPModel = ""; 2759 // -ffp-exception-behavior options: strict, maytrap, ignore 2760 StringRef FPExceptionBehavior = ""; 2761 // -ffp-eval-method options: double, extended, source 2762 StringRef FPEvalMethod = ""; 2763 const llvm::DenormalMode DefaultDenormalFPMath = 2764 TC.getDefaultDenormalModeForType(Args, JA); 2765 const llvm::DenormalMode DefaultDenormalFP32Math = 2766 TC.getDefaultDenormalModeForType(Args, JA, &llvm::APFloat::IEEEsingle()); 2767 2768 llvm::DenormalMode DenormalFPMath = DefaultDenormalFPMath; 2769 llvm::DenormalMode DenormalFP32Math = DefaultDenormalFP32Math; 2770 // CUDA and HIP don't rely on the frontend to pass an ffp-contract option. 2771 // If one wasn't given by the user, don't pass it here. 2772 StringRef FPContract; 2773 if (!JA.isDeviceOffloading(Action::OFK_Cuda) && 2774 !JA.isOffloading(Action::OFK_HIP)) 2775 FPContract = "on"; 2776 bool StrictFPModel = false; 2777 2778 if (const Arg *A = Args.getLastArg(options::OPT_flimited_precision_EQ)) { 2779 CmdArgs.push_back("-mlimit-float-precision"); 2780 CmdArgs.push_back(A->getValue()); 2781 } 2782 2783 for (const Arg *A : Args) { 2784 auto optID = A->getOption().getID(); 2785 bool PreciseFPModel = false; 2786 switch (optID) { 2787 default: 2788 break; 2789 case options::OPT_ffp_model_EQ: { 2790 // If -ffp-model= is seen, reset to fno-fast-math 2791 HonorINFs = true; 2792 HonorNaNs = true; 2793 // Turning *off* -ffast-math restores the toolchain default. 2794 MathErrno = TC.IsMathErrnoDefault(); 2795 AssociativeMath = false; 2796 ReciprocalMath = false; 2797 SignedZeros = true; 2798 // -fno_fast_math restores default denormal and fpcontract handling 2799 FPContract = "on"; 2800 DenormalFPMath = llvm::DenormalMode::getIEEE(); 2801 2802 // FIXME: The target may have picked a non-IEEE default mode here based on 2803 // -cl-denorms-are-zero. Should the target consider -fp-model interaction? 2804 DenormalFP32Math = llvm::DenormalMode::getIEEE(); 2805 2806 StringRef Val = A->getValue(); 2807 if (OFastEnabled && !Val.equals("fast")) { 2808 // Only -ffp-model=fast is compatible with OFast, ignore. 2809 D.Diag(clang::diag::warn_drv_overriding_flag_option) 2810 << Args.MakeArgString("-ffp-model=" + Val) 2811 << "-Ofast"; 2812 break; 2813 } 2814 StrictFPModel = false; 2815 PreciseFPModel = true; 2816 // ffp-model= is a Driver option, it is entirely rewritten into more 2817 // granular options before being passed into cc1. 2818 // Use the gcc option in the switch below. 2819 if (!FPModel.empty() && !FPModel.equals(Val)) 2820 D.Diag(clang::diag::warn_drv_overriding_flag_option) 2821 << Args.MakeArgString("-ffp-model=" + FPModel) 2822 << Args.MakeArgString("-ffp-model=" + Val); 2823 if (Val.equals("fast")) { 2824 optID = options::OPT_ffast_math; 2825 FPModel = Val; 2826 FPContract = "fast"; 2827 } else if (Val.equals("precise")) { 2828 optID = options::OPT_ffp_contract; 2829 FPModel = Val; 2830 FPContract = "on"; 2831 PreciseFPModel = true; 2832 } else if (Val.equals("strict")) { 2833 StrictFPModel = true; 2834 optID = options::OPT_frounding_math; 2835 FPExceptionBehavior = "strict"; 2836 FPModel = Val; 2837 FPContract = "off"; 2838 TrappingMath = true; 2839 } else 2840 D.Diag(diag::err_drv_unsupported_option_argument) 2841 << A->getOption().getName() << Val; 2842 break; 2843 } 2844 } 2845 2846 switch (optID) { 2847 // If this isn't an FP option skip the claim below 2848 default: continue; 2849 2850 // Options controlling individual features 2851 case options::OPT_fhonor_infinities: HonorINFs = true; break; 2852 case options::OPT_fno_honor_infinities: HonorINFs = false; break; 2853 case options::OPT_fhonor_nans: HonorNaNs = true; break; 2854 case options::OPT_fno_honor_nans: HonorNaNs = false; break; 2855 case options::OPT_fapprox_func: ApproxFunc = true; break; 2856 case options::OPT_fno_approx_func: ApproxFunc = false; break; 2857 case options::OPT_fmath_errno: MathErrno = true; break; 2858 case options::OPT_fno_math_errno: MathErrno = false; break; 2859 case options::OPT_fassociative_math: AssociativeMath = true; break; 2860 case options::OPT_fno_associative_math: AssociativeMath = false; break; 2861 case options::OPT_freciprocal_math: ReciprocalMath = true; break; 2862 case options::OPT_fno_reciprocal_math: ReciprocalMath = false; break; 2863 case options::OPT_fsigned_zeros: SignedZeros = true; break; 2864 case options::OPT_fno_signed_zeros: SignedZeros = false; break; 2865 case options::OPT_ftrapping_math: 2866 if (!TrappingMathPresent && !FPExceptionBehavior.empty() && 2867 !FPExceptionBehavior.equals("strict")) 2868 // Warn that previous value of option is overridden. 2869 D.Diag(clang::diag::warn_drv_overriding_flag_option) 2870 << Args.MakeArgString("-ffp-exception-behavior=" + FPExceptionBehavior) 2871 << "-ftrapping-math"; 2872 TrappingMath = true; 2873 TrappingMathPresent = true; 2874 FPExceptionBehavior = "strict"; 2875 break; 2876 case options::OPT_fno_trapping_math: 2877 if (!TrappingMathPresent && !FPExceptionBehavior.empty() && 2878 !FPExceptionBehavior.equals("ignore")) 2879 // Warn that previous value of option is overridden. 2880 D.Diag(clang::diag::warn_drv_overriding_flag_option) 2881 << Args.MakeArgString("-ffp-exception-behavior=" + FPExceptionBehavior) 2882 << "-fno-trapping-math"; 2883 TrappingMath = false; 2884 TrappingMathPresent = true; 2885 FPExceptionBehavior = "ignore"; 2886 break; 2887 2888 case options::OPT_frounding_math: 2889 RoundingFPMath = true; 2890 RoundingMathPresent = true; 2891 break; 2892 2893 case options::OPT_fno_rounding_math: 2894 RoundingFPMath = false; 2895 RoundingMathPresent = false; 2896 break; 2897 2898 case options::OPT_fdenormal_fp_math_EQ: 2899 DenormalFPMath = llvm::parseDenormalFPAttribute(A->getValue()); 2900 DenormalFP32Math = DenormalFPMath; 2901 if (!DenormalFPMath.isValid()) { 2902 D.Diag(diag::err_drv_invalid_value) 2903 << A->getAsString(Args) << A->getValue(); 2904 } 2905 break; 2906 2907 case options::OPT_fdenormal_fp_math_f32_EQ: 2908 DenormalFP32Math = llvm::parseDenormalFPAttribute(A->getValue()); 2909 if (!DenormalFP32Math.isValid()) { 2910 D.Diag(diag::err_drv_invalid_value) 2911 << A->getAsString(Args) << A->getValue(); 2912 } 2913 break; 2914 2915 // Validate and pass through -ffp-contract option. 2916 case options::OPT_ffp_contract: { 2917 StringRef Val = A->getValue(); 2918 if (PreciseFPModel) { 2919 // -ffp-model=precise enables ffp-contract=on. 2920 // -ffp-model=precise sets PreciseFPModel to on and Val to 2921 // "precise". FPContract is set. 2922 ; 2923 } else if (Val.equals("fast") || Val.equals("on") || Val.equals("off")) 2924 FPContract = Val; 2925 else 2926 D.Diag(diag::err_drv_unsupported_option_argument) 2927 << A->getOption().getName() << Val; 2928 break; 2929 } 2930 2931 // Validate and pass through -ffp-model option. 2932 case options::OPT_ffp_model_EQ: 2933 // This should only occur in the error case 2934 // since the optID has been replaced by a more granular 2935 // floating point option. 2936 break; 2937 2938 // Validate and pass through -ffp-exception-behavior option. 2939 case options::OPT_ffp_exception_behavior_EQ: { 2940 StringRef Val = A->getValue(); 2941 if (!TrappingMathPresent && !FPExceptionBehavior.empty() && 2942 !FPExceptionBehavior.equals(Val)) 2943 // Warn that previous value of option is overridden. 2944 D.Diag(clang::diag::warn_drv_overriding_flag_option) 2945 << Args.MakeArgString("-ffp-exception-behavior=" + FPExceptionBehavior) 2946 << Args.MakeArgString("-ffp-exception-behavior=" + Val); 2947 TrappingMath = TrappingMathPresent = false; 2948 if (Val.equals("ignore") || Val.equals("maytrap")) 2949 FPExceptionBehavior = Val; 2950 else if (Val.equals("strict")) { 2951 FPExceptionBehavior = Val; 2952 TrappingMath = TrappingMathPresent = true; 2953 } else 2954 D.Diag(diag::err_drv_unsupported_option_argument) 2955 << A->getOption().getName() << Val; 2956 break; 2957 } 2958 2959 // Validate and pass through -ffp-eval-method option. 2960 case options::OPT_ffp_eval_method_EQ: { 2961 StringRef Val = A->getValue(); 2962 if (Val.equals("double") || Val.equals("extended") || 2963 Val.equals("source")) 2964 FPEvalMethod = Val; 2965 else 2966 D.Diag(diag::err_drv_unsupported_option_argument) 2967 << A->getOption().getName() << Val; 2968 break; 2969 } 2970 2971 case options::OPT_ffinite_math_only: 2972 HonorINFs = false; 2973 HonorNaNs = false; 2974 break; 2975 case options::OPT_fno_finite_math_only: 2976 HonorINFs = true; 2977 HonorNaNs = true; 2978 break; 2979 2980 case options::OPT_funsafe_math_optimizations: 2981 AssociativeMath = true; 2982 ReciprocalMath = true; 2983 SignedZeros = false; 2984 ApproxFunc = true; 2985 TrappingMath = false; 2986 FPExceptionBehavior = ""; 2987 break; 2988 case options::OPT_fno_unsafe_math_optimizations: 2989 AssociativeMath = false; 2990 ReciprocalMath = false; 2991 SignedZeros = true; 2992 ApproxFunc = false; 2993 TrappingMath = true; 2994 FPExceptionBehavior = "strict"; 2995 2996 // The target may have opted to flush by default, so force IEEE. 2997 DenormalFPMath = llvm::DenormalMode::getIEEE(); 2998 DenormalFP32Math = llvm::DenormalMode::getIEEE(); 2999 break; 3000 3001 case options::OPT_Ofast: 3002 // If -Ofast is the optimization level, then -ffast-math should be enabled 3003 if (!OFastEnabled) 3004 continue; 3005 LLVM_FALLTHROUGH; 3006 case options::OPT_ffast_math: 3007 HonorINFs = false; 3008 HonorNaNs = false; 3009 MathErrno = false; 3010 AssociativeMath = true; 3011 ReciprocalMath = true; 3012 ApproxFunc = true; 3013 SignedZeros = false; 3014 TrappingMath = false; 3015 RoundingFPMath = false; 3016 // If fast-math is set then set the fp-contract mode to fast. 3017 FPContract = "fast"; 3018 break; 3019 case options::OPT_fno_fast_math: 3020 HonorINFs = true; 3021 HonorNaNs = true; 3022 // Turning on -ffast-math (with either flag) removes the need for 3023 // MathErrno. However, turning *off* -ffast-math merely restores the 3024 // toolchain default (which may be false). 3025 MathErrno = TC.IsMathErrnoDefault(); 3026 AssociativeMath = false; 3027 ReciprocalMath = false; 3028 ApproxFunc = false; 3029 SignedZeros = true; 3030 // -fno_fast_math restores default denormal and fpcontract handling 3031 DenormalFPMath = DefaultDenormalFPMath; 3032 DenormalFP32Math = llvm::DenormalMode::getIEEE(); 3033 if (!JA.isDeviceOffloading(Action::OFK_Cuda) && 3034 !JA.isOffloading(Action::OFK_HIP)) 3035 if (FPContract == "fast") { 3036 FPContract = "on"; 3037 D.Diag(clang::diag::warn_drv_overriding_flag_option) 3038 << "-ffp-contract=fast" 3039 << "-ffp-contract=on"; 3040 } 3041 break; 3042 } 3043 if (StrictFPModel) { 3044 // If -ffp-model=strict has been specified on command line but 3045 // subsequent options conflict then emit warning diagnostic. 3046 if (HonorINFs && HonorNaNs && !AssociativeMath && !ReciprocalMath && 3047 SignedZeros && TrappingMath && RoundingFPMath && !ApproxFunc && 3048 DenormalFPMath == llvm::DenormalMode::getIEEE() && 3049 DenormalFP32Math == llvm::DenormalMode::getIEEE() && 3050 FPContract.equals("off")) 3051 // OK: Current Arg doesn't conflict with -ffp-model=strict 3052 ; 3053 else { 3054 StrictFPModel = false; 3055 FPModel = ""; 3056 D.Diag(clang::diag::warn_drv_overriding_flag_option) 3057 << "-ffp-model=strict" << 3058 ((A->getNumValues() == 0) ? A->getSpelling() 3059 : Args.MakeArgString(A->getSpelling() + A->getValue())); 3060 } 3061 } 3062 3063 // If we handled this option claim it 3064 A->claim(); 3065 } 3066 3067 if (!HonorINFs) 3068 CmdArgs.push_back("-menable-no-infs"); 3069 3070 if (!HonorNaNs) 3071 CmdArgs.push_back("-menable-no-nans"); 3072 3073 if (ApproxFunc) 3074 CmdArgs.push_back("-fapprox-func"); 3075 3076 if (MathErrno) 3077 CmdArgs.push_back("-fmath-errno"); 3078 3079 if (!MathErrno && AssociativeMath && ReciprocalMath && !SignedZeros && 3080 ApproxFunc && !TrappingMath) 3081 CmdArgs.push_back("-menable-unsafe-fp-math"); 3082 3083 if (!SignedZeros) 3084 CmdArgs.push_back("-fno-signed-zeros"); 3085 3086 if (AssociativeMath && !SignedZeros && !TrappingMath) 3087 CmdArgs.push_back("-mreassociate"); 3088 3089 if (ReciprocalMath) 3090 CmdArgs.push_back("-freciprocal-math"); 3091 3092 if (TrappingMath) { 3093 // FP Exception Behavior is also set to strict 3094 assert(FPExceptionBehavior.equals("strict")); 3095 } 3096 3097 // The default is IEEE. 3098 if (DenormalFPMath != llvm::DenormalMode::getIEEE()) { 3099 llvm::SmallString<64> DenormFlag; 3100 llvm::raw_svector_ostream ArgStr(DenormFlag); 3101 ArgStr << "-fdenormal-fp-math=" << DenormalFPMath; 3102 CmdArgs.push_back(Args.MakeArgString(ArgStr.str())); 3103 } 3104 3105 // Add f32 specific denormal mode flag if it's different. 3106 if (DenormalFP32Math != DenormalFPMath) { 3107 llvm::SmallString<64> DenormFlag; 3108 llvm::raw_svector_ostream ArgStr(DenormFlag); 3109 ArgStr << "-fdenormal-fp-math-f32=" << DenormalFP32Math; 3110 CmdArgs.push_back(Args.MakeArgString(ArgStr.str())); 3111 } 3112 3113 if (!FPContract.empty()) 3114 CmdArgs.push_back(Args.MakeArgString("-ffp-contract=" + FPContract)); 3115 3116 if (!RoundingFPMath) 3117 CmdArgs.push_back(Args.MakeArgString("-fno-rounding-math")); 3118 3119 if (RoundingFPMath && RoundingMathPresent) 3120 CmdArgs.push_back(Args.MakeArgString("-frounding-math")); 3121 3122 if (!FPExceptionBehavior.empty()) 3123 CmdArgs.push_back(Args.MakeArgString("-ffp-exception-behavior=" + 3124 FPExceptionBehavior)); 3125 3126 if (!FPEvalMethod.empty()) 3127 CmdArgs.push_back(Args.MakeArgString("-ffp-eval-method=" + FPEvalMethod)); 3128 3129 ParseMRecip(D, Args, CmdArgs); 3130 3131 // -ffast-math enables the __FAST_MATH__ preprocessor macro, but check for the 3132 // individual features enabled by -ffast-math instead of the option itself as 3133 // that's consistent with gcc's behaviour. 3134 if (!HonorINFs && !HonorNaNs && !MathErrno && AssociativeMath && ApproxFunc && 3135 ReciprocalMath && !SignedZeros && !TrappingMath && !RoundingFPMath) { 3136 CmdArgs.push_back("-ffast-math"); 3137 if (FPModel.equals("fast")) { 3138 if (FPContract.equals("fast")) 3139 // All set, do nothing. 3140 ; 3141 else if (FPContract.empty()) 3142 // Enable -ffp-contract=fast 3143 CmdArgs.push_back(Args.MakeArgString("-ffp-contract=fast")); 3144 else 3145 D.Diag(clang::diag::warn_drv_overriding_flag_option) 3146 << "-ffp-model=fast" 3147 << Args.MakeArgString("-ffp-contract=" + FPContract); 3148 } 3149 } 3150 3151 // Handle __FINITE_MATH_ONLY__ similarly. 3152 if (!HonorINFs && !HonorNaNs) 3153 CmdArgs.push_back("-ffinite-math-only"); 3154 3155 if (const Arg *A = Args.getLastArg(options::OPT_mfpmath_EQ)) { 3156 CmdArgs.push_back("-mfpmath"); 3157 CmdArgs.push_back(A->getValue()); 3158 } 3159 3160 // Disable a codegen optimization for floating-point casts. 3161 if (Args.hasFlag(options::OPT_fno_strict_float_cast_overflow, 3162 options::OPT_fstrict_float_cast_overflow, false)) 3163 CmdArgs.push_back("-fno-strict-float-cast-overflow"); 3164 } 3165 3166 static void RenderAnalyzerOptions(const ArgList &Args, ArgStringList &CmdArgs, 3167 const llvm::Triple &Triple, 3168 const InputInfo &Input) { 3169 // Add default argument set. 3170 if (!Args.hasArg(options::OPT__analyzer_no_default_checks)) { 3171 CmdArgs.push_back("-analyzer-checker=core"); 3172 CmdArgs.push_back("-analyzer-checker=apiModeling"); 3173 3174 if (!Triple.isWindowsMSVCEnvironment()) { 3175 CmdArgs.push_back("-analyzer-checker=unix"); 3176 } else { 3177 // Enable "unix" checkers that also work on Windows. 3178 CmdArgs.push_back("-analyzer-checker=unix.API"); 3179 CmdArgs.push_back("-analyzer-checker=unix.Malloc"); 3180 CmdArgs.push_back("-analyzer-checker=unix.MallocSizeof"); 3181 CmdArgs.push_back("-analyzer-checker=unix.MismatchedDeallocator"); 3182 CmdArgs.push_back("-analyzer-checker=unix.cstring.BadSizeArg"); 3183 CmdArgs.push_back("-analyzer-checker=unix.cstring.NullArg"); 3184 } 3185 3186 // Disable some unix checkers for PS4/PS5. 3187 if (Triple.isPS()) { 3188 CmdArgs.push_back("-analyzer-disable-checker=unix.API"); 3189 CmdArgs.push_back("-analyzer-disable-checker=unix.Vfork"); 3190 } 3191 3192 if (Triple.isOSDarwin()) { 3193 CmdArgs.push_back("-analyzer-checker=osx"); 3194 CmdArgs.push_back( 3195 "-analyzer-checker=security.insecureAPI.decodeValueOfObjCType"); 3196 } 3197 else if (Triple.isOSFuchsia()) 3198 CmdArgs.push_back("-analyzer-checker=fuchsia"); 3199 3200 CmdArgs.push_back("-analyzer-checker=deadcode"); 3201 3202 if (types::isCXX(Input.getType())) 3203 CmdArgs.push_back("-analyzer-checker=cplusplus"); 3204 3205 if (!Triple.isPS()) { 3206 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.UncheckedReturn"); 3207 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.getpw"); 3208 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.gets"); 3209 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mktemp"); 3210 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.mkstemp"); 3211 CmdArgs.push_back("-analyzer-checker=security.insecureAPI.vfork"); 3212 } 3213 3214 // Default nullability checks. 3215 CmdArgs.push_back("-analyzer-checker=nullability.NullPassedToNonnull"); 3216 CmdArgs.push_back("-analyzer-checker=nullability.NullReturnedFromNonnull"); 3217 } 3218 3219 // Set the output format. The default is plist, for (lame) historical reasons. 3220 CmdArgs.push_back("-analyzer-output"); 3221 if (Arg *A = Args.getLastArg(options::OPT__analyzer_output)) 3222 CmdArgs.push_back(A->getValue()); 3223 else 3224 CmdArgs.push_back("plist"); 3225 3226 // Disable the presentation of standard compiler warnings when using 3227 // --analyze. We only want to show static analyzer diagnostics or frontend 3228 // errors. 3229 CmdArgs.push_back("-w"); 3230 3231 // Add -Xanalyzer arguments when running as analyzer. 3232 Args.AddAllArgValues(CmdArgs, options::OPT_Xanalyzer); 3233 } 3234 3235 static bool isValidSymbolName(StringRef S) { 3236 if (S.empty()) 3237 return false; 3238 3239 if (std::isdigit(S[0])) 3240 return false; 3241 3242 return llvm::all_of(S, [](char C) { return std::isalnum(C) || C == '_'; }); 3243 } 3244 3245 static void RenderSSPOptions(const Driver &D, const ToolChain &TC, 3246 const ArgList &Args, ArgStringList &CmdArgs, 3247 bool KernelOrKext) { 3248 const llvm::Triple &EffectiveTriple = TC.getEffectiveTriple(); 3249 3250 // NVPTX doesn't support stack protectors; from the compiler's perspective, it 3251 // doesn't even have a stack! 3252 if (EffectiveTriple.isNVPTX()) 3253 return; 3254 3255 // -stack-protector=0 is default. 3256 LangOptions::StackProtectorMode StackProtectorLevel = LangOptions::SSPOff; 3257 LangOptions::StackProtectorMode DefaultStackProtectorLevel = 3258 TC.GetDefaultStackProtectorLevel(KernelOrKext); 3259 3260 if (Arg *A = Args.getLastArg(options::OPT_fno_stack_protector, 3261 options::OPT_fstack_protector_all, 3262 options::OPT_fstack_protector_strong, 3263 options::OPT_fstack_protector)) { 3264 if (A->getOption().matches(options::OPT_fstack_protector)) 3265 StackProtectorLevel = 3266 std::max<>(LangOptions::SSPOn, DefaultStackProtectorLevel); 3267 else if (A->getOption().matches(options::OPT_fstack_protector_strong)) 3268 StackProtectorLevel = LangOptions::SSPStrong; 3269 else if (A->getOption().matches(options::OPT_fstack_protector_all)) 3270 StackProtectorLevel = LangOptions::SSPReq; 3271 } else { 3272 StackProtectorLevel = DefaultStackProtectorLevel; 3273 } 3274 3275 if (StackProtectorLevel) { 3276 CmdArgs.push_back("-stack-protector"); 3277 CmdArgs.push_back(Args.MakeArgString(Twine(StackProtectorLevel))); 3278 } 3279 3280 // --param ssp-buffer-size= 3281 for (const Arg *A : Args.filtered(options::OPT__param)) { 3282 StringRef Str(A->getValue()); 3283 if (Str.startswith("ssp-buffer-size=")) { 3284 if (StackProtectorLevel) { 3285 CmdArgs.push_back("-stack-protector-buffer-size"); 3286 // FIXME: Verify the argument is a valid integer. 3287 CmdArgs.push_back(Args.MakeArgString(Str.drop_front(16))); 3288 } 3289 A->claim(); 3290 } 3291 } 3292 3293 const std::string &TripleStr = EffectiveTriple.getTriple(); 3294 if (Arg *A = Args.getLastArg(options::OPT_mstack_protector_guard_EQ)) { 3295 StringRef Value = A->getValue(); 3296 if (!EffectiveTriple.isX86() && !EffectiveTriple.isAArch64() && 3297 !EffectiveTriple.isARM() && !EffectiveTriple.isThumb()) 3298 D.Diag(diag::err_drv_unsupported_opt_for_target) 3299 << A->getAsString(Args) << TripleStr; 3300 if ((EffectiveTriple.isX86() || EffectiveTriple.isARM() || 3301 EffectiveTriple.isThumb()) && 3302 Value != "tls" && Value != "global") { 3303 D.Diag(diag::err_drv_invalid_value_with_suggestion) 3304 << A->getOption().getName() << Value << "tls global"; 3305 return; 3306 } 3307 if ((EffectiveTriple.isARM() || EffectiveTriple.isThumb()) && 3308 Value == "tls") { 3309 if (!Args.hasArg(options::OPT_mstack_protector_guard_offset_EQ)) { 3310 D.Diag(diag::err_drv_ssp_missing_offset_argument) 3311 << A->getAsString(Args); 3312 return; 3313 } 3314 // Check whether the target subarch supports the hardware TLS register 3315 if (!arm::isHardTPSupported(EffectiveTriple)) { 3316 D.Diag(diag::err_target_unsupported_tp_hard) 3317 << EffectiveTriple.getArchName(); 3318 return; 3319 } 3320 // Check whether the user asked for something other than -mtp=cp15 3321 if (Arg *A = Args.getLastArg(options::OPT_mtp_mode_EQ)) { 3322 StringRef Value = A->getValue(); 3323 if (Value != "cp15") { 3324 D.Diag(diag::err_drv_argument_not_allowed_with) 3325 << A->getAsString(Args) << "-mstack-protector-guard=tls"; 3326 return; 3327 } 3328 } 3329 CmdArgs.push_back("-target-feature"); 3330 CmdArgs.push_back("+read-tp-hard"); 3331 } 3332 if (EffectiveTriple.isAArch64() && Value != "sysreg" && Value != "global") { 3333 D.Diag(diag::err_drv_invalid_value_with_suggestion) 3334 << A->getOption().getName() << Value << "sysreg global"; 3335 return; 3336 } 3337 A->render(Args, CmdArgs); 3338 } 3339 3340 if (Arg *A = Args.getLastArg(options::OPT_mstack_protector_guard_offset_EQ)) { 3341 StringRef Value = A->getValue(); 3342 if (!EffectiveTriple.isX86() && !EffectiveTriple.isAArch64() && 3343 !EffectiveTriple.isARM() && !EffectiveTriple.isThumb()) 3344 D.Diag(diag::err_drv_unsupported_opt_for_target) 3345 << A->getAsString(Args) << TripleStr; 3346 int Offset; 3347 if (Value.getAsInteger(10, Offset)) { 3348 D.Diag(diag::err_drv_invalid_value) << A->getOption().getName() << Value; 3349 return; 3350 } 3351 if ((EffectiveTriple.isARM() || EffectiveTriple.isThumb()) && 3352 (Offset < 0 || Offset > 0xfffff)) { 3353 D.Diag(diag::err_drv_invalid_int_value) 3354 << A->getOption().getName() << Value; 3355 return; 3356 } 3357 A->render(Args, CmdArgs); 3358 } 3359 3360 if (Arg *A = Args.getLastArg(options::OPT_mstack_protector_guard_reg_EQ)) { 3361 StringRef Value = A->getValue(); 3362 if (!EffectiveTriple.isX86() && !EffectiveTriple.isAArch64()) 3363 D.Diag(diag::err_drv_unsupported_opt_for_target) 3364 << A->getAsString(Args) << TripleStr; 3365 if (EffectiveTriple.isX86() && (Value != "fs" && Value != "gs")) { 3366 D.Diag(diag::err_drv_invalid_value_with_suggestion) 3367 << A->getOption().getName() << Value << "fs gs"; 3368 return; 3369 } 3370 if (EffectiveTriple.isAArch64() && Value != "sp_el0") { 3371 D.Diag(diag::err_drv_invalid_value) << A->getOption().getName() << Value; 3372 return; 3373 } 3374 A->render(Args, CmdArgs); 3375 } 3376 3377 if (Arg *A = Args.getLastArg(options::OPT_mstack_protector_guard_symbol_EQ)) { 3378 StringRef Value = A->getValue(); 3379 if (!isValidSymbolName(Value)) { 3380 D.Diag(diag::err_drv_argument_only_allowed_with) 3381 << A->getOption().getName() << "legal symbol name"; 3382 return; 3383 } 3384 A->render(Args, CmdArgs); 3385 } 3386 } 3387 3388 static void RenderSCPOptions(const ToolChain &TC, const ArgList &Args, 3389 ArgStringList &CmdArgs) { 3390 const llvm::Triple &EffectiveTriple = TC.getEffectiveTriple(); 3391 3392 if (!EffectiveTriple.isOSFreeBSD() && !EffectiveTriple.isOSLinux()) 3393 return; 3394 3395 if (!EffectiveTriple.isX86() && !EffectiveTriple.isSystemZ() && 3396 !EffectiveTriple.isPPC64()) 3397 return; 3398 3399 Args.addOptInFlag(CmdArgs, options::OPT_fstack_clash_protection, 3400 options::OPT_fno_stack_clash_protection); 3401 } 3402 3403 static void RenderTrivialAutoVarInitOptions(const Driver &D, 3404 const ToolChain &TC, 3405 const ArgList &Args, 3406 ArgStringList &CmdArgs) { 3407 auto DefaultTrivialAutoVarInit = TC.GetDefaultTrivialAutoVarInit(); 3408 StringRef TrivialAutoVarInit = ""; 3409 3410 for (const Arg *A : Args) { 3411 switch (A->getOption().getID()) { 3412 default: 3413 continue; 3414 case options::OPT_ftrivial_auto_var_init: { 3415 A->claim(); 3416 StringRef Val = A->getValue(); 3417 if (Val == "uninitialized" || Val == "zero" || Val == "pattern") 3418 TrivialAutoVarInit = Val; 3419 else 3420 D.Diag(diag::err_drv_unsupported_option_argument) 3421 << A->getOption().getName() << Val; 3422 break; 3423 } 3424 } 3425 } 3426 3427 if (TrivialAutoVarInit.empty()) 3428 switch (DefaultTrivialAutoVarInit) { 3429 case LangOptions::TrivialAutoVarInitKind::Uninitialized: 3430 break; 3431 case LangOptions::TrivialAutoVarInitKind::Pattern: 3432 TrivialAutoVarInit = "pattern"; 3433 break; 3434 case LangOptions::TrivialAutoVarInitKind::Zero: 3435 TrivialAutoVarInit = "zero"; 3436 break; 3437 } 3438 3439 if (!TrivialAutoVarInit.empty()) { 3440 if (TrivialAutoVarInit == "zero" && !Args.hasArg(options::OPT_enable_trivial_var_init_zero)) 3441 D.Diag(diag::err_drv_trivial_auto_var_init_zero_disabled); 3442 CmdArgs.push_back( 3443 Args.MakeArgString("-ftrivial-auto-var-init=" + TrivialAutoVarInit)); 3444 } 3445 3446 if (Arg *A = 3447 Args.getLastArg(options::OPT_ftrivial_auto_var_init_stop_after)) { 3448 if (!Args.hasArg(options::OPT_ftrivial_auto_var_init) || 3449 StringRef( 3450 Args.getLastArg(options::OPT_ftrivial_auto_var_init)->getValue()) == 3451 "uninitialized") 3452 D.Diag(diag::err_drv_trivial_auto_var_init_stop_after_missing_dependency); 3453 A->claim(); 3454 StringRef Val = A->getValue(); 3455 if (std::stoi(Val.str()) <= 0) 3456 D.Diag(diag::err_drv_trivial_auto_var_init_stop_after_invalid_value); 3457 CmdArgs.push_back( 3458 Args.MakeArgString("-ftrivial-auto-var-init-stop-after=" + Val)); 3459 } 3460 } 3461 3462 static void RenderOpenCLOptions(const ArgList &Args, ArgStringList &CmdArgs, 3463 types::ID InputType) { 3464 // cl-denorms-are-zero is not forwarded. It is translated into a generic flag 3465 // for denormal flushing handling based on the target. 3466 const unsigned ForwardedArguments[] = { 3467 options::OPT_cl_opt_disable, 3468 options::OPT_cl_strict_aliasing, 3469 options::OPT_cl_single_precision_constant, 3470 options::OPT_cl_finite_math_only, 3471 options::OPT_cl_kernel_arg_info, 3472 options::OPT_cl_unsafe_math_optimizations, 3473 options::OPT_cl_fast_relaxed_math, 3474 options::OPT_cl_mad_enable, 3475 options::OPT_cl_no_signed_zeros, 3476 options::OPT_cl_fp32_correctly_rounded_divide_sqrt, 3477 options::OPT_cl_uniform_work_group_size 3478 }; 3479 3480 if (Arg *A = Args.getLastArg(options::OPT_cl_std_EQ)) { 3481 std::string CLStdStr = std::string("-cl-std=") + A->getValue(); 3482 CmdArgs.push_back(Args.MakeArgString(CLStdStr)); 3483 } else if (Arg *A = Args.getLastArg(options::OPT_cl_ext_EQ)) { 3484 std::string CLExtStr = std::string("-cl-ext=") + A->getValue(); 3485 CmdArgs.push_back(Args.MakeArgString(CLExtStr)); 3486 } 3487 3488 for (const auto &Arg : ForwardedArguments) 3489 if (const auto *A = Args.getLastArg(Arg)) 3490 CmdArgs.push_back(Args.MakeArgString(A->getOption().getPrefixedName())); 3491 3492 // Only add the default headers if we are compiling OpenCL sources. 3493 if ((types::isOpenCL(InputType) || 3494 (Args.hasArg(options::OPT_cl_std_EQ) && types::isSrcFile(InputType))) && 3495 !Args.hasArg(options::OPT_cl_no_stdinc)) { 3496 CmdArgs.push_back("-finclude-default-header"); 3497 CmdArgs.push_back("-fdeclare-opencl-builtins"); 3498 } 3499 } 3500 3501 static void RenderHLSLOptions(const ArgList &Args, ArgStringList &CmdArgs, 3502 types::ID InputType) { 3503 const unsigned ForwardedArguments[] = {options::OPT_dxil_validator_version, 3504 options::OPT_D, 3505 options::OPT_I, 3506 options::OPT_S, 3507 options::OPT_emit_llvm, 3508 options::OPT_disable_llvm_passes, 3509 options::OPT_fnative_half_type}; 3510 3511 for (const auto &Arg : ForwardedArguments) 3512 if (const auto *A = Args.getLastArg(Arg)) 3513 A->renderAsInput(Args, CmdArgs); 3514 // Add the default headers if dxc_no_stdinc is not set. 3515 if (!Args.hasArg(options::OPT_dxc_no_stdinc)) 3516 CmdArgs.push_back("-finclude-default-header"); 3517 CmdArgs.push_back("-fallow-half-arguments-and-returns"); 3518 } 3519 3520 static void RenderARCMigrateToolOptions(const Driver &D, const ArgList &Args, 3521 ArgStringList &CmdArgs) { 3522 bool ARCMTEnabled = false; 3523 if (!Args.hasArg(options::OPT_fno_objc_arc, options::OPT_fobjc_arc)) { 3524 if (const Arg *A = Args.getLastArg(options::OPT_ccc_arcmt_check, 3525 options::OPT_ccc_arcmt_modify, 3526 options::OPT_ccc_arcmt_migrate)) { 3527 ARCMTEnabled = true; 3528 switch (A->getOption().getID()) { 3529 default: llvm_unreachable("missed a case"); 3530 case options::OPT_ccc_arcmt_check: 3531 CmdArgs.push_back("-arcmt-action=check"); 3532 break; 3533 case options::OPT_ccc_arcmt_modify: 3534 CmdArgs.push_back("-arcmt-action=modify"); 3535 break; 3536 case options::OPT_ccc_arcmt_migrate: 3537 CmdArgs.push_back("-arcmt-action=migrate"); 3538 CmdArgs.push_back("-mt-migrate-directory"); 3539 CmdArgs.push_back(A->getValue()); 3540 3541 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_report_output); 3542 Args.AddLastArg(CmdArgs, options::OPT_arcmt_migrate_emit_arc_errors); 3543 break; 3544 } 3545 } 3546 } else { 3547 Args.ClaimAllArgs(options::OPT_ccc_arcmt_check); 3548 Args.ClaimAllArgs(options::OPT_ccc_arcmt_modify); 3549 Args.ClaimAllArgs(options::OPT_ccc_arcmt_migrate); 3550 } 3551 3552 if (const Arg *A = Args.getLastArg(options::OPT_ccc_objcmt_migrate)) { 3553 if (ARCMTEnabled) 3554 D.Diag(diag::err_drv_argument_not_allowed_with) 3555 << A->getAsString(Args) << "-ccc-arcmt-migrate"; 3556 3557 CmdArgs.push_back("-mt-migrate-directory"); 3558 CmdArgs.push_back(A->getValue()); 3559 3560 if (!Args.hasArg(options::OPT_objcmt_migrate_literals, 3561 options::OPT_objcmt_migrate_subscripting, 3562 options::OPT_objcmt_migrate_property)) { 3563 // None specified, means enable them all. 3564 CmdArgs.push_back("-objcmt-migrate-literals"); 3565 CmdArgs.push_back("-objcmt-migrate-subscripting"); 3566 CmdArgs.push_back("-objcmt-migrate-property"); 3567 } else { 3568 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals); 3569 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting); 3570 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property); 3571 } 3572 } else { 3573 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_literals); 3574 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_subscripting); 3575 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property); 3576 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_all); 3577 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readonly_property); 3578 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_readwrite_property); 3579 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_property_dot_syntax); 3580 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_annotation); 3581 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_instancetype); 3582 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_nsmacros); 3583 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_protocol_conformance); 3584 Args.AddLastArg(CmdArgs, options::OPT_objcmt_atomic_property); 3585 Args.AddLastArg(CmdArgs, options::OPT_objcmt_returns_innerpointer_property); 3586 Args.AddLastArg(CmdArgs, options::OPT_objcmt_ns_nonatomic_iosonly); 3587 Args.AddLastArg(CmdArgs, options::OPT_objcmt_migrate_designated_init); 3588 Args.AddLastArg(CmdArgs, options::OPT_objcmt_allowlist_dir_path); 3589 } 3590 } 3591 3592 static void RenderBuiltinOptions(const ToolChain &TC, const llvm::Triple &T, 3593 const ArgList &Args, ArgStringList &CmdArgs) { 3594 // -fbuiltin is default unless -mkernel is used. 3595 bool UseBuiltins = 3596 Args.hasFlag(options::OPT_fbuiltin, options::OPT_fno_builtin, 3597 !Args.hasArg(options::OPT_mkernel)); 3598 if (!UseBuiltins) 3599 CmdArgs.push_back("-fno-builtin"); 3600 3601 // -ffreestanding implies -fno-builtin. 3602 if (Args.hasArg(options::OPT_ffreestanding)) 3603 UseBuiltins = false; 3604 3605 // Process the -fno-builtin-* options. 3606 for (const Arg *A : Args.filtered(options::OPT_fno_builtin_)) { 3607 A->claim(); 3608 3609 // If -fno-builtin is specified, then there's no need to pass the option to 3610 // the frontend. 3611 if (UseBuiltins) 3612 A->render(Args, CmdArgs); 3613 } 3614 3615 // le32-specific flags: 3616 // -fno-math-builtin: clang should not convert math builtins to intrinsics 3617 // by default. 3618 if (TC.getArch() == llvm::Triple::le32) 3619 CmdArgs.push_back("-fno-math-builtin"); 3620 } 3621 3622 bool Driver::getDefaultModuleCachePath(SmallVectorImpl<char> &Result) { 3623 if (const char *Str = std::getenv("CLANG_MODULE_CACHE_PATH")) { 3624 Twine Path{Str}; 3625 Path.toVector(Result); 3626 return Path.getSingleStringRef() != ""; 3627 } 3628 if (llvm::sys::path::cache_directory(Result)) { 3629 llvm::sys::path::append(Result, "clang"); 3630 llvm::sys::path::append(Result, "ModuleCache"); 3631 return true; 3632 } 3633 return false; 3634 } 3635 3636 static void RenderModulesOptions(Compilation &C, const Driver &D, 3637 const ArgList &Args, const InputInfo &Input, 3638 const InputInfo &Output, 3639 ArgStringList &CmdArgs, bool &HaveModules) { 3640 // -fmodules enables the use of precompiled modules (off by default). 3641 // Users can pass -fno-cxx-modules to turn off modules support for 3642 // C++/Objective-C++ programs. 3643 bool HaveClangModules = false; 3644 if (Args.hasFlag(options::OPT_fmodules, options::OPT_fno_modules, false)) { 3645 bool AllowedInCXX = Args.hasFlag(options::OPT_fcxx_modules, 3646 options::OPT_fno_cxx_modules, true); 3647 if (AllowedInCXX || !types::isCXX(Input.getType())) { 3648 CmdArgs.push_back("-fmodules"); 3649 HaveClangModules = true; 3650 } 3651 } 3652 3653 HaveModules |= HaveClangModules; 3654 if (Args.hasArg(options::OPT_fmodules_ts)) { 3655 CmdArgs.push_back("-fmodules-ts"); 3656 HaveModules = true; 3657 } 3658 3659 // -fmodule-maps enables implicit reading of module map files. By default, 3660 // this is enabled if we are using Clang's flavor of precompiled modules. 3661 if (Args.hasFlag(options::OPT_fimplicit_module_maps, 3662 options::OPT_fno_implicit_module_maps, HaveClangModules)) 3663 CmdArgs.push_back("-fimplicit-module-maps"); 3664 3665 // -fmodules-decluse checks that modules used are declared so (off by default) 3666 Args.addOptInFlag(CmdArgs, options::OPT_fmodules_decluse, 3667 options::OPT_fno_modules_decluse); 3668 3669 // -fmodules-strict-decluse is like -fmodule-decluse, but also checks that 3670 // all #included headers are part of modules. 3671 if (Args.hasFlag(options::OPT_fmodules_strict_decluse, 3672 options::OPT_fno_modules_strict_decluse, false)) 3673 CmdArgs.push_back("-fmodules-strict-decluse"); 3674 3675 // -fno-implicit-modules turns off implicitly compiling modules on demand. 3676 bool ImplicitModules = false; 3677 if (!Args.hasFlag(options::OPT_fimplicit_modules, 3678 options::OPT_fno_implicit_modules, HaveClangModules)) { 3679 if (HaveModules) 3680 CmdArgs.push_back("-fno-implicit-modules"); 3681 } else if (HaveModules) { 3682 ImplicitModules = true; 3683 // -fmodule-cache-path specifies where our implicitly-built module files 3684 // should be written. 3685 SmallString<128> Path; 3686 if (Arg *A = Args.getLastArg(options::OPT_fmodules_cache_path)) 3687 Path = A->getValue(); 3688 3689 bool HasPath = true; 3690 if (C.isForDiagnostics()) { 3691 // When generating crash reports, we want to emit the modules along with 3692 // the reproduction sources, so we ignore any provided module path. 3693 Path = Output.getFilename(); 3694 llvm::sys::path::replace_extension(Path, ".cache"); 3695 llvm::sys::path::append(Path, "modules"); 3696 } else if (Path.empty()) { 3697 // No module path was provided: use the default. 3698 HasPath = Driver::getDefaultModuleCachePath(Path); 3699 } 3700 3701 // `HasPath` will only be false if getDefaultModuleCachePath() fails. 3702 // That being said, that failure is unlikely and not caching is harmless. 3703 if (HasPath) { 3704 const char Arg[] = "-fmodules-cache-path="; 3705 Path.insert(Path.begin(), Arg, Arg + strlen(Arg)); 3706 CmdArgs.push_back(Args.MakeArgString(Path)); 3707 } 3708 } 3709 3710 if (HaveModules) { 3711 // -fprebuilt-module-path specifies where to load the prebuilt module files. 3712 for (const Arg *A : Args.filtered(options::OPT_fprebuilt_module_path)) { 3713 CmdArgs.push_back(Args.MakeArgString( 3714 std::string("-fprebuilt-module-path=") + A->getValue())); 3715 A->claim(); 3716 } 3717 if (Args.hasFlag(options::OPT_fprebuilt_implicit_modules, 3718 options::OPT_fno_prebuilt_implicit_modules, false)) 3719 CmdArgs.push_back("-fprebuilt-implicit-modules"); 3720 if (Args.hasFlag(options::OPT_fmodules_validate_input_files_content, 3721 options::OPT_fno_modules_validate_input_files_content, 3722 false)) 3723 CmdArgs.push_back("-fvalidate-ast-input-files-content"); 3724 } 3725 3726 // -fmodule-name specifies the module that is currently being built (or 3727 // used for header checking by -fmodule-maps). 3728 Args.AddLastArg(CmdArgs, options::OPT_fmodule_name_EQ); 3729 3730 // -fmodule-map-file can be used to specify files containing module 3731 // definitions. 3732 Args.AddAllArgs(CmdArgs, options::OPT_fmodule_map_file); 3733 3734 // -fbuiltin-module-map can be used to load the clang 3735 // builtin headers modulemap file. 3736 if (Args.hasArg(options::OPT_fbuiltin_module_map)) { 3737 SmallString<128> BuiltinModuleMap(D.ResourceDir); 3738 llvm::sys::path::append(BuiltinModuleMap, "include"); 3739 llvm::sys::path::append(BuiltinModuleMap, "module.modulemap"); 3740 if (llvm::sys::fs::exists(BuiltinModuleMap)) 3741 CmdArgs.push_back( 3742 Args.MakeArgString("-fmodule-map-file=" + BuiltinModuleMap)); 3743 } 3744 3745 // The -fmodule-file=<name>=<file> form specifies the mapping of module 3746 // names to precompiled module files (the module is loaded only if used). 3747 // The -fmodule-file=<file> form can be used to unconditionally load 3748 // precompiled module files (whether used or not). 3749 if (HaveModules) 3750 Args.AddAllArgs(CmdArgs, options::OPT_fmodule_file); 3751 else 3752 Args.ClaimAllArgs(options::OPT_fmodule_file); 3753 3754 // When building modules and generating crashdumps, we need to dump a module 3755 // dependency VFS alongside the output. 3756 if (HaveClangModules && C.isForDiagnostics()) { 3757 SmallString<128> VFSDir(Output.getFilename()); 3758 llvm::sys::path::replace_extension(VFSDir, ".cache"); 3759 // Add the cache directory as a temp so the crash diagnostics pick it up. 3760 C.addTempFile(Args.MakeArgString(VFSDir)); 3761 3762 llvm::sys::path::append(VFSDir, "vfs"); 3763 CmdArgs.push_back("-module-dependency-dir"); 3764 CmdArgs.push_back(Args.MakeArgString(VFSDir)); 3765 } 3766 3767 if (HaveClangModules) 3768 Args.AddLastArg(CmdArgs, options::OPT_fmodules_user_build_path); 3769 3770 // Pass through all -fmodules-ignore-macro arguments. 3771 Args.AddAllArgs(CmdArgs, options::OPT_fmodules_ignore_macro); 3772 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_interval); 3773 Args.AddLastArg(CmdArgs, options::OPT_fmodules_prune_after); 3774 3775 if (HaveClangModules) { 3776 Args.AddLastArg(CmdArgs, options::OPT_fbuild_session_timestamp); 3777 3778 if (Arg *A = Args.getLastArg(options::OPT_fbuild_session_file)) { 3779 if (Args.hasArg(options::OPT_fbuild_session_timestamp)) 3780 D.Diag(diag::err_drv_argument_not_allowed_with) 3781 << A->getAsString(Args) << "-fbuild-session-timestamp"; 3782 3783 llvm::sys::fs::file_status Status; 3784 if (llvm::sys::fs::status(A->getValue(), Status)) 3785 D.Diag(diag::err_drv_no_such_file) << A->getValue(); 3786 CmdArgs.push_back(Args.MakeArgString( 3787 "-fbuild-session-timestamp=" + 3788 Twine((uint64_t)std::chrono::duration_cast<std::chrono::seconds>( 3789 Status.getLastModificationTime().time_since_epoch()) 3790 .count()))); 3791 } 3792 3793 if (Args.getLastArg( 3794 options::OPT_fmodules_validate_once_per_build_session)) { 3795 if (!Args.getLastArg(options::OPT_fbuild_session_timestamp, 3796 options::OPT_fbuild_session_file)) 3797 D.Diag(diag::err_drv_modules_validate_once_requires_timestamp); 3798 3799 Args.AddLastArg(CmdArgs, 3800 options::OPT_fmodules_validate_once_per_build_session); 3801 } 3802 3803 if (Args.hasFlag(options::OPT_fmodules_validate_system_headers, 3804 options::OPT_fno_modules_validate_system_headers, 3805 ImplicitModules)) 3806 CmdArgs.push_back("-fmodules-validate-system-headers"); 3807 3808 Args.AddLastArg(CmdArgs, 3809 options::OPT_fmodules_disable_diagnostic_validation); 3810 } else { 3811 Args.ClaimAllArgs(options::OPT_fbuild_session_timestamp); 3812 Args.ClaimAllArgs(options::OPT_fbuild_session_file); 3813 Args.ClaimAllArgs(options::OPT_fmodules_validate_once_per_build_session); 3814 Args.ClaimAllArgs(options::OPT_fmodules_validate_system_headers); 3815 Args.ClaimAllArgs(options::OPT_fno_modules_validate_system_headers); 3816 Args.ClaimAllArgs(options::OPT_fmodules_disable_diagnostic_validation); 3817 } 3818 } 3819 3820 static void RenderCharacterOptions(const ArgList &Args, const llvm::Triple &T, 3821 ArgStringList &CmdArgs) { 3822 // -fsigned-char is default. 3823 if (const Arg *A = Args.getLastArg(options::OPT_fsigned_char, 3824 options::OPT_fno_signed_char, 3825 options::OPT_funsigned_char, 3826 options::OPT_fno_unsigned_char)) { 3827 if (A->getOption().matches(options::OPT_funsigned_char) || 3828 A->getOption().matches(options::OPT_fno_signed_char)) { 3829 CmdArgs.push_back("-fno-signed-char"); 3830 } 3831 } else if (!isSignedCharDefault(T)) { 3832 CmdArgs.push_back("-fno-signed-char"); 3833 } 3834 3835 // The default depends on the language standard. 3836 Args.AddLastArg(CmdArgs, options::OPT_fchar8__t, options::OPT_fno_char8__t); 3837 3838 if (const Arg *A = Args.getLastArg(options::OPT_fshort_wchar, 3839 options::OPT_fno_short_wchar)) { 3840 if (A->getOption().matches(options::OPT_fshort_wchar)) { 3841 CmdArgs.push_back("-fwchar-type=short"); 3842 CmdArgs.push_back("-fno-signed-wchar"); 3843 } else { 3844 bool IsARM = T.isARM() || T.isThumb() || T.isAArch64(); 3845 CmdArgs.push_back("-fwchar-type=int"); 3846 if (T.isOSzOS() || 3847 (IsARM && !(T.isOSWindows() || T.isOSNetBSD() || T.isOSOpenBSD()))) 3848 CmdArgs.push_back("-fno-signed-wchar"); 3849 else 3850 CmdArgs.push_back("-fsigned-wchar"); 3851 } 3852 } 3853 } 3854 3855 static void RenderObjCOptions(const ToolChain &TC, const Driver &D, 3856 const llvm::Triple &T, const ArgList &Args, 3857 ObjCRuntime &Runtime, bool InferCovariantReturns, 3858 const InputInfo &Input, ArgStringList &CmdArgs) { 3859 const llvm::Triple::ArchType Arch = TC.getArch(); 3860 3861 // -fobjc-dispatch-method is only relevant with the nonfragile-abi, and legacy 3862 // is the default. Except for deployment target of 10.5, next runtime is 3863 // always legacy dispatch and -fno-objc-legacy-dispatch gets ignored silently. 3864 if (Runtime.isNonFragile()) { 3865 if (!Args.hasFlag(options::OPT_fobjc_legacy_dispatch, 3866 options::OPT_fno_objc_legacy_dispatch, 3867 Runtime.isLegacyDispatchDefaultForArch(Arch))) { 3868 if (TC.UseObjCMixedDispatch()) 3869 CmdArgs.push_back("-fobjc-dispatch-method=mixed"); 3870 else 3871 CmdArgs.push_back("-fobjc-dispatch-method=non-legacy"); 3872 } 3873 } 3874 3875 // When ObjectiveC legacy runtime is in effect on MacOSX, turn on the option 3876 // to do Array/Dictionary subscripting by default. 3877 if (Arch == llvm::Triple::x86 && T.isMacOSX() && 3878 Runtime.getKind() == ObjCRuntime::FragileMacOSX && Runtime.isNeXTFamily()) 3879 CmdArgs.push_back("-fobjc-subscripting-legacy-runtime"); 3880 3881 // Allow -fno-objc-arr to trump -fobjc-arr/-fobjc-arc. 3882 // NOTE: This logic is duplicated in ToolChains.cpp. 3883 if (isObjCAutoRefCount(Args)) { 3884 TC.CheckObjCARC(); 3885 3886 CmdArgs.push_back("-fobjc-arc"); 3887 3888 // FIXME: It seems like this entire block, and several around it should be 3889 // wrapped in isObjC, but for now we just use it here as this is where it 3890 // was being used previously. 3891 if (types::isCXX(Input.getType()) && types::isObjC(Input.getType())) { 3892 if (TC.GetCXXStdlibType(Args) == ToolChain::CST_Libcxx) 3893 CmdArgs.push_back("-fobjc-arc-cxxlib=libc++"); 3894 else 3895 CmdArgs.push_back("-fobjc-arc-cxxlib=libstdc++"); 3896 } 3897 3898 // Allow the user to enable full exceptions code emission. 3899 // We default off for Objective-C, on for Objective-C++. 3900 if (Args.hasFlag(options::OPT_fobjc_arc_exceptions, 3901 options::OPT_fno_objc_arc_exceptions, 3902 /*Default=*/types::isCXX(Input.getType()))) 3903 CmdArgs.push_back("-fobjc-arc-exceptions"); 3904 } 3905 3906 // Silence warning for full exception code emission options when explicitly 3907 // set to use no ARC. 3908 if (Args.hasArg(options::OPT_fno_objc_arc)) { 3909 Args.ClaimAllArgs(options::OPT_fobjc_arc_exceptions); 3910 Args.ClaimAllArgs(options::OPT_fno_objc_arc_exceptions); 3911 } 3912 3913 // Allow the user to control whether messages can be converted to runtime 3914 // functions. 3915 if (types::isObjC(Input.getType())) { 3916 auto *Arg = Args.getLastArg( 3917 options::OPT_fobjc_convert_messages_to_runtime_calls, 3918 options::OPT_fno_objc_convert_messages_to_runtime_calls); 3919 if (Arg && 3920 Arg->getOption().matches( 3921 options::OPT_fno_objc_convert_messages_to_runtime_calls)) 3922 CmdArgs.push_back("-fno-objc-convert-messages-to-runtime-calls"); 3923 } 3924 3925 // -fobjc-infer-related-result-type is the default, except in the Objective-C 3926 // rewriter. 3927 if (InferCovariantReturns) 3928 CmdArgs.push_back("-fno-objc-infer-related-result-type"); 3929 3930 // Pass down -fobjc-weak or -fno-objc-weak if present. 3931 if (types::isObjC(Input.getType())) { 3932 auto WeakArg = 3933 Args.getLastArg(options::OPT_fobjc_weak, options::OPT_fno_objc_weak); 3934 if (!WeakArg) { 3935 // nothing to do 3936 } else if (!Runtime.allowsWeak()) { 3937 if (WeakArg->getOption().matches(options::OPT_fobjc_weak)) 3938 D.Diag(diag::err_objc_weak_unsupported); 3939 } else { 3940 WeakArg->render(Args, CmdArgs); 3941 } 3942 } 3943 3944 if (Args.hasArg(options::OPT_fobjc_disable_direct_methods_for_testing)) 3945 CmdArgs.push_back("-fobjc-disable-direct-methods-for-testing"); 3946 } 3947 3948 static void RenderDiagnosticsOptions(const Driver &D, const ArgList &Args, 3949 ArgStringList &CmdArgs) { 3950 bool CaretDefault = true; 3951 bool ColumnDefault = true; 3952 3953 if (const Arg *A = Args.getLastArg(options::OPT__SLASH_diagnostics_classic, 3954 options::OPT__SLASH_diagnostics_column, 3955 options::OPT__SLASH_diagnostics_caret)) { 3956 switch (A->getOption().getID()) { 3957 case options::OPT__SLASH_diagnostics_caret: 3958 CaretDefault = true; 3959 ColumnDefault = true; 3960 break; 3961 case options::OPT__SLASH_diagnostics_column: 3962 CaretDefault = false; 3963 ColumnDefault = true; 3964 break; 3965 case options::OPT__SLASH_diagnostics_classic: 3966 CaretDefault = false; 3967 ColumnDefault = false; 3968 break; 3969 } 3970 } 3971 3972 // -fcaret-diagnostics is default. 3973 if (!Args.hasFlag(options::OPT_fcaret_diagnostics, 3974 options::OPT_fno_caret_diagnostics, CaretDefault)) 3975 CmdArgs.push_back("-fno-caret-diagnostics"); 3976 3977 Args.addOptOutFlag(CmdArgs, options::OPT_fdiagnostics_fixit_info, 3978 options::OPT_fno_diagnostics_fixit_info); 3979 Args.addOptOutFlag(CmdArgs, options::OPT_fdiagnostics_show_option, 3980 options::OPT_fno_diagnostics_show_option); 3981 3982 if (const Arg *A = 3983 Args.getLastArg(options::OPT_fdiagnostics_show_category_EQ)) { 3984 CmdArgs.push_back("-fdiagnostics-show-category"); 3985 CmdArgs.push_back(A->getValue()); 3986 } 3987 3988 Args.addOptInFlag(CmdArgs, options::OPT_fdiagnostics_show_hotness, 3989 options::OPT_fno_diagnostics_show_hotness); 3990 3991 if (const Arg *A = 3992 Args.getLastArg(options::OPT_fdiagnostics_hotness_threshold_EQ)) { 3993 std::string Opt = 3994 std::string("-fdiagnostics-hotness-threshold=") + A->getValue(); 3995 CmdArgs.push_back(Args.MakeArgString(Opt)); 3996 } 3997 3998 if (const Arg *A = Args.getLastArg(options::OPT_fdiagnostics_format_EQ)) { 3999 CmdArgs.push_back("-fdiagnostics-format"); 4000 CmdArgs.push_back(A->getValue()); 4001 if (StringRef(A->getValue()) == "sarif" || 4002 StringRef(A->getValue()) == "SARIF") 4003 D.Diag(diag::warn_drv_sarif_format_unstable); 4004 } 4005 4006 if (const Arg *A = Args.getLastArg( 4007 options::OPT_fdiagnostics_show_note_include_stack, 4008 options::OPT_fno_diagnostics_show_note_include_stack)) { 4009 const Option &O = A->getOption(); 4010 if (O.matches(options::OPT_fdiagnostics_show_note_include_stack)) 4011 CmdArgs.push_back("-fdiagnostics-show-note-include-stack"); 4012 else 4013 CmdArgs.push_back("-fno-diagnostics-show-note-include-stack"); 4014 } 4015 4016 // Color diagnostics are parsed by the driver directly from argv and later 4017 // re-parsed to construct this job; claim any possible color diagnostic here 4018 // to avoid warn_drv_unused_argument and diagnose bad 4019 // OPT_fdiagnostics_color_EQ values. 4020 Args.getLastArg(options::OPT_fcolor_diagnostics, 4021 options::OPT_fno_color_diagnostics); 4022 if (const Arg *A = Args.getLastArg(options::OPT_fdiagnostics_color_EQ)) { 4023 StringRef Value(A->getValue()); 4024 if (Value != "always" && Value != "never" && Value != "auto") 4025 D.Diag(diag::err_drv_invalid_argument_to_option) 4026 << Value << A->getOption().getName(); 4027 } 4028 4029 if (D.getDiags().getDiagnosticOptions().ShowColors) 4030 CmdArgs.push_back("-fcolor-diagnostics"); 4031 4032 if (Args.hasArg(options::OPT_fansi_escape_codes)) 4033 CmdArgs.push_back("-fansi-escape-codes"); 4034 4035 Args.addOptOutFlag(CmdArgs, options::OPT_fshow_source_location, 4036 options::OPT_fno_show_source_location); 4037 4038 if (Args.hasArg(options::OPT_fdiagnostics_absolute_paths)) 4039 CmdArgs.push_back("-fdiagnostics-absolute-paths"); 4040 4041 if (!Args.hasFlag(options::OPT_fshow_column, options::OPT_fno_show_column, 4042 ColumnDefault)) 4043 CmdArgs.push_back("-fno-show-column"); 4044 4045 Args.addOptOutFlag(CmdArgs, options::OPT_fspell_checking, 4046 options::OPT_fno_spell_checking); 4047 } 4048 4049 DwarfFissionKind tools::getDebugFissionKind(const Driver &D, 4050 const ArgList &Args, Arg *&Arg) { 4051 Arg = Args.getLastArg(options::OPT_gsplit_dwarf, options::OPT_gsplit_dwarf_EQ, 4052 options::OPT_gno_split_dwarf); 4053 if (!Arg || Arg->getOption().matches(options::OPT_gno_split_dwarf)) 4054 return DwarfFissionKind::None; 4055 4056 if (Arg->getOption().matches(options::OPT_gsplit_dwarf)) 4057 return DwarfFissionKind::Split; 4058 4059 StringRef Value = Arg->getValue(); 4060 if (Value == "split") 4061 return DwarfFissionKind::Split; 4062 if (Value == "single") 4063 return DwarfFissionKind::Single; 4064 4065 D.Diag(diag::err_drv_unsupported_option_argument) 4066 << Arg->getOption().getName() << Arg->getValue(); 4067 return DwarfFissionKind::None; 4068 } 4069 4070 static void renderDwarfFormat(const Driver &D, const llvm::Triple &T, 4071 const ArgList &Args, ArgStringList &CmdArgs, 4072 unsigned DwarfVersion) { 4073 auto *DwarfFormatArg = 4074 Args.getLastArg(options::OPT_gdwarf64, options::OPT_gdwarf32); 4075 if (!DwarfFormatArg) 4076 return; 4077 4078 if (DwarfFormatArg->getOption().matches(options::OPT_gdwarf64)) { 4079 if (DwarfVersion < 3) 4080 D.Diag(diag::err_drv_argument_only_allowed_with) 4081 << DwarfFormatArg->getAsString(Args) << "DWARFv3 or greater"; 4082 else if (!T.isArch64Bit()) 4083 D.Diag(diag::err_drv_argument_only_allowed_with) 4084 << DwarfFormatArg->getAsString(Args) << "64 bit architecture"; 4085 else if (!T.isOSBinFormatELF()) 4086 D.Diag(diag::err_drv_argument_only_allowed_with) 4087 << DwarfFormatArg->getAsString(Args) << "ELF platforms"; 4088 } 4089 4090 DwarfFormatArg->render(Args, CmdArgs); 4091 } 4092 4093 static void renderDebugOptions(const ToolChain &TC, const Driver &D, 4094 const llvm::Triple &T, const ArgList &Args, 4095 bool EmitCodeView, bool IRInput, 4096 ArgStringList &CmdArgs, 4097 codegenoptions::DebugInfoKind &DebugInfoKind, 4098 DwarfFissionKind &DwarfFission) { 4099 if (Args.hasFlag(options::OPT_fdebug_info_for_profiling, 4100 options::OPT_fno_debug_info_for_profiling, false) && 4101 checkDebugInfoOption( 4102 Args.getLastArg(options::OPT_fdebug_info_for_profiling), Args, D, TC)) 4103 CmdArgs.push_back("-fdebug-info-for-profiling"); 4104 4105 // The 'g' groups options involve a somewhat intricate sequence of decisions 4106 // about what to pass from the driver to the frontend, but by the time they 4107 // reach cc1 they've been factored into three well-defined orthogonal choices: 4108 // * what level of debug info to generate 4109 // * what dwarf version to write 4110 // * what debugger tuning to use 4111 // This avoids having to monkey around further in cc1 other than to disable 4112 // codeview if not running in a Windows environment. Perhaps even that 4113 // decision should be made in the driver as well though. 4114 llvm::DebuggerKind DebuggerTuning = TC.getDefaultDebuggerTuning(); 4115 4116 bool SplitDWARFInlining = 4117 Args.hasFlag(options::OPT_fsplit_dwarf_inlining, 4118 options::OPT_fno_split_dwarf_inlining, false); 4119 4120 // Normally -gsplit-dwarf is only useful with -gN. For IR input, Clang does 4121 // object file generation and no IR generation, -gN should not be needed. So 4122 // allow -gsplit-dwarf with either -gN or IR input. 4123 if (IRInput || Args.hasArg(options::OPT_g_Group)) { 4124 Arg *SplitDWARFArg; 4125 DwarfFission = getDebugFissionKind(D, Args, SplitDWARFArg); 4126 if (DwarfFission != DwarfFissionKind::None && 4127 !checkDebugInfoOption(SplitDWARFArg, Args, D, TC)) { 4128 DwarfFission = DwarfFissionKind::None; 4129 SplitDWARFInlining = false; 4130 } 4131 } 4132 if (const Arg *A = Args.getLastArg(options::OPT_g_Group)) { 4133 DebugInfoKind = codegenoptions::DebugInfoConstructor; 4134 4135 // If the last option explicitly specified a debug-info level, use it. 4136 if (checkDebugInfoOption(A, Args, D, TC) && 4137 A->getOption().matches(options::OPT_gN_Group)) { 4138 DebugInfoKind = DebugLevelToInfoKind(*A); 4139 // For -g0 or -gline-tables-only, drop -gsplit-dwarf. This gets a bit more 4140 // complicated if you've disabled inline info in the skeleton CUs 4141 // (SplitDWARFInlining) - then there's value in composing split-dwarf and 4142 // line-tables-only, so let those compose naturally in that case. 4143 if (DebugInfoKind == codegenoptions::NoDebugInfo || 4144 DebugInfoKind == codegenoptions::DebugDirectivesOnly || 4145 (DebugInfoKind == codegenoptions::DebugLineTablesOnly && 4146 SplitDWARFInlining)) 4147 DwarfFission = DwarfFissionKind::None; 4148 } 4149 } 4150 4151 // If a debugger tuning argument appeared, remember it. 4152 if (const Arg *A = 4153 Args.getLastArg(options::OPT_gTune_Group, options::OPT_ggdbN_Group)) { 4154 if (checkDebugInfoOption(A, Args, D, TC)) { 4155 if (A->getOption().matches(options::OPT_glldb)) 4156 DebuggerTuning = llvm::DebuggerKind::LLDB; 4157 else if (A->getOption().matches(options::OPT_gsce)) 4158 DebuggerTuning = llvm::DebuggerKind::SCE; 4159 else if (A->getOption().matches(options::OPT_gdbx)) 4160 DebuggerTuning = llvm::DebuggerKind::DBX; 4161 else 4162 DebuggerTuning = llvm::DebuggerKind::GDB; 4163 } 4164 } 4165 4166 // If a -gdwarf argument appeared, remember it. 4167 const Arg *GDwarfN = getDwarfNArg(Args); 4168 bool EmitDwarf = false; 4169 if (GDwarfN) { 4170 if (checkDebugInfoOption(GDwarfN, Args, D, TC)) 4171 EmitDwarf = true; 4172 else 4173 GDwarfN = nullptr; 4174 } 4175 4176 if (const Arg *A = Args.getLastArg(options::OPT_gcodeview)) { 4177 if (checkDebugInfoOption(A, Args, D, TC)) 4178 EmitCodeView = true; 4179 } 4180 4181 // If the user asked for debug info but did not explicitly specify -gcodeview 4182 // or -gdwarf, ask the toolchain for the default format. 4183 if (!EmitCodeView && !EmitDwarf && 4184 DebugInfoKind != codegenoptions::NoDebugInfo) { 4185 switch (TC.getDefaultDebugFormat()) { 4186 case codegenoptions::DIF_CodeView: 4187 EmitCodeView = true; 4188 break; 4189 case codegenoptions::DIF_DWARF: 4190 EmitDwarf = true; 4191 break; 4192 } 4193 } 4194 4195 unsigned RequestedDWARFVersion = 0; // DWARF version requested by the user 4196 unsigned EffectiveDWARFVersion = 0; // DWARF version TC can generate. It may 4197 // be lower than what the user wanted. 4198 unsigned DefaultDWARFVersion = ParseDebugDefaultVersion(TC, Args); 4199 if (EmitDwarf) { 4200 // Start with the platform default DWARF version 4201 RequestedDWARFVersion = TC.GetDefaultDwarfVersion(); 4202 assert(RequestedDWARFVersion && 4203 "toolchain default DWARF version must be nonzero"); 4204 4205 // If the user specified a default DWARF version, that takes precedence 4206 // over the platform default. 4207 if (DefaultDWARFVersion) 4208 RequestedDWARFVersion = DefaultDWARFVersion; 4209 4210 // Override with a user-specified DWARF version 4211 if (GDwarfN) 4212 if (auto ExplicitVersion = DwarfVersionNum(GDwarfN->getSpelling())) 4213 RequestedDWARFVersion = ExplicitVersion; 4214 // Clamp effective DWARF version to the max supported by the toolchain. 4215 EffectiveDWARFVersion = 4216 std::min(RequestedDWARFVersion, TC.getMaxDwarfVersion()); 4217 } 4218 4219 // -gline-directives-only supported only for the DWARF debug info. 4220 if (RequestedDWARFVersion == 0 && 4221 DebugInfoKind == codegenoptions::DebugDirectivesOnly) 4222 DebugInfoKind = codegenoptions::NoDebugInfo; 4223 4224 // strict DWARF is set to false by default. But for DBX, we need it to be set 4225 // as true by default. 4226 if (const Arg *A = Args.getLastArg(options::OPT_gstrict_dwarf)) 4227 (void)checkDebugInfoOption(A, Args, D, TC); 4228 if (Args.hasFlag(options::OPT_gstrict_dwarf, options::OPT_gno_strict_dwarf, 4229 DebuggerTuning == llvm::DebuggerKind::DBX)) 4230 CmdArgs.push_back("-gstrict-dwarf"); 4231 4232 // And we handle flag -grecord-gcc-switches later with DWARFDebugFlags. 4233 Args.ClaimAllArgs(options::OPT_g_flags_Group); 4234 4235 // Column info is included by default for everything except SCE and 4236 // CodeView. Clang doesn't track end columns, just starting columns, which, 4237 // in theory, is fine for CodeView (and PDB). In practice, however, the 4238 // Microsoft debuggers don't handle missing end columns well, and the AIX 4239 // debugger DBX also doesn't handle the columns well, so it's better not to 4240 // include any column info. 4241 if (const Arg *A = Args.getLastArg(options::OPT_gcolumn_info)) 4242 (void)checkDebugInfoOption(A, Args, D, TC); 4243 if (!Args.hasFlag(options::OPT_gcolumn_info, options::OPT_gno_column_info, 4244 !EmitCodeView && 4245 (DebuggerTuning != llvm::DebuggerKind::SCE && 4246 DebuggerTuning != llvm::DebuggerKind::DBX))) 4247 CmdArgs.push_back("-gno-column-info"); 4248 4249 // FIXME: Move backend command line options to the module. 4250 // If -gline-tables-only or -gline-directives-only is the last option it wins. 4251 if (const Arg *A = Args.getLastArg(options::OPT_gmodules)) 4252 if (checkDebugInfoOption(A, Args, D, TC)) { 4253 if (DebugInfoKind != codegenoptions::DebugLineTablesOnly && 4254 DebugInfoKind != codegenoptions::DebugDirectivesOnly) { 4255 DebugInfoKind = codegenoptions::DebugInfoConstructor; 4256 CmdArgs.push_back("-dwarf-ext-refs"); 4257 CmdArgs.push_back("-fmodule-format=obj"); 4258 } 4259 } 4260 4261 if (T.isOSBinFormatELF() && SplitDWARFInlining) 4262 CmdArgs.push_back("-fsplit-dwarf-inlining"); 4263 4264 // After we've dealt with all combinations of things that could 4265 // make DebugInfoKind be other than None or DebugLineTablesOnly, 4266 // figure out if we need to "upgrade" it to standalone debug info. 4267 // We parse these two '-f' options whether or not they will be used, 4268 // to claim them even if you wrote "-fstandalone-debug -gline-tables-only" 4269 bool NeedFullDebug = Args.hasFlag( 4270 options::OPT_fstandalone_debug, options::OPT_fno_standalone_debug, 4271 DebuggerTuning == llvm::DebuggerKind::LLDB || 4272 TC.GetDefaultStandaloneDebug()); 4273 if (const Arg *A = Args.getLastArg(options::OPT_fstandalone_debug)) 4274 (void)checkDebugInfoOption(A, Args, D, TC); 4275 4276 if (DebugInfoKind == codegenoptions::LimitedDebugInfo || 4277 DebugInfoKind == codegenoptions::DebugInfoConstructor) { 4278 if (Args.hasFlag(options::OPT_fno_eliminate_unused_debug_types, 4279 options::OPT_feliminate_unused_debug_types, false)) 4280 DebugInfoKind = codegenoptions::UnusedTypeInfo; 4281 else if (NeedFullDebug) 4282 DebugInfoKind = codegenoptions::FullDebugInfo; 4283 } 4284 4285 if (Args.hasFlag(options::OPT_gembed_source, options::OPT_gno_embed_source, 4286 false)) { 4287 // Source embedding is a vendor extension to DWARF v5. By now we have 4288 // checked if a DWARF version was stated explicitly, and have otherwise 4289 // fallen back to the target default, so if this is still not at least 5 4290 // we emit an error. 4291 const Arg *A = Args.getLastArg(options::OPT_gembed_source); 4292 if (RequestedDWARFVersion < 5) 4293 D.Diag(diag::err_drv_argument_only_allowed_with) 4294 << A->getAsString(Args) << "-gdwarf-5"; 4295 else if (EffectiveDWARFVersion < 5) 4296 // The toolchain has reduced allowed dwarf version, so we can't enable 4297 // -gembed-source. 4298 D.Diag(diag::warn_drv_dwarf_version_limited_by_target) 4299 << A->getAsString(Args) << TC.getTripleString() << 5 4300 << EffectiveDWARFVersion; 4301 else if (checkDebugInfoOption(A, Args, D, TC)) 4302 CmdArgs.push_back("-gembed-source"); 4303 } 4304 4305 if (EmitCodeView) { 4306 CmdArgs.push_back("-gcodeview"); 4307 4308 // Emit codeview type hashes if requested. 4309 if (Args.hasFlag(options::OPT_gcodeview_ghash, 4310 options::OPT_gno_codeview_ghash, false)) { 4311 CmdArgs.push_back("-gcodeview-ghash"); 4312 } 4313 } 4314 4315 // Omit inline line tables if requested. 4316 if (Args.hasFlag(options::OPT_gno_inline_line_tables, 4317 options::OPT_ginline_line_tables, false)) { 4318 CmdArgs.push_back("-gno-inline-line-tables"); 4319 } 4320 4321 // When emitting remarks, we need at least debug lines in the output. 4322 if (willEmitRemarks(Args) && 4323 DebugInfoKind <= codegenoptions::DebugDirectivesOnly) 4324 DebugInfoKind = codegenoptions::DebugLineTablesOnly; 4325 4326 // Adjust the debug info kind for the given toolchain. 4327 TC.adjustDebugInfoKind(DebugInfoKind, Args); 4328 4329 RenderDebugEnablingArgs(Args, CmdArgs, DebugInfoKind, EffectiveDWARFVersion, 4330 DebuggerTuning); 4331 4332 // -fdebug-macro turns on macro debug info generation. 4333 if (Args.hasFlag(options::OPT_fdebug_macro, options::OPT_fno_debug_macro, 4334 false)) 4335 if (checkDebugInfoOption(Args.getLastArg(options::OPT_fdebug_macro), Args, 4336 D, TC)) 4337 CmdArgs.push_back("-debug-info-macro"); 4338 4339 // -ggnu-pubnames turns on gnu style pubnames in the backend. 4340 const auto *PubnamesArg = 4341 Args.getLastArg(options::OPT_ggnu_pubnames, options::OPT_gno_gnu_pubnames, 4342 options::OPT_gpubnames, options::OPT_gno_pubnames); 4343 if (DwarfFission != DwarfFissionKind::None || 4344 (PubnamesArg && checkDebugInfoOption(PubnamesArg, Args, D, TC))) 4345 if (!PubnamesArg || 4346 (!PubnamesArg->getOption().matches(options::OPT_gno_gnu_pubnames) && 4347 !PubnamesArg->getOption().matches(options::OPT_gno_pubnames))) 4348 CmdArgs.push_back(PubnamesArg && PubnamesArg->getOption().matches( 4349 options::OPT_gpubnames) 4350 ? "-gpubnames" 4351 : "-ggnu-pubnames"); 4352 const auto *SimpleTemplateNamesArg = 4353 Args.getLastArg(options::OPT_gsimple_template_names, 4354 options::OPT_gno_simple_template_names); 4355 bool ForwardTemplateParams = DebuggerTuning == llvm::DebuggerKind::SCE; 4356 if (SimpleTemplateNamesArg && 4357 checkDebugInfoOption(SimpleTemplateNamesArg, Args, D, TC)) { 4358 const auto &Opt = SimpleTemplateNamesArg->getOption(); 4359 if (Opt.matches(options::OPT_gsimple_template_names)) { 4360 ForwardTemplateParams = true; 4361 CmdArgs.push_back("-gsimple-template-names=simple"); 4362 } 4363 } 4364 4365 if (Args.hasFlag(options::OPT_fdebug_ranges_base_address, 4366 options::OPT_fno_debug_ranges_base_address, false)) { 4367 CmdArgs.push_back("-fdebug-ranges-base-address"); 4368 } 4369 4370 // -gdwarf-aranges turns on the emission of the aranges section in the 4371 // backend. 4372 // Always enabled for SCE tuning. 4373 bool NeedAranges = DebuggerTuning == llvm::DebuggerKind::SCE; 4374 if (const Arg *A = Args.getLastArg(options::OPT_gdwarf_aranges)) 4375 NeedAranges = checkDebugInfoOption(A, Args, D, TC) || NeedAranges; 4376 if (NeedAranges) { 4377 CmdArgs.push_back("-mllvm"); 4378 CmdArgs.push_back("-generate-arange-section"); 4379 } 4380 4381 if (Args.hasFlag(options::OPT_fforce_dwarf_frame, 4382 options::OPT_fno_force_dwarf_frame, false)) 4383 CmdArgs.push_back("-fforce-dwarf-frame"); 4384 4385 if (Args.hasFlag(options::OPT_fdebug_types_section, 4386 options::OPT_fno_debug_types_section, false)) { 4387 if (!(T.isOSBinFormatELF() || T.isOSBinFormatWasm())) { 4388 D.Diag(diag::err_drv_unsupported_opt_for_target) 4389 << Args.getLastArg(options::OPT_fdebug_types_section) 4390 ->getAsString(Args) 4391 << T.getTriple(); 4392 } else if (checkDebugInfoOption( 4393 Args.getLastArg(options::OPT_fdebug_types_section), Args, D, 4394 TC)) { 4395 CmdArgs.push_back("-mllvm"); 4396 CmdArgs.push_back("-generate-type-units"); 4397 } 4398 } 4399 4400 // To avoid join/split of directory+filename, the integrated assembler prefers 4401 // the directory form of .file on all DWARF versions. GNU as doesn't allow the 4402 // form before DWARF v5. 4403 if (!Args.hasFlag(options::OPT_fdwarf_directory_asm, 4404 options::OPT_fno_dwarf_directory_asm, 4405 TC.useIntegratedAs() || EffectiveDWARFVersion >= 5)) 4406 CmdArgs.push_back("-fno-dwarf-directory-asm"); 4407 4408 // Decide how to render forward declarations of template instantiations. 4409 // SCE wants full descriptions, others just get them in the name. 4410 if (ForwardTemplateParams) 4411 CmdArgs.push_back("-debug-forward-template-params"); 4412 4413 // Do we need to explicitly import anonymous namespaces into the parent 4414 // scope? 4415 if (DebuggerTuning == llvm::DebuggerKind::SCE) 4416 CmdArgs.push_back("-dwarf-explicit-import"); 4417 4418 renderDwarfFormat(D, T, Args, CmdArgs, EffectiveDWARFVersion); 4419 RenderDebugInfoCompressionArgs(Args, CmdArgs, D, TC); 4420 } 4421 4422 void Clang::ConstructJob(Compilation &C, const JobAction &JA, 4423 const InputInfo &Output, const InputInfoList &Inputs, 4424 const ArgList &Args, const char *LinkingOutput) const { 4425 const auto &TC = getToolChain(); 4426 const llvm::Triple &RawTriple = TC.getTriple(); 4427 const llvm::Triple &Triple = TC.getEffectiveTriple(); 4428 const std::string &TripleStr = Triple.getTriple(); 4429 4430 bool KernelOrKext = 4431 Args.hasArg(options::OPT_mkernel, options::OPT_fapple_kext); 4432 const Driver &D = TC.getDriver(); 4433 ArgStringList CmdArgs; 4434 4435 assert(Inputs.size() >= 1 && "Must have at least one input."); 4436 // CUDA/HIP compilation may have multiple inputs (source file + results of 4437 // device-side compilations). OpenMP device jobs also take the host IR as a 4438 // second input. Module precompilation accepts a list of header files to 4439 // include as part of the module. API extraction accepts a list of header 4440 // files whose API information is emitted in the output. All other jobs are 4441 // expected to have exactly one input. 4442 bool IsCuda = JA.isOffloading(Action::OFK_Cuda); 4443 bool IsCudaDevice = JA.isDeviceOffloading(Action::OFK_Cuda); 4444 bool IsHIP = JA.isOffloading(Action::OFK_HIP); 4445 bool IsHIPDevice = JA.isDeviceOffloading(Action::OFK_HIP); 4446 bool IsOpenMPDevice = JA.isDeviceOffloading(Action::OFK_OpenMP); 4447 bool IsHeaderModulePrecompile = isa<HeaderModulePrecompileJobAction>(JA); 4448 bool IsExtractAPI = isa<ExtractAPIJobAction>(JA); 4449 bool IsDeviceOffloadAction = !(JA.isDeviceOffloading(Action::OFK_None) || 4450 JA.isDeviceOffloading(Action::OFK_Host)); 4451 bool IsHostOffloadingAction = 4452 (JA.isHostOffloading(Action::OFK_OpenMP) && 4453 Args.hasFlag(options::OPT_fopenmp_new_driver, 4454 options::OPT_no_offload_new_driver, true)) || 4455 (JA.isHostOffloading(C.getActiveOffloadKinds()) && 4456 Args.hasFlag(options::OPT_offload_new_driver, 4457 options::OPT_no_offload_new_driver, false)); 4458 4459 bool IsRDCMode = 4460 Args.hasFlag(options::OPT_fgpu_rdc, options::OPT_fno_gpu_rdc, false); 4461 bool IsUsingLTO = D.isUsingLTO(IsDeviceOffloadAction); 4462 auto LTOMode = D.getLTOMode(IsDeviceOffloadAction); 4463 4464 // A header module compilation doesn't have a main input file, so invent a 4465 // fake one as a placeholder. 4466 const char *ModuleName = [&] { 4467 auto *ModuleNameArg = Args.getLastArg(options::OPT_fmodule_name_EQ); 4468 return ModuleNameArg ? ModuleNameArg->getValue() : ""; 4469 }(); 4470 InputInfo HeaderModuleInput(Inputs[0].getType(), ModuleName, ModuleName); 4471 4472 // Extract API doesn't have a main input file, so invent a fake one as a 4473 // placeholder. 4474 InputInfo ExtractAPIPlaceholderInput(Inputs[0].getType(), "extract-api", 4475 "extract-api"); 4476 4477 const InputInfo &Input = [&]() -> const InputInfo & { 4478 if (IsHeaderModulePrecompile) 4479 return HeaderModuleInput; 4480 if (IsExtractAPI) 4481 return ExtractAPIPlaceholderInput; 4482 return Inputs[0]; 4483 }(); 4484 4485 InputInfoList ModuleHeaderInputs; 4486 InputInfoList ExtractAPIInputs; 4487 InputInfoList HostOffloadingInputs; 4488 const InputInfo *CudaDeviceInput = nullptr; 4489 const InputInfo *OpenMPDeviceInput = nullptr; 4490 for (const InputInfo &I : Inputs) { 4491 if (&I == &Input) { 4492 // This is the primary input. 4493 } else if (IsHeaderModulePrecompile && 4494 types::getPrecompiledType(I.getType()) == types::TY_PCH) { 4495 types::ID Expected = HeaderModuleInput.getType(); 4496 if (I.getType() != Expected) { 4497 D.Diag(diag::err_drv_module_header_wrong_kind) 4498 << I.getFilename() << types::getTypeName(I.getType()) 4499 << types::getTypeName(Expected); 4500 } 4501 ModuleHeaderInputs.push_back(I); 4502 } else if (IsExtractAPI) { 4503 auto ExpectedInputType = ExtractAPIPlaceholderInput.getType(); 4504 if (I.getType() != ExpectedInputType) { 4505 D.Diag(diag::err_drv_extract_api_wrong_kind) 4506 << I.getFilename() << types::getTypeName(I.getType()) 4507 << types::getTypeName(ExpectedInputType); 4508 } 4509 ExtractAPIInputs.push_back(I); 4510 } else if (IsHostOffloadingAction) { 4511 HostOffloadingInputs.push_back(I); 4512 } else if ((IsCuda || IsHIP) && !CudaDeviceInput) { 4513 CudaDeviceInput = &I; 4514 } else if (IsOpenMPDevice && !OpenMPDeviceInput) { 4515 OpenMPDeviceInput = &I; 4516 } else { 4517 llvm_unreachable("unexpectedly given multiple inputs"); 4518 } 4519 } 4520 4521 const llvm::Triple *AuxTriple = 4522 (IsCuda || IsHIP) ? TC.getAuxTriple() : nullptr; 4523 bool IsWindowsMSVC = RawTriple.isWindowsMSVCEnvironment(); 4524 bool IsIAMCU = RawTriple.isOSIAMCU(); 4525 4526 // Adjust IsWindowsXYZ for CUDA/HIP compilations. Even when compiling in 4527 // device mode (i.e., getToolchain().getTriple() is NVPTX/AMDGCN, not 4528 // Windows), we need to pass Windows-specific flags to cc1. 4529 if (IsCuda || IsHIP) 4530 IsWindowsMSVC |= AuxTriple && AuxTriple->isWindowsMSVCEnvironment(); 4531 4532 // C++ is not supported for IAMCU. 4533 if (IsIAMCU && types::isCXX(Input.getType())) 4534 D.Diag(diag::err_drv_clang_unsupported) << "C++ for IAMCU"; 4535 4536 // Invoke ourselves in -cc1 mode. 4537 // 4538 // FIXME: Implement custom jobs for internal actions. 4539 CmdArgs.push_back("-cc1"); 4540 4541 // Add the "effective" target triple. 4542 CmdArgs.push_back("-triple"); 4543 CmdArgs.push_back(Args.MakeArgString(TripleStr)); 4544 4545 if (const Arg *MJ = Args.getLastArg(options::OPT_MJ)) { 4546 DumpCompilationDatabase(C, MJ->getValue(), TripleStr, Output, Input, Args); 4547 Args.ClaimAllArgs(options::OPT_MJ); 4548 } else if (const Arg *GenCDBFragment = 4549 Args.getLastArg(options::OPT_gen_cdb_fragment_path)) { 4550 DumpCompilationDatabaseFragmentToDir(GenCDBFragment->getValue(), C, 4551 TripleStr, Output, Input, Args); 4552 Args.ClaimAllArgs(options::OPT_gen_cdb_fragment_path); 4553 } 4554 4555 if (IsCuda || IsHIP) { 4556 // We have to pass the triple of the host if compiling for a CUDA/HIP device 4557 // and vice-versa. 4558 std::string NormalizedTriple; 4559 if (JA.isDeviceOffloading(Action::OFK_Cuda) || 4560 JA.isDeviceOffloading(Action::OFK_HIP)) 4561 NormalizedTriple = C.getSingleOffloadToolChain<Action::OFK_Host>() 4562 ->getTriple() 4563 .normalize(); 4564 else { 4565 // Host-side compilation. 4566 NormalizedTriple = 4567 (IsCuda ? C.getSingleOffloadToolChain<Action::OFK_Cuda>() 4568 : C.getSingleOffloadToolChain<Action::OFK_HIP>()) 4569 ->getTriple() 4570 .normalize(); 4571 if (IsCuda) { 4572 // We need to figure out which CUDA version we're compiling for, as that 4573 // determines how we load and launch GPU kernels. 4574 auto *CTC = static_cast<const toolchains::CudaToolChain *>( 4575 C.getSingleOffloadToolChain<Action::OFK_Cuda>()); 4576 assert(CTC && "Expected valid CUDA Toolchain."); 4577 if (CTC && CTC->CudaInstallation.version() != CudaVersion::UNKNOWN) 4578 CmdArgs.push_back(Args.MakeArgString( 4579 Twine("-target-sdk-version=") + 4580 CudaVersionToString(CTC->CudaInstallation.version()))); 4581 } 4582 } 4583 CmdArgs.push_back("-aux-triple"); 4584 CmdArgs.push_back(Args.MakeArgString(NormalizedTriple)); 4585 } 4586 4587 if (Args.hasFlag(options::OPT_fsycl, options::OPT_fno_sycl, false)) { 4588 CmdArgs.push_back("-fsycl-is-device"); 4589 4590 if (Arg *A = Args.getLastArg(options::OPT_sycl_std_EQ)) { 4591 A->render(Args, CmdArgs); 4592 } else { 4593 // Ensure the default version in SYCL mode is 2020. 4594 CmdArgs.push_back("-sycl-std=2020"); 4595 } 4596 } 4597 4598 if (IsOpenMPDevice) { 4599 // We have to pass the triple of the host if compiling for an OpenMP device. 4600 std::string NormalizedTriple = 4601 C.getSingleOffloadToolChain<Action::OFK_Host>() 4602 ->getTriple() 4603 .normalize(); 4604 CmdArgs.push_back("-aux-triple"); 4605 CmdArgs.push_back(Args.MakeArgString(NormalizedTriple)); 4606 } 4607 4608 if (Triple.isOSWindows() && (Triple.getArch() == llvm::Triple::arm || 4609 Triple.getArch() == llvm::Triple::thumb)) { 4610 unsigned Offset = Triple.getArch() == llvm::Triple::arm ? 4 : 6; 4611 unsigned Version = 0; 4612 bool Failure = 4613 Triple.getArchName().substr(Offset).consumeInteger(10, Version); 4614 if (Failure || Version < 7) 4615 D.Diag(diag::err_target_unsupported_arch) << Triple.getArchName() 4616 << TripleStr; 4617 } 4618 4619 // Push all default warning arguments that are specific to 4620 // the given target. These come before user provided warning options 4621 // are provided. 4622 TC.addClangWarningOptions(CmdArgs); 4623 4624 // FIXME: Subclass ToolChain for SPIR and move this to addClangWarningOptions. 4625 if (Triple.isSPIR() || Triple.isSPIRV()) { 4626 CmdArgs.push_back("-Wspir-compat"); 4627 // SPIR-V support still needs pointer types in some cases as recovering 4628 // type from pointer uses is not always possible e.g. for extern functions 4629 // (see PR56660). 4630 CmdArgs.push_back("-no-opaque-pointers"); 4631 } 4632 4633 // Select the appropriate action. 4634 RewriteKind rewriteKind = RK_None; 4635 4636 // If CollectArgsForIntegratedAssembler() isn't called below, claim the args 4637 // it claims when not running an assembler. Otherwise, clang would emit 4638 // "argument unused" warnings for assembler flags when e.g. adding "-E" to 4639 // flags while debugging something. That'd be somewhat inconvenient, and it's 4640 // also inconsistent with most other flags -- we don't warn on 4641 // -ffunction-sections not being used in -E mode either for example, even 4642 // though it's not really used either. 4643 if (!isa<AssembleJobAction>(JA)) { 4644 // The args claimed here should match the args used in 4645 // CollectArgsForIntegratedAssembler(). 4646 if (TC.useIntegratedAs()) { 4647 Args.ClaimAllArgs(options::OPT_mrelax_all); 4648 Args.ClaimAllArgs(options::OPT_mno_relax_all); 4649 Args.ClaimAllArgs(options::OPT_mincremental_linker_compatible); 4650 Args.ClaimAllArgs(options::OPT_mno_incremental_linker_compatible); 4651 switch (C.getDefaultToolChain().getArch()) { 4652 case llvm::Triple::arm: 4653 case llvm::Triple::armeb: 4654 case llvm::Triple::thumb: 4655 case llvm::Triple::thumbeb: 4656 Args.ClaimAllArgs(options::OPT_mimplicit_it_EQ); 4657 break; 4658 default: 4659 break; 4660 } 4661 } 4662 Args.ClaimAllArgs(options::OPT_Wa_COMMA); 4663 Args.ClaimAllArgs(options::OPT_Xassembler); 4664 Args.ClaimAllArgs(options::OPT_femit_dwarf_unwind_EQ); 4665 } 4666 4667 if (isa<AnalyzeJobAction>(JA)) { 4668 assert(JA.getType() == types::TY_Plist && "Invalid output type."); 4669 CmdArgs.push_back("-analyze"); 4670 } else if (isa<MigrateJobAction>(JA)) { 4671 CmdArgs.push_back("-migrate"); 4672 } else if (isa<PreprocessJobAction>(JA)) { 4673 if (Output.getType() == types::TY_Dependencies) 4674 CmdArgs.push_back("-Eonly"); 4675 else { 4676 CmdArgs.push_back("-E"); 4677 if (Args.hasArg(options::OPT_rewrite_objc) && 4678 !Args.hasArg(options::OPT_g_Group)) 4679 CmdArgs.push_back("-P"); 4680 else if (JA.getType() == types::TY_PP_CXXHeaderUnit) 4681 CmdArgs.push_back("-fdirectives-only"); 4682 } 4683 } else if (isa<AssembleJobAction>(JA)) { 4684 CmdArgs.push_back("-emit-obj"); 4685 4686 CollectArgsForIntegratedAssembler(C, Args, CmdArgs, D); 4687 4688 // Also ignore explicit -force_cpusubtype_ALL option. 4689 (void)Args.hasArg(options::OPT_force__cpusubtype__ALL); 4690 } else if (isa<PrecompileJobAction>(JA)) { 4691 if (JA.getType() == types::TY_Nothing) 4692 CmdArgs.push_back("-fsyntax-only"); 4693 else if (JA.getType() == types::TY_ModuleFile) 4694 CmdArgs.push_back(IsHeaderModulePrecompile 4695 ? "-emit-header-module" 4696 : "-emit-module-interface"); 4697 else if (JA.getType() == types::TY_HeaderUnit) 4698 CmdArgs.push_back("-emit-header-unit"); 4699 else 4700 CmdArgs.push_back("-emit-pch"); 4701 } else if (isa<VerifyPCHJobAction>(JA)) { 4702 CmdArgs.push_back("-verify-pch"); 4703 } else if (isa<ExtractAPIJobAction>(JA)) { 4704 assert(JA.getType() == types::TY_API_INFO && 4705 "Extract API actions must generate a API information."); 4706 CmdArgs.push_back("-extract-api"); 4707 if (Arg *ProductNameArg = Args.getLastArg(options::OPT_product_name_EQ)) 4708 ProductNameArg->render(Args, CmdArgs); 4709 } else { 4710 assert((isa<CompileJobAction>(JA) || isa<BackendJobAction>(JA)) && 4711 "Invalid action for clang tool."); 4712 if (JA.getType() == types::TY_Nothing) { 4713 CmdArgs.push_back("-fsyntax-only"); 4714 } else if (JA.getType() == types::TY_LLVM_IR || 4715 JA.getType() == types::TY_LTO_IR) { 4716 CmdArgs.push_back("-emit-llvm"); 4717 } else if (JA.getType() == types::TY_LLVM_BC || 4718 JA.getType() == types::TY_LTO_BC) { 4719 // Emit textual llvm IR for AMDGPU offloading for -emit-llvm -S 4720 if (Triple.isAMDGCN() && IsOpenMPDevice && Args.hasArg(options::OPT_S) && 4721 Args.hasArg(options::OPT_emit_llvm)) { 4722 CmdArgs.push_back("-emit-llvm"); 4723 } else { 4724 CmdArgs.push_back("-emit-llvm-bc"); 4725 } 4726 } else if (JA.getType() == types::TY_IFS || 4727 JA.getType() == types::TY_IFS_CPP) { 4728 StringRef ArgStr = 4729 Args.hasArg(options::OPT_interface_stub_version_EQ) 4730 ? Args.getLastArgValue(options::OPT_interface_stub_version_EQ) 4731 : "ifs-v1"; 4732 CmdArgs.push_back("-emit-interface-stubs"); 4733 CmdArgs.push_back( 4734 Args.MakeArgString(Twine("-interface-stub-version=") + ArgStr.str())); 4735 } else if (JA.getType() == types::TY_PP_Asm) { 4736 CmdArgs.push_back("-S"); 4737 } else if (JA.getType() == types::TY_AST) { 4738 CmdArgs.push_back("-emit-pch"); 4739 } else if (JA.getType() == types::TY_ModuleFile) { 4740 CmdArgs.push_back("-module-file-info"); 4741 } else if (JA.getType() == types::TY_RewrittenObjC) { 4742 CmdArgs.push_back("-rewrite-objc"); 4743 rewriteKind = RK_NonFragile; 4744 } else if (JA.getType() == types::TY_RewrittenLegacyObjC) { 4745 CmdArgs.push_back("-rewrite-objc"); 4746 rewriteKind = RK_Fragile; 4747 } else { 4748 assert(JA.getType() == types::TY_PP_Asm && "Unexpected output type!"); 4749 } 4750 4751 // Preserve use-list order by default when emitting bitcode, so that 4752 // loading the bitcode up in 'opt' or 'llc' and running passes gives the 4753 // same result as running passes here. For LTO, we don't need to preserve 4754 // the use-list order, since serialization to bitcode is part of the flow. 4755 if (JA.getType() == types::TY_LLVM_BC) 4756 CmdArgs.push_back("-emit-llvm-uselists"); 4757 4758 if (IsUsingLTO) { 4759 // Only AMDGPU supports device-side LTO. 4760 if (IsDeviceOffloadAction && 4761 !Args.hasFlag(options::OPT_fopenmp_new_driver, 4762 options::OPT_no_offload_new_driver, true) && 4763 !Args.hasFlag(options::OPT_offload_new_driver, 4764 options::OPT_no_offload_new_driver, false) && 4765 !Triple.isAMDGPU()) { 4766 D.Diag(diag::err_drv_unsupported_opt_for_target) 4767 << Args.getLastArg(options::OPT_foffload_lto, 4768 options::OPT_foffload_lto_EQ) 4769 ->getAsString(Args) 4770 << Triple.getTriple(); 4771 } else { 4772 assert(LTOMode == LTOK_Full || LTOMode == LTOK_Thin); 4773 CmdArgs.push_back(Args.MakeArgString( 4774 Twine("-flto=") + (LTOMode == LTOK_Thin ? "thin" : "full"))); 4775 CmdArgs.push_back("-flto-unit"); 4776 } 4777 } 4778 } 4779 4780 if (const Arg *A = Args.getLastArg(options::OPT_fthinlto_index_EQ)) { 4781 if (!types::isLLVMIR(Input.getType())) 4782 D.Diag(diag::err_drv_arg_requires_bitcode_input) << A->getAsString(Args); 4783 Args.AddLastArg(CmdArgs, options::OPT_fthinlto_index_EQ); 4784 } 4785 4786 if (Args.getLastArg(options::OPT_fthin_link_bitcode_EQ)) 4787 Args.AddLastArg(CmdArgs, options::OPT_fthin_link_bitcode_EQ); 4788 4789 if (Args.getLastArg(options::OPT_save_temps_EQ)) 4790 Args.AddLastArg(CmdArgs, options::OPT_save_temps_EQ); 4791 4792 auto *MemProfArg = Args.getLastArg(options::OPT_fmemory_profile, 4793 options::OPT_fmemory_profile_EQ, 4794 options::OPT_fno_memory_profile); 4795 if (MemProfArg && 4796 !MemProfArg->getOption().matches(options::OPT_fno_memory_profile)) 4797 MemProfArg->render(Args, CmdArgs); 4798 4799 // Embed-bitcode option. 4800 // Only white-listed flags below are allowed to be embedded. 4801 if (C.getDriver().embedBitcodeInObject() && !IsUsingLTO && 4802 (isa<BackendJobAction>(JA) || isa<AssembleJobAction>(JA))) { 4803 // Add flags implied by -fembed-bitcode. 4804 Args.AddLastArg(CmdArgs, options::OPT_fembed_bitcode_EQ); 4805 // Disable all llvm IR level optimizations. 4806 CmdArgs.push_back("-disable-llvm-passes"); 4807 4808 // Render target options. 4809 TC.addClangTargetOptions(Args, CmdArgs, JA.getOffloadingDeviceKind()); 4810 4811 // reject options that shouldn't be supported in bitcode 4812 // also reject kernel/kext 4813 static const constexpr unsigned kBitcodeOptionIgnorelist[] = { 4814 options::OPT_mkernel, 4815 options::OPT_fapple_kext, 4816 options::OPT_ffunction_sections, 4817 options::OPT_fno_function_sections, 4818 options::OPT_fdata_sections, 4819 options::OPT_fno_data_sections, 4820 options::OPT_fbasic_block_sections_EQ, 4821 options::OPT_funique_internal_linkage_names, 4822 options::OPT_fno_unique_internal_linkage_names, 4823 options::OPT_funique_section_names, 4824 options::OPT_fno_unique_section_names, 4825 options::OPT_funique_basic_block_section_names, 4826 options::OPT_fno_unique_basic_block_section_names, 4827 options::OPT_mrestrict_it, 4828 options::OPT_mno_restrict_it, 4829 options::OPT_mstackrealign, 4830 options::OPT_mno_stackrealign, 4831 options::OPT_mstack_alignment, 4832 options::OPT_mcmodel_EQ, 4833 options::OPT_mlong_calls, 4834 options::OPT_mno_long_calls, 4835 options::OPT_ggnu_pubnames, 4836 options::OPT_gdwarf_aranges, 4837 options::OPT_fdebug_types_section, 4838 options::OPT_fno_debug_types_section, 4839 options::OPT_fdwarf_directory_asm, 4840 options::OPT_fno_dwarf_directory_asm, 4841 options::OPT_mrelax_all, 4842 options::OPT_mno_relax_all, 4843 options::OPT_ftrap_function_EQ, 4844 options::OPT_ffixed_r9, 4845 options::OPT_mfix_cortex_a53_835769, 4846 options::OPT_mno_fix_cortex_a53_835769, 4847 options::OPT_ffixed_x18, 4848 options::OPT_mglobal_merge, 4849 options::OPT_mno_global_merge, 4850 options::OPT_mred_zone, 4851 options::OPT_mno_red_zone, 4852 options::OPT_Wa_COMMA, 4853 options::OPT_Xassembler, 4854 options::OPT_mllvm, 4855 }; 4856 for (const auto &A : Args) 4857 if (llvm::is_contained(kBitcodeOptionIgnorelist, A->getOption().getID())) 4858 D.Diag(diag::err_drv_unsupported_embed_bitcode) << A->getSpelling(); 4859 4860 // Render the CodeGen options that need to be passed. 4861 Args.addOptOutFlag(CmdArgs, options::OPT_foptimize_sibling_calls, 4862 options::OPT_fno_optimize_sibling_calls); 4863 4864 RenderFloatingPointOptions(TC, D, isOptimizationLevelFast(Args), Args, 4865 CmdArgs, JA); 4866 4867 // Render ABI arguments 4868 switch (TC.getArch()) { 4869 default: break; 4870 case llvm::Triple::arm: 4871 case llvm::Triple::armeb: 4872 case llvm::Triple::thumbeb: 4873 RenderARMABI(D, Triple, Args, CmdArgs); 4874 break; 4875 case llvm::Triple::aarch64: 4876 case llvm::Triple::aarch64_32: 4877 case llvm::Triple::aarch64_be: 4878 RenderAArch64ABI(Triple, Args, CmdArgs); 4879 break; 4880 } 4881 4882 // Optimization level for CodeGen. 4883 if (const Arg *A = Args.getLastArg(options::OPT_O_Group)) { 4884 if (A->getOption().matches(options::OPT_O4)) { 4885 CmdArgs.push_back("-O3"); 4886 D.Diag(diag::warn_O4_is_O3); 4887 } else { 4888 A->render(Args, CmdArgs); 4889 } 4890 } 4891 4892 // Input/Output file. 4893 if (Output.getType() == types::TY_Dependencies) { 4894 // Handled with other dependency code. 4895 } else if (Output.isFilename()) { 4896 CmdArgs.push_back("-o"); 4897 CmdArgs.push_back(Output.getFilename()); 4898 } else { 4899 assert(Output.isNothing() && "Input output."); 4900 } 4901 4902 for (const auto &II : Inputs) { 4903 addDashXForInput(Args, II, CmdArgs); 4904 if (II.isFilename()) 4905 CmdArgs.push_back(II.getFilename()); 4906 else 4907 II.getInputArg().renderAsInput(Args, CmdArgs); 4908 } 4909 4910 C.addCommand(std::make_unique<Command>( 4911 JA, *this, ResponseFileSupport::AtFileUTF8(), D.getClangProgramPath(), 4912 CmdArgs, Inputs, Output)); 4913 return; 4914 } 4915 4916 if (C.getDriver().embedBitcodeMarkerOnly() && !IsUsingLTO) 4917 CmdArgs.push_back("-fembed-bitcode=marker"); 4918 4919 // We normally speed up the clang process a bit by skipping destructors at 4920 // exit, but when we're generating diagnostics we can rely on some of the 4921 // cleanup. 4922 if (!C.isForDiagnostics()) 4923 CmdArgs.push_back("-disable-free"); 4924 CmdArgs.push_back("-clear-ast-before-backend"); 4925 4926 #ifdef NDEBUG 4927 const bool IsAssertBuild = false; 4928 #else 4929 const bool IsAssertBuild = true; 4930 #endif 4931 4932 // Disable the verification pass in -asserts builds. 4933 if (!IsAssertBuild) 4934 CmdArgs.push_back("-disable-llvm-verifier"); 4935 4936 // Discard value names in assert builds unless otherwise specified. 4937 if (Args.hasFlag(options::OPT_fdiscard_value_names, 4938 options::OPT_fno_discard_value_names, !IsAssertBuild)) { 4939 if (Args.hasArg(options::OPT_fdiscard_value_names) && 4940 llvm::any_of(Inputs, [](const clang::driver::InputInfo &II) { 4941 return types::isLLVMIR(II.getType()); 4942 })) { 4943 D.Diag(diag::warn_ignoring_fdiscard_for_bitcode); 4944 } 4945 CmdArgs.push_back("-discard-value-names"); 4946 } 4947 4948 // Set the main file name, so that debug info works even with 4949 // -save-temps. 4950 CmdArgs.push_back("-main-file-name"); 4951 CmdArgs.push_back(getBaseInputName(Args, Input)); 4952 4953 // Some flags which affect the language (via preprocessor 4954 // defines). 4955 if (Args.hasArg(options::OPT_static)) 4956 CmdArgs.push_back("-static-define"); 4957 4958 if (Args.hasArg(options::OPT_municode)) 4959 CmdArgs.push_back("-DUNICODE"); 4960 4961 if (isa<AnalyzeJobAction>(JA)) 4962 RenderAnalyzerOptions(Args, CmdArgs, Triple, Input); 4963 4964 if (isa<AnalyzeJobAction>(JA) || 4965 (isa<PreprocessJobAction>(JA) && Args.hasArg(options::OPT__analyze))) 4966 CmdArgs.push_back("-setup-static-analyzer"); 4967 4968 // Enable compatilibily mode to avoid analyzer-config related errors. 4969 // Since we can't access frontend flags through hasArg, let's manually iterate 4970 // through them. 4971 bool FoundAnalyzerConfig = false; 4972 for (auto Arg : Args.filtered(options::OPT_Xclang)) 4973 if (StringRef(Arg->getValue()) == "-analyzer-config") { 4974 FoundAnalyzerConfig = true; 4975 break; 4976 } 4977 if (!FoundAnalyzerConfig) 4978 for (auto Arg : Args.filtered(options::OPT_Xanalyzer)) 4979 if (StringRef(Arg->getValue()) == "-analyzer-config") { 4980 FoundAnalyzerConfig = true; 4981 break; 4982 } 4983 if (FoundAnalyzerConfig) 4984 CmdArgs.push_back("-analyzer-config-compatibility-mode=true"); 4985 4986 CheckCodeGenerationOptions(D, Args); 4987 4988 unsigned FunctionAlignment = ParseFunctionAlignment(TC, Args); 4989 assert(FunctionAlignment <= 31 && "function alignment will be truncated!"); 4990 if (FunctionAlignment) { 4991 CmdArgs.push_back("-function-alignment"); 4992 CmdArgs.push_back(Args.MakeArgString(std::to_string(FunctionAlignment))); 4993 } 4994 4995 // We support -falign-loops=N where N is a power of 2. GCC supports more 4996 // forms. 4997 if (const Arg *A = Args.getLastArg(options::OPT_falign_loops_EQ)) { 4998 unsigned Value = 0; 4999 if (StringRef(A->getValue()).getAsInteger(10, Value) || Value > 65536) 5000 TC.getDriver().Diag(diag::err_drv_invalid_int_value) 5001 << A->getAsString(Args) << A->getValue(); 5002 else if (Value & (Value - 1)) 5003 TC.getDriver().Diag(diag::err_drv_alignment_not_power_of_two) 5004 << A->getAsString(Args) << A->getValue(); 5005 // Treat =0 as unspecified (use the target preference). 5006 if (Value) 5007 CmdArgs.push_back(Args.MakeArgString("-falign-loops=" + 5008 Twine(std::min(Value, 65536u)))); 5009 } 5010 5011 llvm::Reloc::Model RelocationModel; 5012 unsigned PICLevel; 5013 bool IsPIE; 5014 std::tie(RelocationModel, PICLevel, IsPIE) = ParsePICArgs(TC, Args); 5015 5016 bool IsROPI = RelocationModel == llvm::Reloc::ROPI || 5017 RelocationModel == llvm::Reloc::ROPI_RWPI; 5018 bool IsRWPI = RelocationModel == llvm::Reloc::RWPI || 5019 RelocationModel == llvm::Reloc::ROPI_RWPI; 5020 5021 if (Args.hasArg(options::OPT_mcmse) && 5022 !Args.hasArg(options::OPT_fallow_unsupported)) { 5023 if (IsROPI) 5024 D.Diag(diag::err_cmse_pi_are_incompatible) << IsROPI; 5025 if (IsRWPI) 5026 D.Diag(diag::err_cmse_pi_are_incompatible) << !IsRWPI; 5027 } 5028 5029 if (IsROPI && types::isCXX(Input.getType()) && 5030 !Args.hasArg(options::OPT_fallow_unsupported)) 5031 D.Diag(diag::err_drv_ropi_incompatible_with_cxx); 5032 5033 const char *RMName = RelocationModelName(RelocationModel); 5034 if (RMName) { 5035 CmdArgs.push_back("-mrelocation-model"); 5036 CmdArgs.push_back(RMName); 5037 } 5038 if (PICLevel > 0) { 5039 CmdArgs.push_back("-pic-level"); 5040 CmdArgs.push_back(PICLevel == 1 ? "1" : "2"); 5041 if (IsPIE) 5042 CmdArgs.push_back("-pic-is-pie"); 5043 } 5044 5045 if (RelocationModel == llvm::Reloc::ROPI || 5046 RelocationModel == llvm::Reloc::ROPI_RWPI) 5047 CmdArgs.push_back("-fropi"); 5048 if (RelocationModel == llvm::Reloc::RWPI || 5049 RelocationModel == llvm::Reloc::ROPI_RWPI) 5050 CmdArgs.push_back("-frwpi"); 5051 5052 if (Arg *A = Args.getLastArg(options::OPT_meabi)) { 5053 CmdArgs.push_back("-meabi"); 5054 CmdArgs.push_back(A->getValue()); 5055 } 5056 5057 // -fsemantic-interposition is forwarded to CC1: set the 5058 // "SemanticInterposition" metadata to 1 (make some linkages interposable) and 5059 // make default visibility external linkage definitions dso_preemptable. 5060 // 5061 // -fno-semantic-interposition: if the target supports .Lfoo$local local 5062 // aliases (make default visibility external linkage definitions dso_local). 5063 // This is the CC1 default for ELF to match COFF/Mach-O. 5064 // 5065 // Otherwise use Clang's traditional behavior: like 5066 // -fno-semantic-interposition but local aliases are not used. So references 5067 // can be interposed if not optimized out. 5068 if (Triple.isOSBinFormatELF()) { 5069 Arg *A = Args.getLastArg(options::OPT_fsemantic_interposition, 5070 options::OPT_fno_semantic_interposition); 5071 if (RelocationModel != llvm::Reloc::Static && !IsPIE) { 5072 // The supported targets need to call AsmPrinter::getSymbolPreferLocal. 5073 bool SupportsLocalAlias = 5074 Triple.isAArch64() || Triple.isRISCV() || Triple.isX86(); 5075 if (!A) 5076 CmdArgs.push_back("-fhalf-no-semantic-interposition"); 5077 else if (A->getOption().matches(options::OPT_fsemantic_interposition)) 5078 A->render(Args, CmdArgs); 5079 else if (!SupportsLocalAlias) 5080 CmdArgs.push_back("-fhalf-no-semantic-interposition"); 5081 } 5082 } 5083 5084 { 5085 std::string Model; 5086 if (Arg *A = Args.getLastArg(options::OPT_mthread_model)) { 5087 if (!TC.isThreadModelSupported(A->getValue())) 5088 D.Diag(diag::err_drv_invalid_thread_model_for_target) 5089 << A->getValue() << A->getAsString(Args); 5090 Model = A->getValue(); 5091 } else 5092 Model = TC.getThreadModel(); 5093 if (Model != "posix") { 5094 CmdArgs.push_back("-mthread-model"); 5095 CmdArgs.push_back(Args.MakeArgString(Model)); 5096 } 5097 } 5098 5099 Args.AddLastArg(CmdArgs, options::OPT_fveclib); 5100 5101 if (Args.hasFlag(options::OPT_fmerge_all_constants, 5102 options::OPT_fno_merge_all_constants, false)) 5103 CmdArgs.push_back("-fmerge-all-constants"); 5104 5105 if (Args.hasFlag(options::OPT_fno_delete_null_pointer_checks, 5106 options::OPT_fdelete_null_pointer_checks, false)) 5107 CmdArgs.push_back("-fno-delete-null-pointer-checks"); 5108 5109 // LLVM Code Generator Options. 5110 5111 for (const Arg *A : Args.filtered(options::OPT_frewrite_map_file_EQ)) { 5112 StringRef Map = A->getValue(); 5113 if (!llvm::sys::fs::exists(Map)) { 5114 D.Diag(diag::err_drv_no_such_file) << Map; 5115 } else { 5116 A->render(Args, CmdArgs); 5117 A->claim(); 5118 } 5119 } 5120 5121 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ_vec_extabi, 5122 options::OPT_mabi_EQ_vec_default)) { 5123 if (!Triple.isOSAIX()) 5124 D.Diag(diag::err_drv_unsupported_opt_for_target) 5125 << A->getSpelling() << RawTriple.str(); 5126 if (A->getOption().getID() == options::OPT_mabi_EQ_vec_extabi) 5127 CmdArgs.push_back("-mabi=vec-extabi"); 5128 else 5129 CmdArgs.push_back("-mabi=vec-default"); 5130 } 5131 5132 if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ_quadword_atomics)) { 5133 if (!Triple.isOSAIX() || Triple.isPPC32()) 5134 D.Diag(diag::err_drv_unsupported_opt_for_target) 5135 << A->getSpelling() << RawTriple.str(); 5136 CmdArgs.push_back("-mabi=quadword-atomics"); 5137 } 5138 5139 if (Arg *A = Args.getLastArg(options::OPT_mlong_double_128)) { 5140 // Emit the unsupported option error until the Clang's library integration 5141 // support for 128-bit long double is available for AIX. 5142 if (Triple.isOSAIX()) 5143 D.Diag(diag::err_drv_unsupported_opt_for_target) 5144 << A->getSpelling() << RawTriple.str(); 5145 } 5146 5147 if (Arg *A = Args.getLastArg(options::OPT_Wframe_larger_than_EQ)) { 5148 StringRef v = A->getValue(); 5149 // FIXME: Validate the argument here so we don't produce meaningless errors 5150 // about -fwarn-stack-size=. 5151 if (v.empty()) 5152 D.Diag(diag::err_drv_missing_argument) << A->getSpelling() << 1; 5153 else 5154 CmdArgs.push_back(Args.MakeArgString("-fwarn-stack-size=" + v)); 5155 A->claim(); 5156 } 5157 5158 Args.addOptOutFlag(CmdArgs, options::OPT_fjump_tables, 5159 options::OPT_fno_jump_tables); 5160 Args.addOptInFlag(CmdArgs, options::OPT_fprofile_sample_accurate, 5161 options::OPT_fno_profile_sample_accurate); 5162 Args.addOptOutFlag(CmdArgs, options::OPT_fpreserve_as_comments, 5163 options::OPT_fno_preserve_as_comments); 5164 5165 if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) { 5166 CmdArgs.push_back("-mregparm"); 5167 CmdArgs.push_back(A->getValue()); 5168 } 5169 5170 if (Arg *A = Args.getLastArg(options::OPT_maix_struct_return, 5171 options::OPT_msvr4_struct_return)) { 5172 if (!TC.getTriple().isPPC32()) { 5173 D.Diag(diag::err_drv_unsupported_opt_for_target) 5174 << A->getSpelling() << RawTriple.str(); 5175 } else if (A->getOption().matches(options::OPT_maix_struct_return)) { 5176 CmdArgs.push_back("-maix-struct-return"); 5177 } else { 5178 assert(A->getOption().matches(options::OPT_msvr4_struct_return)); 5179 CmdArgs.push_back("-msvr4-struct-return"); 5180 } 5181 } 5182 5183 if (Arg *A = Args.getLastArg(options::OPT_fpcc_struct_return, 5184 options::OPT_freg_struct_return)) { 5185 if (TC.getArch() != llvm::Triple::x86) { 5186 D.Diag(diag::err_drv_unsupported_opt_for_target) 5187 << A->getSpelling() << RawTriple.str(); 5188 } else if (A->getOption().matches(options::OPT_fpcc_struct_return)) { 5189 CmdArgs.push_back("-fpcc-struct-return"); 5190 } else { 5191 assert(A->getOption().matches(options::OPT_freg_struct_return)); 5192 CmdArgs.push_back("-freg-struct-return"); 5193 } 5194 } 5195 5196 if (Args.hasFlag(options::OPT_mrtd, options::OPT_mno_rtd, false)) 5197 CmdArgs.push_back("-fdefault-calling-conv=stdcall"); 5198 5199 if (Args.hasArg(options::OPT_fenable_matrix)) { 5200 // enable-matrix is needed by both the LangOpts and by LLVM. 5201 CmdArgs.push_back("-fenable-matrix"); 5202 CmdArgs.push_back("-mllvm"); 5203 CmdArgs.push_back("-enable-matrix"); 5204 } 5205 5206 CodeGenOptions::FramePointerKind FPKeepKind = 5207 getFramePointerKind(Args, RawTriple); 5208 const char *FPKeepKindStr = nullptr; 5209 switch (FPKeepKind) { 5210 case CodeGenOptions::FramePointerKind::None: 5211 FPKeepKindStr = "-mframe-pointer=none"; 5212 break; 5213 case CodeGenOptions::FramePointerKind::NonLeaf: 5214 FPKeepKindStr = "-mframe-pointer=non-leaf"; 5215 break; 5216 case CodeGenOptions::FramePointerKind::All: 5217 FPKeepKindStr = "-mframe-pointer=all"; 5218 break; 5219 } 5220 assert(FPKeepKindStr && "unknown FramePointerKind"); 5221 CmdArgs.push_back(FPKeepKindStr); 5222 5223 Args.addOptOutFlag(CmdArgs, options::OPT_fzero_initialized_in_bss, 5224 options::OPT_fno_zero_initialized_in_bss); 5225 5226 bool OFastEnabled = isOptimizationLevelFast(Args); 5227 // If -Ofast is the optimization level, then -fstrict-aliasing should be 5228 // enabled. This alias option is being used to simplify the hasFlag logic. 5229 OptSpecifier StrictAliasingAliasOption = 5230 OFastEnabled ? options::OPT_Ofast : options::OPT_fstrict_aliasing; 5231 // We turn strict aliasing off by default if we're in CL mode, since MSVC 5232 // doesn't do any TBAA. 5233 bool TBAAOnByDefault = !D.IsCLMode(); 5234 if (!Args.hasFlag(options::OPT_fstrict_aliasing, StrictAliasingAliasOption, 5235 options::OPT_fno_strict_aliasing, TBAAOnByDefault)) 5236 CmdArgs.push_back("-relaxed-aliasing"); 5237 if (!Args.hasFlag(options::OPT_fstruct_path_tbaa, 5238 options::OPT_fno_struct_path_tbaa, true)) 5239 CmdArgs.push_back("-no-struct-path-tbaa"); 5240 Args.addOptInFlag(CmdArgs, options::OPT_fstrict_enums, 5241 options::OPT_fno_strict_enums); 5242 Args.addOptOutFlag(CmdArgs, options::OPT_fstrict_return, 5243 options::OPT_fno_strict_return); 5244 Args.addOptInFlag(CmdArgs, options::OPT_fallow_editor_placeholders, 5245 options::OPT_fno_allow_editor_placeholders); 5246 Args.addOptInFlag(CmdArgs, options::OPT_fstrict_vtable_pointers, 5247 options::OPT_fno_strict_vtable_pointers); 5248 Args.addOptInFlag(CmdArgs, options::OPT_fforce_emit_vtables, 5249 options::OPT_fno_force_emit_vtables); 5250 Args.addOptOutFlag(CmdArgs, options::OPT_foptimize_sibling_calls, 5251 options::OPT_fno_optimize_sibling_calls); 5252 Args.addOptOutFlag(CmdArgs, options::OPT_fescaping_block_tail_calls, 5253 options::OPT_fno_escaping_block_tail_calls); 5254 5255 Args.AddLastArg(CmdArgs, options::OPT_ffine_grained_bitfield_accesses, 5256 options::OPT_fno_fine_grained_bitfield_accesses); 5257 5258 Args.AddLastArg(CmdArgs, options::OPT_fexperimental_relative_cxx_abi_vtables, 5259 options::OPT_fno_experimental_relative_cxx_abi_vtables); 5260 5261 // Handle segmented stacks. 5262 if (Args.hasFlag(options::OPT_fsplit_stack, options::OPT_fno_split_stack, 5263 false)) 5264 CmdArgs.push_back("-fsplit-stack"); 5265 5266 // -fprotect-parens=0 is default. 5267 if (Args.hasFlag(options::OPT_fprotect_parens, 5268 options::OPT_fno_protect_parens, false)) 5269 CmdArgs.push_back("-fprotect-parens"); 5270 5271 RenderFloatingPointOptions(TC, D, OFastEnabled, Args, CmdArgs, JA); 5272 5273 if (Arg *A = Args.getLastArg(options::OPT_fextend_args_EQ)) { 5274 const llvm::Triple::ArchType Arch = TC.getArch(); 5275 if (Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64) { 5276 StringRef V = A->getValue(); 5277 if (V == "64") 5278 CmdArgs.push_back("-fextend-arguments=64"); 5279 else if (V != "32") 5280 D.Diag(diag::err_drv_invalid_argument_to_option) 5281 << A->getValue() << A->getOption().getName(); 5282 } else 5283 D.Diag(diag::err_drv_unsupported_opt_for_target) 5284 << A->getOption().getName() << TripleStr; 5285 } 5286 5287 if (Arg *A = Args.getLastArg(options::OPT_mdouble_EQ)) { 5288 if (TC.getArch() == llvm::Triple::avr) 5289 A->render(Args, CmdArgs); 5290 else 5291 D.Diag(diag::err_drv_unsupported_opt_for_target) 5292 << A->getAsString(Args) << TripleStr; 5293 } 5294 5295 if (Arg *A = Args.getLastArg(options::OPT_LongDouble_Group)) { 5296 if (TC.getTriple().isX86()) 5297 A->render(Args, CmdArgs); 5298 else if (TC.getTriple().isPPC() && 5299 (A->getOption().getID() != options::OPT_mlong_double_80)) 5300 A->render(Args, CmdArgs); 5301 else 5302 D.Diag(diag::err_drv_unsupported_opt_for_target) 5303 << A->getAsString(Args) << TripleStr; 5304 } 5305 5306 // Decide whether to use verbose asm. Verbose assembly is the default on 5307 // toolchains which have the integrated assembler on by default. 5308 bool IsIntegratedAssemblerDefault = TC.IsIntegratedAssemblerDefault(); 5309 if (!Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm, 5310 IsIntegratedAssemblerDefault)) 5311 CmdArgs.push_back("-fno-verbose-asm"); 5312 5313 // Parse 'none' or '$major.$minor'. Disallow -fbinutils-version=0 because we 5314 // use that to indicate the MC default in the backend. 5315 if (Arg *A = Args.getLastArg(options::OPT_fbinutils_version_EQ)) { 5316 StringRef V = A->getValue(); 5317 unsigned Num; 5318 if (V == "none") 5319 A->render(Args, CmdArgs); 5320 else if (!V.consumeInteger(10, Num) && Num > 0 && 5321 (V.empty() || (V.consume_front(".") && 5322 !V.consumeInteger(10, Num) && V.empty()))) 5323 A->render(Args, CmdArgs); 5324 else 5325 D.Diag(diag::err_drv_invalid_argument_to_option) 5326 << A->getValue() << A->getOption().getName(); 5327 } 5328 5329 // If toolchain choose to use MCAsmParser for inline asm don't pass the 5330 // option to disable integrated-as explictly. 5331 if (!TC.useIntegratedAs() && !TC.parseInlineAsmUsingAsmParser()) 5332 CmdArgs.push_back("-no-integrated-as"); 5333 5334 if (Args.hasArg(options::OPT_fdebug_pass_structure)) { 5335 CmdArgs.push_back("-mdebug-pass"); 5336 CmdArgs.push_back("Structure"); 5337 } 5338 if (Args.hasArg(options::OPT_fdebug_pass_arguments)) { 5339 CmdArgs.push_back("-mdebug-pass"); 5340 CmdArgs.push_back("Arguments"); 5341 } 5342 5343 // Enable -mconstructor-aliases except on darwin, where we have to work around 5344 // a linker bug (see <rdar://problem/7651567>), and CUDA device code, where 5345 // aliases aren't supported. 5346 if (!RawTriple.isOSDarwin() && !RawTriple.isNVPTX()) 5347 CmdArgs.push_back("-mconstructor-aliases"); 5348 5349 // Darwin's kernel doesn't support guard variables; just die if we 5350 // try to use them. 5351 if (KernelOrKext && RawTriple.isOSDarwin()) 5352 CmdArgs.push_back("-fforbid-guard-variables"); 5353 5354 if (Args.hasFlag(options::OPT_mms_bitfields, options::OPT_mno_ms_bitfields, 5355 Triple.isWindowsGNUEnvironment())) { 5356 CmdArgs.push_back("-mms-bitfields"); 5357 } 5358 5359 // Non-PIC code defaults to -fdirect-access-external-data while PIC code 5360 // defaults to -fno-direct-access-external-data. Pass the option if different 5361 // from the default. 5362 if (Arg *A = Args.getLastArg(options::OPT_fdirect_access_external_data, 5363 options::OPT_fno_direct_access_external_data)) 5364 if (A->getOption().matches(options::OPT_fdirect_access_external_data) != 5365 (PICLevel == 0)) 5366 A->render(Args, CmdArgs); 5367 5368 if (Args.hasFlag(options::OPT_fno_plt, options::OPT_fplt, false)) { 5369 CmdArgs.push_back("-fno-plt"); 5370 } 5371 5372 // -fhosted is default. 5373 // TODO: Audit uses of KernelOrKext and see where it'd be more appropriate to 5374 // use Freestanding. 5375 bool Freestanding = 5376 Args.hasFlag(options::OPT_ffreestanding, options::OPT_fhosted, false) || 5377 KernelOrKext; 5378 if (Freestanding) 5379 CmdArgs.push_back("-ffreestanding"); 5380 5381 Args.AddLastArg(CmdArgs, options::OPT_fno_knr_functions); 5382 5383 // This is a coarse approximation of what llvm-gcc actually does, both 5384 // -fasynchronous-unwind-tables and -fnon-call-exceptions interact in more 5385 // complicated ways. 5386 auto SanitizeArgs = TC.getSanitizerArgs(Args); 5387 bool AsyncUnwindTables = Args.hasFlag( 5388 options::OPT_fasynchronous_unwind_tables, 5389 options::OPT_fno_asynchronous_unwind_tables, 5390 (TC.IsUnwindTablesDefault(Args) || SanitizeArgs.needsUnwindTables()) && 5391 !Freestanding); 5392 bool UnwindTables = Args.hasFlag(options::OPT_funwind_tables, 5393 options::OPT_fno_unwind_tables, false); 5394 if (AsyncUnwindTables) 5395 CmdArgs.push_back("-funwind-tables=2"); 5396 else if (UnwindTables) 5397 CmdArgs.push_back("-funwind-tables=1"); 5398 5399 // Prepare `-aux-target-cpu` and `-aux-target-feature` unless 5400 // `--gpu-use-aux-triple-only` is specified. 5401 if (!Args.getLastArg(options::OPT_gpu_use_aux_triple_only) && 5402 (IsCudaDevice || IsHIPDevice)) { 5403 const ArgList &HostArgs = 5404 C.getArgsForToolChain(nullptr, StringRef(), Action::OFK_None); 5405 std::string HostCPU = 5406 getCPUName(D, HostArgs, *TC.getAuxTriple(), /*FromAs*/ false); 5407 if (!HostCPU.empty()) { 5408 CmdArgs.push_back("-aux-target-cpu"); 5409 CmdArgs.push_back(Args.MakeArgString(HostCPU)); 5410 } 5411 getTargetFeatures(D, *TC.getAuxTriple(), HostArgs, CmdArgs, 5412 /*ForAS*/ false, /*IsAux*/ true); 5413 } 5414 5415 TC.addClangTargetOptions(Args, CmdArgs, JA.getOffloadingDeviceKind()); 5416 5417 if (Arg *A = Args.getLastArg(options::OPT_mcmodel_EQ)) { 5418 StringRef CM = A->getValue(); 5419 if (CM == "small" || CM == "kernel" || CM == "medium" || CM == "large" || 5420 CM == "tiny") { 5421 if (Triple.isOSAIX() && CM == "medium") 5422 CmdArgs.push_back("-mcmodel=large"); 5423 else 5424 A->render(Args, CmdArgs); 5425 } else { 5426 D.Diag(diag::err_drv_invalid_argument_to_option) 5427 << CM << A->getOption().getName(); 5428 } 5429 } 5430 5431 if (Arg *A = Args.getLastArg(options::OPT_mtls_size_EQ)) { 5432 StringRef Value = A->getValue(); 5433 unsigned TLSSize = 0; 5434 Value.getAsInteger(10, TLSSize); 5435 if (!Triple.isAArch64() || !Triple.isOSBinFormatELF()) 5436 D.Diag(diag::err_drv_unsupported_opt_for_target) 5437 << A->getOption().getName() << TripleStr; 5438 if (TLSSize != 12 && TLSSize != 24 && TLSSize != 32 && TLSSize != 48) 5439 D.Diag(diag::err_drv_invalid_int_value) 5440 << A->getOption().getName() << Value; 5441 Args.AddLastArg(CmdArgs, options::OPT_mtls_size_EQ); 5442 } 5443 5444 // Add the target cpu 5445 std::string CPU = getCPUName(D, Args, Triple, /*FromAs*/ false); 5446 if (!CPU.empty()) { 5447 CmdArgs.push_back("-target-cpu"); 5448 CmdArgs.push_back(Args.MakeArgString(CPU)); 5449 } 5450 5451 RenderTargetOptions(Triple, Args, KernelOrKext, CmdArgs); 5452 5453 // FIXME: For now we want to demote any errors to warnings, when they have 5454 // been raised for asking the wrong question of scalable vectors, such as 5455 // asking for the fixed number of elements. This may happen because code that 5456 // is not yet ported to work for scalable vectors uses the wrong interfaces, 5457 // whereas the behaviour is actually correct. Emitting a warning helps bring 5458 // up scalable vector support in an incremental way. When scalable vector 5459 // support is stable enough, all uses of wrong interfaces should be considered 5460 // as errors, but until then, we can live with a warning being emitted by the 5461 // compiler. This way, Clang can be used to compile code with scalable vectors 5462 // and identify possible issues. 5463 if (isa<AssembleJobAction>(JA) || isa<CompileJobAction>(JA) || 5464 isa<BackendJobAction>(JA)) { 5465 CmdArgs.push_back("-mllvm"); 5466 CmdArgs.push_back("-treat-scalable-fixed-error-as-warning"); 5467 } 5468 5469 // These two are potentially updated by AddClangCLArgs. 5470 codegenoptions::DebugInfoKind DebugInfoKind = codegenoptions::NoDebugInfo; 5471 bool EmitCodeView = false; 5472 5473 // Add clang-cl arguments. 5474 types::ID InputType = Input.getType(); 5475 if (D.IsCLMode()) 5476 AddClangCLArgs(Args, InputType, CmdArgs, &DebugInfoKind, &EmitCodeView); 5477 5478 DwarfFissionKind DwarfFission = DwarfFissionKind::None; 5479 renderDebugOptions(TC, D, RawTriple, Args, EmitCodeView, 5480 types::isLLVMIR(InputType), CmdArgs, DebugInfoKind, 5481 DwarfFission); 5482 5483 // This controls whether or not we perform JustMyCode instrumentation. 5484 if (Args.hasFlag(options::OPT_fjmc, options::OPT_fno_jmc, false)) { 5485 if (TC.getTriple().isOSBinFormatELF()) { 5486 if (DebugInfoKind >= codegenoptions::DebugInfoConstructor) 5487 CmdArgs.push_back("-fjmc"); 5488 else 5489 D.Diag(clang::diag::warn_drv_jmc_requires_debuginfo) << "-fjmc" 5490 << "-g"; 5491 } else { 5492 D.Diag(clang::diag::warn_drv_fjmc_for_elf_only); 5493 } 5494 } 5495 5496 // Add the split debug info name to the command lines here so we 5497 // can propagate it to the backend. 5498 bool SplitDWARF = (DwarfFission != DwarfFissionKind::None) && 5499 (TC.getTriple().isOSBinFormatELF() || 5500 TC.getTriple().isOSBinFormatWasm()) && 5501 (isa<AssembleJobAction>(JA) || isa<CompileJobAction>(JA) || 5502 isa<BackendJobAction>(JA)); 5503 if (SplitDWARF) { 5504 const char *SplitDWARFOut = SplitDebugName(JA, Args, Input, Output); 5505 CmdArgs.push_back("-split-dwarf-file"); 5506 CmdArgs.push_back(SplitDWARFOut); 5507 if (DwarfFission == DwarfFissionKind::Split) { 5508 CmdArgs.push_back("-split-dwarf-output"); 5509 CmdArgs.push_back(SplitDWARFOut); 5510 } 5511 } 5512 5513 // Pass the linker version in use. 5514 if (Arg *A = Args.getLastArg(options::OPT_mlinker_version_EQ)) { 5515 CmdArgs.push_back("-target-linker-version"); 5516 CmdArgs.push_back(A->getValue()); 5517 } 5518 5519 // Explicitly error on some things we know we don't support and can't just 5520 // ignore. 5521 if (!Args.hasArg(options::OPT_fallow_unsupported)) { 5522 Arg *Unsupported; 5523 if (types::isCXX(InputType) && RawTriple.isOSDarwin() && 5524 TC.getArch() == llvm::Triple::x86) { 5525 if ((Unsupported = Args.getLastArg(options::OPT_fapple_kext)) || 5526 (Unsupported = Args.getLastArg(options::OPT_mkernel))) 5527 D.Diag(diag::err_drv_clang_unsupported_opt_cxx_darwin_i386) 5528 << Unsupported->getOption().getName(); 5529 } 5530 // The faltivec option has been superseded by the maltivec option. 5531 if ((Unsupported = Args.getLastArg(options::OPT_faltivec))) 5532 D.Diag(diag::err_drv_clang_unsupported_opt_faltivec) 5533 << Unsupported->getOption().getName() 5534 << "please use -maltivec and include altivec.h explicitly"; 5535 if ((Unsupported = Args.getLastArg(options::OPT_fno_altivec))) 5536 D.Diag(diag::err_drv_clang_unsupported_opt_faltivec) 5537 << Unsupported->getOption().getName() << "please use -mno-altivec"; 5538 } 5539 5540 Args.AddAllArgs(CmdArgs, options::OPT_v); 5541 5542 if (Args.getLastArg(options::OPT_H)) { 5543 CmdArgs.push_back("-H"); 5544 CmdArgs.push_back("-sys-header-deps"); 5545 } 5546 Args.AddAllArgs(CmdArgs, options::OPT_fshow_skipped_includes); 5547 5548 if (D.CCPrintHeaders && !D.CCGenDiagnostics) { 5549 CmdArgs.push_back("-header-include-file"); 5550 CmdArgs.push_back(!D.CCPrintHeadersFilename.empty() 5551 ? D.CCPrintHeadersFilename.c_str() 5552 : "-"); 5553 CmdArgs.push_back("-sys-header-deps"); 5554 } 5555 Args.AddLastArg(CmdArgs, options::OPT_P); 5556 Args.AddLastArg(CmdArgs, options::OPT_print_ivar_layout); 5557 5558 if (D.CCLogDiagnostics && !D.CCGenDiagnostics) { 5559 CmdArgs.push_back("-diagnostic-log-file"); 5560 CmdArgs.push_back(!D.CCLogDiagnosticsFilename.empty() 5561 ? D.CCLogDiagnosticsFilename.c_str() 5562 : "-"); 5563 } 5564 5565 // Give the gen diagnostics more chances to succeed, by avoiding intentional 5566 // crashes. 5567 if (D.CCGenDiagnostics) 5568 CmdArgs.push_back("-disable-pragma-debug-crash"); 5569 5570 // Allow backend to put its diagnostic files in the same place as frontend 5571 // crash diagnostics files. 5572 if (Args.hasArg(options::OPT_fcrash_diagnostics_dir)) { 5573 StringRef Dir = Args.getLastArgValue(options::OPT_fcrash_diagnostics_dir); 5574 CmdArgs.push_back("-mllvm"); 5575 CmdArgs.push_back(Args.MakeArgString("-crash-diagnostics-dir=" + Dir)); 5576 } 5577 5578 bool UseSeparateSections = isUseSeparateSections(Triple); 5579 5580 if (Args.hasFlag(options::OPT_ffunction_sections, 5581 options::OPT_fno_function_sections, UseSeparateSections)) { 5582 CmdArgs.push_back("-ffunction-sections"); 5583 } 5584 5585 if (Arg *A = Args.getLastArg(options::OPT_fbasic_block_sections_EQ)) { 5586 StringRef Val = A->getValue(); 5587 if (Triple.isX86() && Triple.isOSBinFormatELF()) { 5588 if (Val != "all" && Val != "labels" && Val != "none" && 5589 !Val.startswith("list=")) 5590 D.Diag(diag::err_drv_invalid_value) 5591 << A->getAsString(Args) << A->getValue(); 5592 else 5593 A->render(Args, CmdArgs); 5594 } else if (Triple.isNVPTX()) { 5595 // Do not pass the option to the GPU compilation. We still want it enabled 5596 // for the host-side compilation, so seeing it here is not an error. 5597 } else if (Val != "none") { 5598 // =none is allowed everywhere. It's useful for overriding the option 5599 // and is the same as not specifying the option. 5600 D.Diag(diag::err_drv_unsupported_opt_for_target) 5601 << A->getAsString(Args) << TripleStr; 5602 } 5603 } 5604 5605 bool HasDefaultDataSections = Triple.isOSBinFormatXCOFF(); 5606 if (Args.hasFlag(options::OPT_fdata_sections, options::OPT_fno_data_sections, 5607 UseSeparateSections || HasDefaultDataSections)) { 5608 CmdArgs.push_back("-fdata-sections"); 5609 } 5610 5611 Args.addOptOutFlag(CmdArgs, options::OPT_funique_section_names, 5612 options::OPT_fno_unique_section_names); 5613 Args.addOptInFlag(CmdArgs, options::OPT_funique_internal_linkage_names, 5614 options::OPT_fno_unique_internal_linkage_names); 5615 Args.addOptInFlag(CmdArgs, options::OPT_funique_basic_block_section_names, 5616 options::OPT_fno_unique_basic_block_section_names); 5617 5618 if (Arg *A = Args.getLastArg(options::OPT_fsplit_machine_functions, 5619 options::OPT_fno_split_machine_functions)) { 5620 // This codegen pass is only available on x86-elf targets. 5621 if (Triple.isX86() && Triple.isOSBinFormatELF()) { 5622 if (A->getOption().matches(options::OPT_fsplit_machine_functions)) 5623 A->render(Args, CmdArgs); 5624 } else { 5625 D.Diag(diag::err_drv_unsupported_opt_for_target) 5626 << A->getAsString(Args) << TripleStr; 5627 } 5628 } 5629 5630 Args.AddLastArg(CmdArgs, options::OPT_finstrument_functions, 5631 options::OPT_finstrument_functions_after_inlining, 5632 options::OPT_finstrument_function_entry_bare); 5633 5634 // NVPTX/AMDGCN doesn't support PGO or coverage. There's no runtime support 5635 // for sampling, overhead of call arc collection is way too high and there's 5636 // no way to collect the output. 5637 if (!Triple.isNVPTX() && !Triple.isAMDGCN()) 5638 addPGOAndCoverageFlags(TC, C, D, Output, Args, SanitizeArgs, CmdArgs); 5639 5640 Args.AddLastArg(CmdArgs, options::OPT_fclang_abi_compat_EQ); 5641 5642 // Add runtime flag for PS4/PS5 when PGO, coverage, or sanitizers are enabled. 5643 if (RawTriple.isPS() && 5644 !Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) { 5645 PScpu::addProfileRTArgs(TC, Args, CmdArgs); 5646 PScpu::addSanitizerArgs(TC, Args, CmdArgs); 5647 } 5648 5649 // Pass options for controlling the default header search paths. 5650 if (Args.hasArg(options::OPT_nostdinc)) { 5651 CmdArgs.push_back("-nostdsysteminc"); 5652 CmdArgs.push_back("-nobuiltininc"); 5653 } else { 5654 if (Args.hasArg(options::OPT_nostdlibinc)) 5655 CmdArgs.push_back("-nostdsysteminc"); 5656 Args.AddLastArg(CmdArgs, options::OPT_nostdincxx); 5657 Args.AddLastArg(CmdArgs, options::OPT_nobuiltininc); 5658 } 5659 5660 // Pass the path to compiler resource files. 5661 CmdArgs.push_back("-resource-dir"); 5662 CmdArgs.push_back(D.ResourceDir.c_str()); 5663 5664 Args.AddLastArg(CmdArgs, options::OPT_working_directory); 5665 5666 RenderARCMigrateToolOptions(D, Args, CmdArgs); 5667 5668 // Add preprocessing options like -I, -D, etc. if we are using the 5669 // preprocessor. 5670 // 5671 // FIXME: Support -fpreprocessed 5672 if (types::getPreprocessedType(InputType) != types::TY_INVALID) 5673 AddPreprocessingOptions(C, JA, D, Args, CmdArgs, Output, Inputs); 5674 5675 // Don't warn about "clang -c -DPIC -fPIC test.i" because libtool.m4 assumes 5676 // that "The compiler can only warn and ignore the option if not recognized". 5677 // When building with ccache, it will pass -D options to clang even on 5678 // preprocessed inputs and configure concludes that -fPIC is not supported. 5679 Args.ClaimAllArgs(options::OPT_D); 5680 5681 // Manually translate -O4 to -O3; let clang reject others. 5682 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) { 5683 if (A->getOption().matches(options::OPT_O4)) { 5684 CmdArgs.push_back("-O3"); 5685 D.Diag(diag::warn_O4_is_O3); 5686 } else { 5687 A->render(Args, CmdArgs); 5688 } 5689 } 5690 5691 // Warn about ignored options to clang. 5692 for (const Arg *A : 5693 Args.filtered(options::OPT_clang_ignored_gcc_optimization_f_Group)) { 5694 D.Diag(diag::warn_ignored_gcc_optimization) << A->getAsString(Args); 5695 A->claim(); 5696 } 5697 5698 for (const Arg *A : 5699 Args.filtered(options::OPT_clang_ignored_legacy_options_Group)) { 5700 D.Diag(diag::warn_ignored_clang_option) << A->getAsString(Args); 5701 A->claim(); 5702 } 5703 5704 claimNoWarnArgs(Args); 5705 5706 Args.AddAllArgs(CmdArgs, options::OPT_R_Group); 5707 5708 for (const Arg *A : 5709 Args.filtered(options::OPT_W_Group, options::OPT__SLASH_wd)) { 5710 A->claim(); 5711 if (A->getOption().getID() == options::OPT__SLASH_wd) { 5712 unsigned WarningNumber; 5713 if (StringRef(A->getValue()).getAsInteger(10, WarningNumber)) { 5714 D.Diag(diag::err_drv_invalid_int_value) 5715 << A->getAsString(Args) << A->getValue(); 5716 continue; 5717 } 5718 5719 if (auto Group = diagGroupFromCLWarningID(WarningNumber)) { 5720 CmdArgs.push_back(Args.MakeArgString( 5721 "-Wno-" + DiagnosticIDs::getWarningOptionForGroup(*Group))); 5722 } 5723 continue; 5724 } 5725 A->render(Args, CmdArgs); 5726 } 5727 5728 if (Args.hasFlag(options::OPT_pedantic, options::OPT_no_pedantic, false)) 5729 CmdArgs.push_back("-pedantic"); 5730 Args.AddLastArg(CmdArgs, options::OPT_pedantic_errors); 5731 Args.AddLastArg(CmdArgs, options::OPT_w); 5732 5733 // Fixed point flags 5734 if (Args.hasFlag(options::OPT_ffixed_point, options::OPT_fno_fixed_point, 5735 /*Default=*/false)) 5736 Args.AddLastArg(CmdArgs, options::OPT_ffixed_point); 5737 5738 if (Arg *A = Args.getLastArg(options::OPT_fcxx_abi_EQ)) 5739 A->render(Args, CmdArgs); 5740 5741 Args.AddLastArg(CmdArgs, options::OPT_fexperimental_relative_cxx_abi_vtables, 5742 options::OPT_fno_experimental_relative_cxx_abi_vtables); 5743 5744 if (Arg *A = Args.getLastArg(options::OPT_ffuchsia_api_level_EQ)) 5745 A->render(Args, CmdArgs); 5746 5747 // Handle -{std, ansi, trigraphs} -- take the last of -{std, ansi} 5748 // (-ansi is equivalent to -std=c89 or -std=c++98). 5749 // 5750 // If a std is supplied, only add -trigraphs if it follows the 5751 // option. 5752 bool ImplyVCPPCVer = false; 5753 bool ImplyVCPPCXXVer = false; 5754 const Arg *Std = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi); 5755 if (Std) { 5756 if (Std->getOption().matches(options::OPT_ansi)) 5757 if (types::isCXX(InputType)) 5758 CmdArgs.push_back("-std=c++98"); 5759 else 5760 CmdArgs.push_back("-std=c89"); 5761 else 5762 Std->render(Args, CmdArgs); 5763 5764 // If -f(no-)trigraphs appears after the language standard flag, honor it. 5765 if (Arg *A = Args.getLastArg(options::OPT_std_EQ, options::OPT_ansi, 5766 options::OPT_ftrigraphs, 5767 options::OPT_fno_trigraphs)) 5768 if (A != Std) 5769 A->render(Args, CmdArgs); 5770 } else { 5771 // Honor -std-default. 5772 // 5773 // FIXME: Clang doesn't correctly handle -std= when the input language 5774 // doesn't match. For the time being just ignore this for C++ inputs; 5775 // eventually we want to do all the standard defaulting here instead of 5776 // splitting it between the driver and clang -cc1. 5777 if (!types::isCXX(InputType)) { 5778 if (!Args.hasArg(options::OPT__SLASH_std)) { 5779 Args.AddAllArgsTranslated(CmdArgs, options::OPT_std_default_EQ, "-std=", 5780 /*Joined=*/true); 5781 } else 5782 ImplyVCPPCVer = true; 5783 } 5784 else if (IsWindowsMSVC) 5785 ImplyVCPPCXXVer = true; 5786 5787 Args.AddLastArg(CmdArgs, options::OPT_ftrigraphs, 5788 options::OPT_fno_trigraphs); 5789 5790 // HIP headers has minimum C++ standard requirements. Therefore set the 5791 // default language standard. 5792 if (IsHIP) 5793 CmdArgs.push_back(IsWindowsMSVC ? "-std=c++14" : "-std=c++11"); 5794 } 5795 5796 // GCC's behavior for -Wwrite-strings is a bit strange: 5797 // * In C, this "warning flag" changes the types of string literals from 5798 // 'char[N]' to 'const char[N]', and thus triggers an unrelated warning 5799 // for the discarded qualifier. 5800 // * In C++, this is just a normal warning flag. 5801 // 5802 // Implementing this warning correctly in C is hard, so we follow GCC's 5803 // behavior for now. FIXME: Directly diagnose uses of a string literal as 5804 // a non-const char* in C, rather than using this crude hack. 5805 if (!types::isCXX(InputType)) { 5806 // FIXME: This should behave just like a warning flag, and thus should also 5807 // respect -Weverything, -Wno-everything, -Werror=write-strings, and so on. 5808 Arg *WriteStrings = 5809 Args.getLastArg(options::OPT_Wwrite_strings, 5810 options::OPT_Wno_write_strings, options::OPT_w); 5811 if (WriteStrings && 5812 WriteStrings->getOption().matches(options::OPT_Wwrite_strings)) 5813 CmdArgs.push_back("-fconst-strings"); 5814 } 5815 5816 // GCC provides a macro definition '__DEPRECATED' when -Wdeprecated is active 5817 // during C++ compilation, which it is by default. GCC keeps this define even 5818 // in the presence of '-w', match this behavior bug-for-bug. 5819 if (types::isCXX(InputType) && 5820 Args.hasFlag(options::OPT_Wdeprecated, options::OPT_Wno_deprecated, 5821 true)) { 5822 CmdArgs.push_back("-fdeprecated-macro"); 5823 } 5824 5825 // Translate GCC's misnamer '-fasm' arguments to '-fgnu-keywords'. 5826 if (Arg *Asm = Args.getLastArg(options::OPT_fasm, options::OPT_fno_asm)) { 5827 if (Asm->getOption().matches(options::OPT_fasm)) 5828 CmdArgs.push_back("-fgnu-keywords"); 5829 else 5830 CmdArgs.push_back("-fno-gnu-keywords"); 5831 } 5832 5833 if (!ShouldEnableAutolink(Args, TC, JA)) 5834 CmdArgs.push_back("-fno-autolink"); 5835 5836 // Add in -fdebug-compilation-dir if necessary. 5837 const char *DebugCompilationDir = 5838 addDebugCompDirArg(Args, CmdArgs, D.getVFS()); 5839 5840 addDebugPrefixMapArg(D, TC, Args, CmdArgs); 5841 5842 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_depth_, 5843 options::OPT_ftemplate_depth_EQ)) { 5844 CmdArgs.push_back("-ftemplate-depth"); 5845 CmdArgs.push_back(A->getValue()); 5846 } 5847 5848 if (Arg *A = Args.getLastArg(options::OPT_foperator_arrow_depth_EQ)) { 5849 CmdArgs.push_back("-foperator-arrow-depth"); 5850 CmdArgs.push_back(A->getValue()); 5851 } 5852 5853 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_depth_EQ)) { 5854 CmdArgs.push_back("-fconstexpr-depth"); 5855 CmdArgs.push_back(A->getValue()); 5856 } 5857 5858 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_steps_EQ)) { 5859 CmdArgs.push_back("-fconstexpr-steps"); 5860 CmdArgs.push_back(A->getValue()); 5861 } 5862 5863 Args.AddLastArg(CmdArgs, options::OPT_fexperimental_library); 5864 5865 if (Args.hasArg(options::OPT_fexperimental_new_constant_interpreter)) 5866 CmdArgs.push_back("-fexperimental-new-constant-interpreter"); 5867 5868 if (Arg *A = Args.getLastArg(options::OPT_fbracket_depth_EQ)) { 5869 CmdArgs.push_back("-fbracket-depth"); 5870 CmdArgs.push_back(A->getValue()); 5871 } 5872 5873 if (Arg *A = Args.getLastArg(options::OPT_Wlarge_by_value_copy_EQ, 5874 options::OPT_Wlarge_by_value_copy_def)) { 5875 if (A->getNumValues()) { 5876 StringRef bytes = A->getValue(); 5877 CmdArgs.push_back(Args.MakeArgString("-Wlarge-by-value-copy=" + bytes)); 5878 } else 5879 CmdArgs.push_back("-Wlarge-by-value-copy=64"); // default value 5880 } 5881 5882 if (Args.hasArg(options::OPT_relocatable_pch)) 5883 CmdArgs.push_back("-relocatable-pch"); 5884 5885 if (const Arg *A = Args.getLastArg(options::OPT_fcf_runtime_abi_EQ)) { 5886 static const char *kCFABIs[] = { 5887 "standalone", "objc", "swift", "swift-5.0", "swift-4.2", "swift-4.1", 5888 }; 5889 5890 if (!llvm::is_contained(kCFABIs, StringRef(A->getValue()))) 5891 D.Diag(diag::err_drv_invalid_cf_runtime_abi) << A->getValue(); 5892 else 5893 A->render(Args, CmdArgs); 5894 } 5895 5896 if (Arg *A = Args.getLastArg(options::OPT_fconstant_string_class_EQ)) { 5897 CmdArgs.push_back("-fconstant-string-class"); 5898 CmdArgs.push_back(A->getValue()); 5899 } 5900 5901 if (Arg *A = Args.getLastArg(options::OPT_ftabstop_EQ)) { 5902 CmdArgs.push_back("-ftabstop"); 5903 CmdArgs.push_back(A->getValue()); 5904 } 5905 5906 if (Args.hasFlag(options::OPT_fstack_size_section, 5907 options::OPT_fno_stack_size_section, RawTriple.isPS4())) 5908 CmdArgs.push_back("-fstack-size-section"); 5909 5910 if (Args.hasArg(options::OPT_fstack_usage)) { 5911 CmdArgs.push_back("-stack-usage-file"); 5912 5913 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) { 5914 SmallString<128> OutputFilename(OutputOpt->getValue()); 5915 llvm::sys::path::replace_extension(OutputFilename, "su"); 5916 CmdArgs.push_back(Args.MakeArgString(OutputFilename)); 5917 } else 5918 CmdArgs.push_back( 5919 Args.MakeArgString(Twine(getBaseInputStem(Args, Inputs)) + ".su")); 5920 } 5921 5922 CmdArgs.push_back("-ferror-limit"); 5923 if (Arg *A = Args.getLastArg(options::OPT_ferror_limit_EQ)) 5924 CmdArgs.push_back(A->getValue()); 5925 else 5926 CmdArgs.push_back("19"); 5927 5928 if (Arg *A = Args.getLastArg(options::OPT_fmacro_backtrace_limit_EQ)) { 5929 CmdArgs.push_back("-fmacro-backtrace-limit"); 5930 CmdArgs.push_back(A->getValue()); 5931 } 5932 5933 if (Arg *A = Args.getLastArg(options::OPT_ftemplate_backtrace_limit_EQ)) { 5934 CmdArgs.push_back("-ftemplate-backtrace-limit"); 5935 CmdArgs.push_back(A->getValue()); 5936 } 5937 5938 if (Arg *A = Args.getLastArg(options::OPT_fconstexpr_backtrace_limit_EQ)) { 5939 CmdArgs.push_back("-fconstexpr-backtrace-limit"); 5940 CmdArgs.push_back(A->getValue()); 5941 } 5942 5943 if (Arg *A = Args.getLastArg(options::OPT_fspell_checking_limit_EQ)) { 5944 CmdArgs.push_back("-fspell-checking-limit"); 5945 CmdArgs.push_back(A->getValue()); 5946 } 5947 5948 // Pass -fmessage-length=. 5949 unsigned MessageLength = 0; 5950 if (Arg *A = Args.getLastArg(options::OPT_fmessage_length_EQ)) { 5951 StringRef V(A->getValue()); 5952 if (V.getAsInteger(0, MessageLength)) 5953 D.Diag(diag::err_drv_invalid_argument_to_option) 5954 << V << A->getOption().getName(); 5955 } else { 5956 // If -fmessage-length=N was not specified, determine whether this is a 5957 // terminal and, if so, implicitly define -fmessage-length appropriately. 5958 MessageLength = llvm::sys::Process::StandardErrColumns(); 5959 } 5960 if (MessageLength != 0) 5961 CmdArgs.push_back( 5962 Args.MakeArgString("-fmessage-length=" + Twine(MessageLength))); 5963 5964 if (Arg *A = Args.getLastArg(options::OPT_frandomize_layout_seed_EQ)) 5965 CmdArgs.push_back( 5966 Args.MakeArgString("-frandomize-layout-seed=" + Twine(A->getValue(0)))); 5967 5968 if (Arg *A = Args.getLastArg(options::OPT_frandomize_layout_seed_file_EQ)) 5969 CmdArgs.push_back(Args.MakeArgString("-frandomize-layout-seed-file=" + 5970 Twine(A->getValue(0)))); 5971 5972 // -fvisibility= and -fvisibility-ms-compat are of a piece. 5973 if (const Arg *A = Args.getLastArg(options::OPT_fvisibility_EQ, 5974 options::OPT_fvisibility_ms_compat)) { 5975 if (A->getOption().matches(options::OPT_fvisibility_EQ)) { 5976 CmdArgs.push_back("-fvisibility"); 5977 CmdArgs.push_back(A->getValue()); 5978 } else { 5979 assert(A->getOption().matches(options::OPT_fvisibility_ms_compat)); 5980 CmdArgs.push_back("-fvisibility"); 5981 CmdArgs.push_back("hidden"); 5982 CmdArgs.push_back("-ftype-visibility"); 5983 CmdArgs.push_back("default"); 5984 } 5985 } else if (IsOpenMPDevice) { 5986 // When compiling for the OpenMP device we want protected visibility by 5987 // default. This prevents the device from accidenally preempting code on the 5988 // host, makes the system more robust, and improves performance. 5989 CmdArgs.push_back("-fvisibility"); 5990 CmdArgs.push_back("protected"); 5991 } 5992 5993 if (!RawTriple.isPS4()) 5994 if (const Arg *A = 5995 Args.getLastArg(options::OPT_fvisibility_from_dllstorageclass, 5996 options::OPT_fno_visibility_from_dllstorageclass)) { 5997 if (A->getOption().matches( 5998 options::OPT_fvisibility_from_dllstorageclass)) { 5999 CmdArgs.push_back("-fvisibility-from-dllstorageclass"); 6000 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_dllexport_EQ); 6001 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_nodllstorageclass_EQ); 6002 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_externs_dllimport_EQ); 6003 Args.AddLastArg(CmdArgs, 6004 options::OPT_fvisibility_externs_nodllstorageclass_EQ); 6005 } 6006 } 6007 6008 if (const Arg *A = Args.getLastArg(options::OPT_mignore_xcoff_visibility)) { 6009 if (Triple.isOSAIX()) 6010 CmdArgs.push_back("-mignore-xcoff-visibility"); 6011 else 6012 D.Diag(diag::err_drv_unsupported_opt_for_target) 6013 << A->getAsString(Args) << TripleStr; 6014 } 6015 6016 if (const Arg *A = 6017 Args.getLastArg(options::OPT_mdefault_visibility_export_mapping_EQ)) { 6018 if (Triple.isOSAIX()) 6019 A->render(Args, CmdArgs); 6020 else 6021 D.Diag(diag::err_drv_unsupported_opt_for_target) 6022 << A->getAsString(Args) << TripleStr; 6023 } 6024 6025 if (Args.hasFlag(options::OPT_fvisibility_inlines_hidden, 6026 options::OPT_fno_visibility_inlines_hidden, false)) 6027 CmdArgs.push_back("-fvisibility-inlines-hidden"); 6028 6029 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_inlines_hidden_static_local_var, 6030 options::OPT_fno_visibility_inlines_hidden_static_local_var); 6031 Args.AddLastArg(CmdArgs, options::OPT_fvisibility_global_new_delete_hidden); 6032 Args.AddLastArg(CmdArgs, options::OPT_ftlsmodel_EQ); 6033 6034 if (Args.hasFlag(options::OPT_fnew_infallible, 6035 options::OPT_fno_new_infallible, false)) 6036 CmdArgs.push_back("-fnew-infallible"); 6037 6038 if (Args.hasFlag(options::OPT_fno_operator_names, 6039 options::OPT_foperator_names, false)) 6040 CmdArgs.push_back("-fno-operator-names"); 6041 6042 // Forward -f (flag) options which we can pass directly. 6043 Args.AddLastArg(CmdArgs, options::OPT_femit_all_decls); 6044 Args.AddLastArg(CmdArgs, options::OPT_fheinous_gnu_extensions); 6045 Args.AddLastArg(CmdArgs, options::OPT_fdigraphs, options::OPT_fno_digraphs); 6046 Args.AddLastArg(CmdArgs, options::OPT_femulated_tls, 6047 options::OPT_fno_emulated_tls); 6048 Args.AddLastArg(CmdArgs, options::OPT_fzero_call_used_regs_EQ); 6049 6050 if (Arg *A = Args.getLastArg(options::OPT_fzero_call_used_regs_EQ)) { 6051 // FIXME: There's no reason for this to be restricted to X86. The backend 6052 // code needs to be changed to include the appropriate function calls 6053 // automatically. 6054 if (!Triple.isX86() && !Triple.isAArch64()) 6055 D.Diag(diag::err_drv_unsupported_opt_for_target) 6056 << A->getAsString(Args) << TripleStr; 6057 } 6058 6059 // AltiVec-like language extensions aren't relevant for assembling. 6060 if (!isa<PreprocessJobAction>(JA) || Output.getType() != types::TY_PP_Asm) 6061 Args.AddLastArg(CmdArgs, options::OPT_fzvector); 6062 6063 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_show_template_tree); 6064 Args.AddLastArg(CmdArgs, options::OPT_fno_elide_type); 6065 6066 // Forward flags for OpenMP. We don't do this if the current action is an 6067 // device offloading action other than OpenMP. 6068 if (Args.hasFlag(options::OPT_fopenmp, options::OPT_fopenmp_EQ, 6069 options::OPT_fno_openmp, false) && 6070 (JA.isDeviceOffloading(Action::OFK_None) || 6071 JA.isDeviceOffloading(Action::OFK_OpenMP))) { 6072 switch (D.getOpenMPRuntime(Args)) { 6073 case Driver::OMPRT_OMP: 6074 case Driver::OMPRT_IOMP5: 6075 // Clang can generate useful OpenMP code for these two runtime libraries. 6076 CmdArgs.push_back("-fopenmp"); 6077 6078 // If no option regarding the use of TLS in OpenMP codegeneration is 6079 // given, decide a default based on the target. Otherwise rely on the 6080 // options and pass the right information to the frontend. 6081 if (!Args.hasFlag(options::OPT_fopenmp_use_tls, 6082 options::OPT_fnoopenmp_use_tls, /*Default=*/true)) 6083 CmdArgs.push_back("-fnoopenmp-use-tls"); 6084 Args.AddLastArg(CmdArgs, options::OPT_fopenmp_simd, 6085 options::OPT_fno_openmp_simd); 6086 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_enable_irbuilder); 6087 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_version_EQ); 6088 if (!Args.hasFlag(options::OPT_fopenmp_extensions, 6089 options::OPT_fno_openmp_extensions, /*Default=*/true)) 6090 CmdArgs.push_back("-fno-openmp-extensions"); 6091 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_cuda_number_of_sm_EQ); 6092 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_cuda_blocks_per_sm_EQ); 6093 Args.AddAllArgs(CmdArgs, 6094 options::OPT_fopenmp_cuda_teams_reduction_recs_num_EQ); 6095 if (Args.hasFlag(options::OPT_fopenmp_optimistic_collapse, 6096 options::OPT_fno_openmp_optimistic_collapse, 6097 /*Default=*/false)) 6098 CmdArgs.push_back("-fopenmp-optimistic-collapse"); 6099 6100 // When in OpenMP offloading mode with NVPTX target, forward 6101 // cuda-mode flag 6102 if (Args.hasFlag(options::OPT_fopenmp_cuda_mode, 6103 options::OPT_fno_openmp_cuda_mode, /*Default=*/false)) 6104 CmdArgs.push_back("-fopenmp-cuda-mode"); 6105 6106 // When in OpenMP offloading mode, enable debugging on the device. 6107 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_target_debug_EQ); 6108 if (Args.hasFlag(options::OPT_fopenmp_target_debug, 6109 options::OPT_fno_openmp_target_debug, /*Default=*/false)) 6110 CmdArgs.push_back("-fopenmp-target-debug"); 6111 6112 // When in OpenMP offloading mode with NVPTX target, check if full runtime 6113 // is required. 6114 if (Args.hasFlag(options::OPT_fopenmp_cuda_force_full_runtime, 6115 options::OPT_fno_openmp_cuda_force_full_runtime, 6116 /*Default=*/false)) 6117 CmdArgs.push_back("-fopenmp-cuda-force-full-runtime"); 6118 6119 // When in OpenMP offloading mode, forward assumptions information about 6120 // thread and team counts in the device. 6121 if (Args.hasFlag(options::OPT_fopenmp_assume_teams_oversubscription, 6122 options::OPT_fno_openmp_assume_teams_oversubscription, 6123 /*Default=*/false)) 6124 CmdArgs.push_back("-fopenmp-assume-teams-oversubscription"); 6125 if (Args.hasFlag(options::OPT_fopenmp_assume_threads_oversubscription, 6126 options::OPT_fno_openmp_assume_threads_oversubscription, 6127 /*Default=*/false)) 6128 CmdArgs.push_back("-fopenmp-assume-threads-oversubscription"); 6129 if (Args.hasArg(options::OPT_fopenmp_assume_no_thread_state)) 6130 CmdArgs.push_back("-fopenmp-assume-no-thread-state"); 6131 if (Args.hasArg(options::OPT_fopenmp_offload_mandatory)) 6132 CmdArgs.push_back("-fopenmp-offload-mandatory"); 6133 break; 6134 default: 6135 // By default, if Clang doesn't know how to generate useful OpenMP code 6136 // for a specific runtime library, we just don't pass the '-fopenmp' flag 6137 // down to the actual compilation. 6138 // FIXME: It would be better to have a mode which *only* omits IR 6139 // generation based on the OpenMP support so that we get consistent 6140 // semantic analysis, etc. 6141 break; 6142 } 6143 } else { 6144 Args.AddLastArg(CmdArgs, options::OPT_fopenmp_simd, 6145 options::OPT_fno_openmp_simd); 6146 Args.AddAllArgs(CmdArgs, options::OPT_fopenmp_version_EQ); 6147 Args.addOptOutFlag(CmdArgs, options::OPT_fopenmp_extensions, 6148 options::OPT_fno_openmp_extensions); 6149 } 6150 6151 // Forward the new driver to change offloading code generation. 6152 if (Args.hasArg(options::OPT_offload_new_driver)) 6153 CmdArgs.push_back("--offload-new-driver"); 6154 6155 SanitizeArgs.addArgs(TC, Args, CmdArgs, InputType); 6156 6157 const XRayArgs &XRay = TC.getXRayArgs(); 6158 XRay.addArgs(TC, Args, CmdArgs, InputType); 6159 6160 for (const auto &Filename : 6161 Args.getAllArgValues(options::OPT_fprofile_list_EQ)) { 6162 if (D.getVFS().exists(Filename)) 6163 CmdArgs.push_back(Args.MakeArgString("-fprofile-list=" + Filename)); 6164 else 6165 D.Diag(clang::diag::err_drv_no_such_file) << Filename; 6166 } 6167 6168 if (Arg *A = Args.getLastArg(options::OPT_fpatchable_function_entry_EQ)) { 6169 StringRef S0 = A->getValue(), S = S0; 6170 unsigned Size, Offset = 0; 6171 if (!Triple.isAArch64() && !Triple.isRISCV() && !Triple.isX86()) 6172 D.Diag(diag::err_drv_unsupported_opt_for_target) 6173 << A->getAsString(Args) << TripleStr; 6174 else if (S.consumeInteger(10, Size) || 6175 (!S.empty() && (!S.consume_front(",") || 6176 S.consumeInteger(10, Offset) || !S.empty()))) 6177 D.Diag(diag::err_drv_invalid_argument_to_option) 6178 << S0 << A->getOption().getName(); 6179 else if (Size < Offset) 6180 D.Diag(diag::err_drv_unsupported_fpatchable_function_entry_argument); 6181 else { 6182 CmdArgs.push_back(Args.MakeArgString(A->getSpelling() + Twine(Size))); 6183 CmdArgs.push_back(Args.MakeArgString( 6184 "-fpatchable-function-entry-offset=" + Twine(Offset))); 6185 } 6186 } 6187 6188 Args.AddLastArg(CmdArgs, options::OPT_fms_hotpatch); 6189 6190 if (TC.SupportsProfiling()) { 6191 Args.AddLastArg(CmdArgs, options::OPT_pg); 6192 6193 llvm::Triple::ArchType Arch = TC.getArch(); 6194 if (Arg *A = Args.getLastArg(options::OPT_mfentry)) { 6195 if (Arch == llvm::Triple::systemz || TC.getTriple().isX86()) 6196 A->render(Args, CmdArgs); 6197 else 6198 D.Diag(diag::err_drv_unsupported_opt_for_target) 6199 << A->getAsString(Args) << TripleStr; 6200 } 6201 if (Arg *A = Args.getLastArg(options::OPT_mnop_mcount)) { 6202 if (Arch == llvm::Triple::systemz) 6203 A->render(Args, CmdArgs); 6204 else 6205 D.Diag(diag::err_drv_unsupported_opt_for_target) 6206 << A->getAsString(Args) << TripleStr; 6207 } 6208 if (Arg *A = Args.getLastArg(options::OPT_mrecord_mcount)) { 6209 if (Arch == llvm::Triple::systemz) 6210 A->render(Args, CmdArgs); 6211 else 6212 D.Diag(diag::err_drv_unsupported_opt_for_target) 6213 << A->getAsString(Args) << TripleStr; 6214 } 6215 } 6216 6217 if (Args.getLastArg(options::OPT_fapple_kext) || 6218 (Args.hasArg(options::OPT_mkernel) && types::isCXX(InputType))) 6219 CmdArgs.push_back("-fapple-kext"); 6220 6221 Args.AddLastArg(CmdArgs, options::OPT_altivec_src_compat); 6222 Args.AddLastArg(CmdArgs, options::OPT_flax_vector_conversions_EQ); 6223 Args.AddLastArg(CmdArgs, options::OPT_fobjc_sender_dependent_dispatch); 6224 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_print_source_range_info); 6225 Args.AddLastArg(CmdArgs, options::OPT_fdiagnostics_parseable_fixits); 6226 Args.AddLastArg(CmdArgs, options::OPT_ftime_report); 6227 Args.AddLastArg(CmdArgs, options::OPT_ftime_report_EQ); 6228 Args.AddLastArg(CmdArgs, options::OPT_ftime_trace); 6229 Args.AddLastArg(CmdArgs, options::OPT_ftime_trace_granularity_EQ); 6230 Args.AddLastArg(CmdArgs, options::OPT_ftime_trace_EQ); 6231 Args.AddLastArg(CmdArgs, options::OPT_ftrapv); 6232 Args.AddLastArg(CmdArgs, options::OPT_malign_double); 6233 Args.AddLastArg(CmdArgs, options::OPT_fno_temp_file); 6234 6235 if (Arg *A = Args.getLastArg(options::OPT_ftrapv_handler_EQ)) { 6236 CmdArgs.push_back("-ftrapv-handler"); 6237 CmdArgs.push_back(A->getValue()); 6238 } 6239 6240 Args.AddLastArg(CmdArgs, options::OPT_ftrap_function_EQ); 6241 6242 // -fno-strict-overflow implies -fwrapv if it isn't disabled, but 6243 // -fstrict-overflow won't turn off an explicitly enabled -fwrapv. 6244 if (Arg *A = Args.getLastArg(options::OPT_fwrapv, options::OPT_fno_wrapv)) { 6245 if (A->getOption().matches(options::OPT_fwrapv)) 6246 CmdArgs.push_back("-fwrapv"); 6247 } else if (Arg *A = Args.getLastArg(options::OPT_fstrict_overflow, 6248 options::OPT_fno_strict_overflow)) { 6249 if (A->getOption().matches(options::OPT_fno_strict_overflow)) 6250 CmdArgs.push_back("-fwrapv"); 6251 } 6252 6253 if (Arg *A = Args.getLastArg(options::OPT_freroll_loops, 6254 options::OPT_fno_reroll_loops)) 6255 if (A->getOption().matches(options::OPT_freroll_loops)) 6256 CmdArgs.push_back("-freroll-loops"); 6257 6258 Args.AddLastArg(CmdArgs, options::OPT_ffinite_loops, 6259 options::OPT_fno_finite_loops); 6260 6261 Args.AddLastArg(CmdArgs, options::OPT_fwritable_strings); 6262 Args.AddLastArg(CmdArgs, options::OPT_funroll_loops, 6263 options::OPT_fno_unroll_loops); 6264 6265 Args.AddLastArg(CmdArgs, options::OPT_fstrict_flex_arrays_EQ); 6266 6267 Args.AddLastArg(CmdArgs, options::OPT_pthread); 6268 6269 if (Args.hasFlag(options::OPT_mspeculative_load_hardening, 6270 options::OPT_mno_speculative_load_hardening, false)) 6271 CmdArgs.push_back(Args.MakeArgString("-mspeculative-load-hardening")); 6272 6273 RenderSSPOptions(D, TC, Args, CmdArgs, KernelOrKext); 6274 RenderSCPOptions(TC, Args, CmdArgs); 6275 RenderTrivialAutoVarInitOptions(D, TC, Args, CmdArgs); 6276 6277 Args.AddLastArg(CmdArgs, options::OPT_fswift_async_fp_EQ); 6278 6279 // Translate -mstackrealign 6280 if (Args.hasFlag(options::OPT_mstackrealign, options::OPT_mno_stackrealign, 6281 false)) 6282 CmdArgs.push_back(Args.MakeArgString("-mstackrealign")); 6283 6284 if (Args.hasArg(options::OPT_mstack_alignment)) { 6285 StringRef alignment = Args.getLastArgValue(options::OPT_mstack_alignment); 6286 CmdArgs.push_back(Args.MakeArgString("-mstack-alignment=" + alignment)); 6287 } 6288 6289 if (Args.hasArg(options::OPT_mstack_probe_size)) { 6290 StringRef Size = Args.getLastArgValue(options::OPT_mstack_probe_size); 6291 6292 if (!Size.empty()) 6293 CmdArgs.push_back(Args.MakeArgString("-mstack-probe-size=" + Size)); 6294 else 6295 CmdArgs.push_back("-mstack-probe-size=0"); 6296 } 6297 6298 Args.addOptOutFlag(CmdArgs, options::OPT_mstack_arg_probe, 6299 options::OPT_mno_stack_arg_probe); 6300 6301 if (Arg *A = Args.getLastArg(options::OPT_mrestrict_it, 6302 options::OPT_mno_restrict_it)) { 6303 if (A->getOption().matches(options::OPT_mrestrict_it)) { 6304 CmdArgs.push_back("-mllvm"); 6305 CmdArgs.push_back("-arm-restrict-it"); 6306 } else { 6307 CmdArgs.push_back("-mllvm"); 6308 CmdArgs.push_back("-arm-default-it"); 6309 } 6310 } 6311 6312 // Forward -cl options to -cc1 6313 RenderOpenCLOptions(Args, CmdArgs, InputType); 6314 6315 // Forward hlsl options to -cc1 6316 if (C.getDriver().IsDXCMode()) 6317 RenderHLSLOptions(Args, CmdArgs, InputType); 6318 6319 if (IsHIP) { 6320 if (Args.hasFlag(options::OPT_fhip_new_launch_api, 6321 options::OPT_fno_hip_new_launch_api, true)) 6322 CmdArgs.push_back("-fhip-new-launch-api"); 6323 if (Args.hasFlag(options::OPT_fgpu_allow_device_init, 6324 options::OPT_fno_gpu_allow_device_init, false)) 6325 CmdArgs.push_back("-fgpu-allow-device-init"); 6326 Args.addOptInFlag(CmdArgs, options::OPT_fhip_kernel_arg_name, 6327 options::OPT_fno_hip_kernel_arg_name); 6328 } 6329 6330 if (IsCuda || IsHIP) { 6331 if (IsRDCMode) 6332 CmdArgs.push_back("-fgpu-rdc"); 6333 if (Args.hasFlag(options::OPT_fgpu_defer_diag, 6334 options::OPT_fno_gpu_defer_diag, false)) 6335 CmdArgs.push_back("-fgpu-defer-diag"); 6336 if (Args.hasFlag(options::OPT_fgpu_exclude_wrong_side_overloads, 6337 options::OPT_fno_gpu_exclude_wrong_side_overloads, 6338 false)) { 6339 CmdArgs.push_back("-fgpu-exclude-wrong-side-overloads"); 6340 CmdArgs.push_back("-fgpu-defer-diag"); 6341 } 6342 } 6343 6344 // Forward -nogpulib to -cc1. 6345 if (Args.hasArg(options::OPT_nogpulib)) 6346 CmdArgs.push_back("-nogpulib"); 6347 6348 if (Arg *A = Args.getLastArg(options::OPT_fcf_protection_EQ)) { 6349 CmdArgs.push_back( 6350 Args.MakeArgString(Twine("-fcf-protection=") + A->getValue())); 6351 } 6352 6353 if (IsUsingLTO) 6354 Args.AddLastArg(CmdArgs, options::OPT_mibt_seal); 6355 6356 if (Arg *A = Args.getLastArg(options::OPT_mfunction_return_EQ)) 6357 CmdArgs.push_back( 6358 Args.MakeArgString(Twine("-mfunction-return=") + A->getValue())); 6359 6360 // Forward -f options with positive and negative forms; we translate these by 6361 // hand. Do not propagate PGO options to the GPU-side compilations as the 6362 // profile info is for the host-side compilation only. 6363 if (!(IsCudaDevice || IsHIPDevice)) { 6364 if (Arg *A = getLastProfileSampleUseArg(Args)) { 6365 auto *PGOArg = Args.getLastArg( 6366 options::OPT_fprofile_generate, options::OPT_fprofile_generate_EQ, 6367 options::OPT_fcs_profile_generate, 6368 options::OPT_fcs_profile_generate_EQ, options::OPT_fprofile_use, 6369 options::OPT_fprofile_use_EQ); 6370 if (PGOArg) 6371 D.Diag(diag::err_drv_argument_not_allowed_with) 6372 << "SampleUse with PGO options"; 6373 6374 StringRef fname = A->getValue(); 6375 if (!llvm::sys::fs::exists(fname)) 6376 D.Diag(diag::err_drv_no_such_file) << fname; 6377 else 6378 A->render(Args, CmdArgs); 6379 } 6380 Args.AddLastArg(CmdArgs, options::OPT_fprofile_remapping_file_EQ); 6381 6382 if (Args.hasFlag(options::OPT_fpseudo_probe_for_profiling, 6383 options::OPT_fno_pseudo_probe_for_profiling, false)) { 6384 CmdArgs.push_back("-fpseudo-probe-for-profiling"); 6385 // Enforce -funique-internal-linkage-names if it's not explicitly turned 6386 // off. 6387 if (Args.hasFlag(options::OPT_funique_internal_linkage_names, 6388 options::OPT_fno_unique_internal_linkage_names, true)) 6389 CmdArgs.push_back("-funique-internal-linkage-names"); 6390 } 6391 } 6392 RenderBuiltinOptions(TC, RawTriple, Args, CmdArgs); 6393 6394 Args.addOptOutFlag(CmdArgs, options::OPT_fassume_sane_operator_new, 6395 options::OPT_fno_assume_sane_operator_new); 6396 6397 // -fblocks=0 is default. 6398 if (Args.hasFlag(options::OPT_fblocks, options::OPT_fno_blocks, 6399 TC.IsBlocksDefault()) || 6400 (Args.hasArg(options::OPT_fgnu_runtime) && 6401 Args.hasArg(options::OPT_fobjc_nonfragile_abi) && 6402 !Args.hasArg(options::OPT_fno_blocks))) { 6403 CmdArgs.push_back("-fblocks"); 6404 6405 if (!Args.hasArg(options::OPT_fgnu_runtime) && !TC.hasBlocksRuntime()) 6406 CmdArgs.push_back("-fblocks-runtime-optional"); 6407 } 6408 6409 // -fencode-extended-block-signature=1 is default. 6410 if (TC.IsEncodeExtendedBlockSignatureDefault()) 6411 CmdArgs.push_back("-fencode-extended-block-signature"); 6412 6413 if (Args.hasFlag(options::OPT_fcoroutines_ts, options::OPT_fno_coroutines_ts, 6414 false) && 6415 types::isCXX(InputType)) { 6416 CmdArgs.push_back("-fcoroutines-ts"); 6417 } 6418 6419 Args.AddLastArg(CmdArgs, options::OPT_fdouble_square_bracket_attributes, 6420 options::OPT_fno_double_square_bracket_attributes); 6421 6422 Args.addOptOutFlag(CmdArgs, options::OPT_faccess_control, 6423 options::OPT_fno_access_control); 6424 Args.addOptOutFlag(CmdArgs, options::OPT_felide_constructors, 6425 options::OPT_fno_elide_constructors); 6426 6427 ToolChain::RTTIMode RTTIMode = TC.getRTTIMode(); 6428 6429 if (KernelOrKext || (types::isCXX(InputType) && 6430 (RTTIMode == ToolChain::RM_Disabled))) 6431 CmdArgs.push_back("-fno-rtti"); 6432 6433 // -fshort-enums=0 is default for all architectures except Hexagon and z/OS. 6434 if (Args.hasFlag(options::OPT_fshort_enums, options::OPT_fno_short_enums, 6435 TC.getArch() == llvm::Triple::hexagon || Triple.isOSzOS())) 6436 CmdArgs.push_back("-fshort-enums"); 6437 6438 RenderCharacterOptions(Args, AuxTriple ? *AuxTriple : RawTriple, CmdArgs); 6439 6440 // -fuse-cxa-atexit is default. 6441 if (!Args.hasFlag( 6442 options::OPT_fuse_cxa_atexit, options::OPT_fno_use_cxa_atexit, 6443 !RawTriple.isOSAIX() && !RawTriple.isOSWindows() && 6444 ((RawTriple.getVendor() != llvm::Triple::MipsTechnologies) || 6445 RawTriple.hasEnvironment())) || 6446 KernelOrKext) 6447 CmdArgs.push_back("-fno-use-cxa-atexit"); 6448 6449 if (Args.hasFlag(options::OPT_fregister_global_dtors_with_atexit, 6450 options::OPT_fno_register_global_dtors_with_atexit, 6451 RawTriple.isOSDarwin() && !KernelOrKext)) 6452 CmdArgs.push_back("-fregister-global-dtors-with-atexit"); 6453 6454 Args.addOptInFlag(CmdArgs, options::OPT_fuse_line_directives, 6455 options::OPT_fno_use_line_directives); 6456 6457 // -fno-minimize-whitespace is default. 6458 if (Args.hasFlag(options::OPT_fminimize_whitespace, 6459 options::OPT_fno_minimize_whitespace, false)) { 6460 types::ID InputType = Inputs[0].getType(); 6461 if (!isDerivedFromC(InputType)) 6462 D.Diag(diag::err_drv_minws_unsupported_input_type) 6463 << types::getTypeName(InputType); 6464 CmdArgs.push_back("-fminimize-whitespace"); 6465 } 6466 6467 // -fms-extensions=0 is default. 6468 if (Args.hasFlag(options::OPT_fms_extensions, options::OPT_fno_ms_extensions, 6469 IsWindowsMSVC)) 6470 CmdArgs.push_back("-fms-extensions"); 6471 6472 // -fms-compatibility=0 is default. 6473 bool IsMSVCCompat = Args.hasFlag( 6474 options::OPT_fms_compatibility, options::OPT_fno_ms_compatibility, 6475 (IsWindowsMSVC && Args.hasFlag(options::OPT_fms_extensions, 6476 options::OPT_fno_ms_extensions, true))); 6477 if (IsMSVCCompat) 6478 CmdArgs.push_back("-fms-compatibility"); 6479 6480 // Handle -fgcc-version, if present. 6481 VersionTuple GNUCVer; 6482 if (Arg *A = Args.getLastArg(options::OPT_fgnuc_version_EQ)) { 6483 // Check that the version has 1 to 3 components and the minor and patch 6484 // versions fit in two decimal digits. 6485 StringRef Val = A->getValue(); 6486 Val = Val.empty() ? "0" : Val; // Treat "" as 0 or disable. 6487 bool Invalid = GNUCVer.tryParse(Val); 6488 unsigned Minor = GNUCVer.getMinor().value_or(0); 6489 unsigned Patch = GNUCVer.getSubminor().value_or(0); 6490 if (Invalid || GNUCVer.getBuild() || Minor >= 100 || Patch >= 100) { 6491 D.Diag(diag::err_drv_invalid_value) 6492 << A->getAsString(Args) << A->getValue(); 6493 } 6494 } else if (!IsMSVCCompat) { 6495 // Imitate GCC 4.2.1 by default if -fms-compatibility is not in effect. 6496 GNUCVer = VersionTuple(4, 2, 1); 6497 } 6498 if (!GNUCVer.empty()) { 6499 CmdArgs.push_back( 6500 Args.MakeArgString("-fgnuc-version=" + GNUCVer.getAsString())); 6501 } 6502 6503 VersionTuple MSVT = TC.computeMSVCVersion(&D, Args); 6504 if (!MSVT.empty()) 6505 CmdArgs.push_back( 6506 Args.MakeArgString("-fms-compatibility-version=" + MSVT.getAsString())); 6507 6508 bool IsMSVC2015Compatible = MSVT.getMajor() >= 19; 6509 if (ImplyVCPPCVer) { 6510 StringRef LanguageStandard; 6511 if (const Arg *StdArg = Args.getLastArg(options::OPT__SLASH_std)) { 6512 Std = StdArg; 6513 LanguageStandard = llvm::StringSwitch<StringRef>(StdArg->getValue()) 6514 .Case("c11", "-std=c11") 6515 .Case("c17", "-std=c17") 6516 .Default(""); 6517 if (LanguageStandard.empty()) 6518 D.Diag(clang::diag::warn_drv_unused_argument) 6519 << StdArg->getAsString(Args); 6520 } 6521 CmdArgs.push_back(LanguageStandard.data()); 6522 } 6523 if (ImplyVCPPCXXVer) { 6524 StringRef LanguageStandard; 6525 if (const Arg *StdArg = Args.getLastArg(options::OPT__SLASH_std)) { 6526 Std = StdArg; 6527 LanguageStandard = llvm::StringSwitch<StringRef>(StdArg->getValue()) 6528 .Case("c++14", "-std=c++14") 6529 .Case("c++17", "-std=c++17") 6530 .Case("c++20", "-std=c++20") 6531 .Case("c++latest", "-std=c++2b") 6532 .Default(""); 6533 if (LanguageStandard.empty()) 6534 D.Diag(clang::diag::warn_drv_unused_argument) 6535 << StdArg->getAsString(Args); 6536 } 6537 6538 if (LanguageStandard.empty()) { 6539 if (IsMSVC2015Compatible) 6540 LanguageStandard = "-std=c++14"; 6541 else 6542 LanguageStandard = "-std=c++11"; 6543 } 6544 6545 CmdArgs.push_back(LanguageStandard.data()); 6546 } 6547 6548 Args.addOptInFlag(CmdArgs, options::OPT_fborland_extensions, 6549 options::OPT_fno_borland_extensions); 6550 6551 // -fno-declspec is default, except for PS4/PS5. 6552 if (Args.hasFlag(options::OPT_fdeclspec, options::OPT_fno_declspec, 6553 RawTriple.isPS())) 6554 CmdArgs.push_back("-fdeclspec"); 6555 else if (Args.hasArg(options::OPT_fno_declspec)) 6556 CmdArgs.push_back("-fno-declspec"); // Explicitly disabling __declspec. 6557 6558 // -fthreadsafe-static is default, except for MSVC compatibility versions less 6559 // than 19. 6560 if (!Args.hasFlag(options::OPT_fthreadsafe_statics, 6561 options::OPT_fno_threadsafe_statics, 6562 !types::isOpenCL(InputType) && 6563 (!IsWindowsMSVC || IsMSVC2015Compatible))) 6564 CmdArgs.push_back("-fno-threadsafe-statics"); 6565 6566 // -fno-delayed-template-parsing is default, except when targeting MSVC. 6567 // Many old Windows SDK versions require this to parse. 6568 // FIXME: MSVC introduced /Zc:twoPhase- to disable this behavior in their 6569 // compiler. We should be able to disable this by default at some point. 6570 if (Args.hasFlag(options::OPT_fdelayed_template_parsing, 6571 options::OPT_fno_delayed_template_parsing, IsWindowsMSVC)) 6572 CmdArgs.push_back("-fdelayed-template-parsing"); 6573 6574 // -fgnu-keywords default varies depending on language; only pass if 6575 // specified. 6576 Args.AddLastArg(CmdArgs, options::OPT_fgnu_keywords, 6577 options::OPT_fno_gnu_keywords); 6578 6579 Args.addOptInFlag(CmdArgs, options::OPT_fgnu89_inline, 6580 options::OPT_fno_gnu89_inline); 6581 6582 const Arg *InlineArg = Args.getLastArg(options::OPT_finline_functions, 6583 options::OPT_finline_hint_functions, 6584 options::OPT_fno_inline_functions); 6585 if (Arg *A = Args.getLastArg(options::OPT_finline, options::OPT_fno_inline)) { 6586 if (A->getOption().matches(options::OPT_fno_inline)) 6587 A->render(Args, CmdArgs); 6588 } else if (InlineArg) { 6589 InlineArg->render(Args, CmdArgs); 6590 } 6591 6592 // FIXME: Find a better way to determine whether the language has modules 6593 // support by default, or just assume that all languages do. 6594 bool HaveModules = 6595 Std && (Std->containsValue("c++2a") || Std->containsValue("c++20") || 6596 Std->containsValue("c++2b") || Std->containsValue("c++latest")); 6597 RenderModulesOptions(C, D, Args, Input, Output, CmdArgs, HaveModules); 6598 6599 if (Args.hasFlag(options::OPT_fpch_validate_input_files_content, 6600 options::OPT_fno_pch_validate_input_files_content, false)) 6601 CmdArgs.push_back("-fvalidate-ast-input-files-content"); 6602 if (Args.hasFlag(options::OPT_fpch_instantiate_templates, 6603 options::OPT_fno_pch_instantiate_templates, false)) 6604 CmdArgs.push_back("-fpch-instantiate-templates"); 6605 if (Args.hasFlag(options::OPT_fpch_codegen, options::OPT_fno_pch_codegen, 6606 false)) 6607 CmdArgs.push_back("-fmodules-codegen"); 6608 if (Args.hasFlag(options::OPT_fpch_debuginfo, options::OPT_fno_pch_debuginfo, 6609 false)) 6610 CmdArgs.push_back("-fmodules-debuginfo"); 6611 6612 if (!CLANG_ENABLE_OPAQUE_POINTERS_INTERNAL) 6613 CmdArgs.push_back("-no-opaque-pointers"); 6614 6615 ObjCRuntime Runtime = AddObjCRuntimeArgs(Args, Inputs, CmdArgs, rewriteKind); 6616 RenderObjCOptions(TC, D, RawTriple, Args, Runtime, rewriteKind != RK_None, 6617 Input, CmdArgs); 6618 6619 if (types::isObjC(Input.getType()) && 6620 Args.hasFlag(options::OPT_fobjc_encode_cxx_class_template_spec, 6621 options::OPT_fno_objc_encode_cxx_class_template_spec, 6622 !Runtime.isNeXTFamily())) 6623 CmdArgs.push_back("-fobjc-encode-cxx-class-template-spec"); 6624 6625 if (Args.hasFlag(options::OPT_fapplication_extension, 6626 options::OPT_fno_application_extension, false)) 6627 CmdArgs.push_back("-fapplication-extension"); 6628 6629 // Handle GCC-style exception args. 6630 bool EH = false; 6631 if (!C.getDriver().IsCLMode()) 6632 EH = addExceptionArgs(Args, InputType, TC, KernelOrKext, Runtime, CmdArgs); 6633 6634 // Handle exception personalities 6635 Arg *A = Args.getLastArg( 6636 options::OPT_fsjlj_exceptions, options::OPT_fseh_exceptions, 6637 options::OPT_fdwarf_exceptions, options::OPT_fwasm_exceptions); 6638 if (A) { 6639 const Option &Opt = A->getOption(); 6640 if (Opt.matches(options::OPT_fsjlj_exceptions)) 6641 CmdArgs.push_back("-exception-model=sjlj"); 6642 if (Opt.matches(options::OPT_fseh_exceptions)) 6643 CmdArgs.push_back("-exception-model=seh"); 6644 if (Opt.matches(options::OPT_fdwarf_exceptions)) 6645 CmdArgs.push_back("-exception-model=dwarf"); 6646 if (Opt.matches(options::OPT_fwasm_exceptions)) 6647 CmdArgs.push_back("-exception-model=wasm"); 6648 } else { 6649 switch (TC.GetExceptionModel(Args)) { 6650 default: 6651 break; 6652 case llvm::ExceptionHandling::DwarfCFI: 6653 CmdArgs.push_back("-exception-model=dwarf"); 6654 break; 6655 case llvm::ExceptionHandling::SjLj: 6656 CmdArgs.push_back("-exception-model=sjlj"); 6657 break; 6658 case llvm::ExceptionHandling::WinEH: 6659 CmdArgs.push_back("-exception-model=seh"); 6660 break; 6661 } 6662 } 6663 6664 // C++ "sane" operator new. 6665 Args.addOptOutFlag(CmdArgs, options::OPT_fassume_sane_operator_new, 6666 options::OPT_fno_assume_sane_operator_new); 6667 6668 // -frelaxed-template-template-args is off by default, as it is a severe 6669 // breaking change until a corresponding change to template partial ordering 6670 // is provided. 6671 Args.addOptInFlag(CmdArgs, options::OPT_frelaxed_template_template_args, 6672 options::OPT_fno_relaxed_template_template_args); 6673 6674 // -fsized-deallocation is off by default, as it is an ABI-breaking change for 6675 // most platforms. 6676 Args.addOptInFlag(CmdArgs, options::OPT_fsized_deallocation, 6677 options::OPT_fno_sized_deallocation); 6678 6679 // -faligned-allocation is on by default in C++17 onwards and otherwise off 6680 // by default. 6681 if (Arg *A = Args.getLastArg(options::OPT_faligned_allocation, 6682 options::OPT_fno_aligned_allocation, 6683 options::OPT_faligned_new_EQ)) { 6684 if (A->getOption().matches(options::OPT_fno_aligned_allocation)) 6685 CmdArgs.push_back("-fno-aligned-allocation"); 6686 else 6687 CmdArgs.push_back("-faligned-allocation"); 6688 } 6689 6690 // The default new alignment can be specified using a dedicated option or via 6691 // a GCC-compatible option that also turns on aligned allocation. 6692 if (Arg *A = Args.getLastArg(options::OPT_fnew_alignment_EQ, 6693 options::OPT_faligned_new_EQ)) 6694 CmdArgs.push_back( 6695 Args.MakeArgString(Twine("-fnew-alignment=") + A->getValue())); 6696 6697 // -fconstant-cfstrings is default, and may be subject to argument translation 6698 // on Darwin. 6699 if (!Args.hasFlag(options::OPT_fconstant_cfstrings, 6700 options::OPT_fno_constant_cfstrings, true) || 6701 !Args.hasFlag(options::OPT_mconstant_cfstrings, 6702 options::OPT_mno_constant_cfstrings, true)) 6703 CmdArgs.push_back("-fno-constant-cfstrings"); 6704 6705 Args.addOptInFlag(CmdArgs, options::OPT_fpascal_strings, 6706 options::OPT_fno_pascal_strings); 6707 6708 // Honor -fpack-struct= and -fpack-struct, if given. Note that 6709 // -fno-pack-struct doesn't apply to -fpack-struct=. 6710 if (Arg *A = Args.getLastArg(options::OPT_fpack_struct_EQ)) { 6711 std::string PackStructStr = "-fpack-struct="; 6712 PackStructStr += A->getValue(); 6713 CmdArgs.push_back(Args.MakeArgString(PackStructStr)); 6714 } else if (Args.hasFlag(options::OPT_fpack_struct, 6715 options::OPT_fno_pack_struct, false)) { 6716 CmdArgs.push_back("-fpack-struct=1"); 6717 } 6718 6719 // Handle -fmax-type-align=N and -fno-type-align 6720 bool SkipMaxTypeAlign = Args.hasArg(options::OPT_fno_max_type_align); 6721 if (Arg *A = Args.getLastArg(options::OPT_fmax_type_align_EQ)) { 6722 if (!SkipMaxTypeAlign) { 6723 std::string MaxTypeAlignStr = "-fmax-type-align="; 6724 MaxTypeAlignStr += A->getValue(); 6725 CmdArgs.push_back(Args.MakeArgString(MaxTypeAlignStr)); 6726 } 6727 } else if (RawTriple.isOSDarwin()) { 6728 if (!SkipMaxTypeAlign) { 6729 std::string MaxTypeAlignStr = "-fmax-type-align=16"; 6730 CmdArgs.push_back(Args.MakeArgString(MaxTypeAlignStr)); 6731 } 6732 } 6733 6734 if (!Args.hasFlag(options::OPT_Qy, options::OPT_Qn, true)) 6735 CmdArgs.push_back("-Qn"); 6736 6737 // -fno-common is the default, set -fcommon only when that flag is set. 6738 Args.addOptInFlag(CmdArgs, options::OPT_fcommon, options::OPT_fno_common); 6739 6740 // -fsigned-bitfields is default, and clang doesn't yet support 6741 // -funsigned-bitfields. 6742 if (!Args.hasFlag(options::OPT_fsigned_bitfields, 6743 options::OPT_funsigned_bitfields, true)) 6744 D.Diag(diag::warn_drv_clang_unsupported) 6745 << Args.getLastArg(options::OPT_funsigned_bitfields)->getAsString(Args); 6746 6747 // -fsigned-bitfields is default, and clang doesn't support -fno-for-scope. 6748 if (!Args.hasFlag(options::OPT_ffor_scope, options::OPT_fno_for_scope, true)) 6749 D.Diag(diag::err_drv_clang_unsupported) 6750 << Args.getLastArg(options::OPT_fno_for_scope)->getAsString(Args); 6751 6752 // -finput_charset=UTF-8 is default. Reject others 6753 if (Arg *inputCharset = Args.getLastArg(options::OPT_finput_charset_EQ)) { 6754 StringRef value = inputCharset->getValue(); 6755 if (!value.equals_insensitive("utf-8")) 6756 D.Diag(diag::err_drv_invalid_value) << inputCharset->getAsString(Args) 6757 << value; 6758 } 6759 6760 // -fexec_charset=UTF-8 is default. Reject others 6761 if (Arg *execCharset = Args.getLastArg(options::OPT_fexec_charset_EQ)) { 6762 StringRef value = execCharset->getValue(); 6763 if (!value.equals_insensitive("utf-8")) 6764 D.Diag(diag::err_drv_invalid_value) << execCharset->getAsString(Args) 6765 << value; 6766 } 6767 6768 RenderDiagnosticsOptions(D, Args, CmdArgs); 6769 6770 Args.addOptInFlag(CmdArgs, options::OPT_fasm_blocks, 6771 options::OPT_fno_asm_blocks); 6772 6773 // -fgnu-inline-asm is default. 6774 if (!Args.hasFlag(options::OPT_fgnu_inline_asm, 6775 options::OPT_fno_gnu_inline_asm, true)) 6776 CmdArgs.push_back("-fno-gnu-inline-asm"); 6777 6778 // Enable vectorization per default according to the optimization level 6779 // selected. For optimization levels that want vectorization we use the alias 6780 // option to simplify the hasFlag logic. 6781 bool EnableVec = shouldEnableVectorizerAtOLevel(Args, false); 6782 OptSpecifier VectorizeAliasOption = 6783 EnableVec ? options::OPT_O_Group : options::OPT_fvectorize; 6784 if (Args.hasFlag(options::OPT_fvectorize, VectorizeAliasOption, 6785 options::OPT_fno_vectorize, EnableVec)) 6786 CmdArgs.push_back("-vectorize-loops"); 6787 6788 // -fslp-vectorize is enabled based on the optimization level selected. 6789 bool EnableSLPVec = shouldEnableVectorizerAtOLevel(Args, true); 6790 OptSpecifier SLPVectAliasOption = 6791 EnableSLPVec ? options::OPT_O_Group : options::OPT_fslp_vectorize; 6792 if (Args.hasFlag(options::OPT_fslp_vectorize, SLPVectAliasOption, 6793 options::OPT_fno_slp_vectorize, EnableSLPVec)) 6794 CmdArgs.push_back("-vectorize-slp"); 6795 6796 ParseMPreferVectorWidth(D, Args, CmdArgs); 6797 6798 Args.AddLastArg(CmdArgs, options::OPT_fshow_overloads_EQ); 6799 Args.AddLastArg(CmdArgs, 6800 options::OPT_fsanitize_undefined_strip_path_components_EQ); 6801 6802 // -fdollars-in-identifiers default varies depending on platform and 6803 // language; only pass if specified. 6804 if (Arg *A = Args.getLastArg(options::OPT_fdollars_in_identifiers, 6805 options::OPT_fno_dollars_in_identifiers)) { 6806 if (A->getOption().matches(options::OPT_fdollars_in_identifiers)) 6807 CmdArgs.push_back("-fdollars-in-identifiers"); 6808 else 6809 CmdArgs.push_back("-fno-dollars-in-identifiers"); 6810 } 6811 6812 Args.addOptInFlag(CmdArgs, options::OPT_fapple_pragma_pack, 6813 options::OPT_fno_apple_pragma_pack); 6814 6815 if (Args.hasFlag(options::OPT_fxl_pragma_pack, 6816 options::OPT_fno_xl_pragma_pack, RawTriple.isOSAIX())) 6817 CmdArgs.push_back("-fxl-pragma-pack"); 6818 6819 // Remarks can be enabled with any of the `-f.*optimization-record.*` flags. 6820 if (willEmitRemarks(Args) && checkRemarksOptions(D, Args, Triple)) 6821 renderRemarksOptions(Args, CmdArgs, Triple, Input, Output, JA); 6822 6823 bool RewriteImports = Args.hasFlag(options::OPT_frewrite_imports, 6824 options::OPT_fno_rewrite_imports, false); 6825 if (RewriteImports) 6826 CmdArgs.push_back("-frewrite-imports"); 6827 6828 if (Args.hasFlag(options::OPT_fdirectives_only, 6829 options::OPT_fno_directives_only, false)) 6830 CmdArgs.push_back("-fdirectives-only"); 6831 6832 // Enable rewrite includes if the user's asked for it or if we're generating 6833 // diagnostics. 6834 // TODO: Once -module-dependency-dir works with -frewrite-includes it'd be 6835 // nice to enable this when doing a crashdump for modules as well. 6836 if (Args.hasFlag(options::OPT_frewrite_includes, 6837 options::OPT_fno_rewrite_includes, false) || 6838 (C.isForDiagnostics() && !HaveModules)) 6839 CmdArgs.push_back("-frewrite-includes"); 6840 6841 // Only allow -traditional or -traditional-cpp outside in preprocessing modes. 6842 if (Arg *A = Args.getLastArg(options::OPT_traditional, 6843 options::OPT_traditional_cpp)) { 6844 if (isa<PreprocessJobAction>(JA)) 6845 CmdArgs.push_back("-traditional-cpp"); 6846 else 6847 D.Diag(diag::err_drv_clang_unsupported) << A->getAsString(Args); 6848 } 6849 6850 Args.AddLastArg(CmdArgs, options::OPT_dM); 6851 Args.AddLastArg(CmdArgs, options::OPT_dD); 6852 Args.AddLastArg(CmdArgs, options::OPT_dI); 6853 6854 Args.AddLastArg(CmdArgs, options::OPT_fmax_tokens_EQ); 6855 6856 // Handle serialized diagnostics. 6857 if (Arg *A = Args.getLastArg(options::OPT__serialize_diags)) { 6858 CmdArgs.push_back("-serialize-diagnostic-file"); 6859 CmdArgs.push_back(Args.MakeArgString(A->getValue())); 6860 } 6861 6862 if (Args.hasArg(options::OPT_fretain_comments_from_system_headers)) 6863 CmdArgs.push_back("-fretain-comments-from-system-headers"); 6864 6865 // Forward -fcomment-block-commands to -cc1. 6866 Args.AddAllArgs(CmdArgs, options::OPT_fcomment_block_commands); 6867 // Forward -fparse-all-comments to -cc1. 6868 Args.AddAllArgs(CmdArgs, options::OPT_fparse_all_comments); 6869 6870 // Turn -fplugin=name.so into -load name.so 6871 for (const Arg *A : Args.filtered(options::OPT_fplugin_EQ)) { 6872 CmdArgs.push_back("-load"); 6873 CmdArgs.push_back(A->getValue()); 6874 A->claim(); 6875 } 6876 6877 // Turn -fplugin-arg-pluginname-key=value into 6878 // -plugin-arg-pluginname key=value 6879 // GCC has an actual plugin_argument struct with key/value pairs that it 6880 // passes to its plugins, but we don't, so just pass it on as-is. 6881 // 6882 // The syntax for -fplugin-arg- is ambiguous if both plugin name and 6883 // argument key are allowed to contain dashes. GCC therefore only 6884 // allows dashes in the key. We do the same. 6885 for (const Arg *A : Args.filtered(options::OPT_fplugin_arg)) { 6886 auto ArgValue = StringRef(A->getValue()); 6887 auto FirstDashIndex = ArgValue.find('-'); 6888 StringRef PluginName = ArgValue.substr(0, FirstDashIndex); 6889 StringRef Arg = ArgValue.substr(FirstDashIndex + 1); 6890 6891 A->claim(); 6892 if (FirstDashIndex == StringRef::npos || Arg.empty()) { 6893 if (PluginName.empty()) { 6894 D.Diag(diag::warn_drv_missing_plugin_name) << A->getAsString(Args); 6895 } else { 6896 D.Diag(diag::warn_drv_missing_plugin_arg) 6897 << PluginName << A->getAsString(Args); 6898 } 6899 continue; 6900 } 6901 6902 CmdArgs.push_back(Args.MakeArgString(Twine("-plugin-arg-") + PluginName)); 6903 CmdArgs.push_back(Args.MakeArgString(Arg)); 6904 } 6905 6906 // Forward -fpass-plugin=name.so to -cc1. 6907 for (const Arg *A : Args.filtered(options::OPT_fpass_plugin_EQ)) { 6908 CmdArgs.push_back( 6909 Args.MakeArgString(Twine("-fpass-plugin=") + A->getValue())); 6910 A->claim(); 6911 } 6912 6913 // Setup statistics file output. 6914 SmallString<128> StatsFile = getStatsFileName(Args, Output, Input, D); 6915 if (!StatsFile.empty()) 6916 CmdArgs.push_back(Args.MakeArgString(Twine("-stats-file=") + StatsFile)); 6917 6918 // Forward -Xclang arguments to -cc1, and -mllvm arguments to the LLVM option 6919 // parser. 6920 // -finclude-default-header flag is for preprocessor, 6921 // do not pass it to other cc1 commands when save-temps is enabled 6922 if (C.getDriver().isSaveTempsEnabled() && 6923 !isa<PreprocessJobAction>(JA)) { 6924 for (auto Arg : Args.filtered(options::OPT_Xclang)) { 6925 Arg->claim(); 6926 if (StringRef(Arg->getValue()) != "-finclude-default-header") 6927 CmdArgs.push_back(Arg->getValue()); 6928 } 6929 } 6930 else { 6931 Args.AddAllArgValues(CmdArgs, options::OPT_Xclang); 6932 } 6933 for (const Arg *A : Args.filtered(options::OPT_mllvm)) { 6934 A->claim(); 6935 6936 // We translate this by hand to the -cc1 argument, since nightly test uses 6937 // it and developers have been trained to spell it with -mllvm. Both 6938 // spellings are now deprecated and should be removed. 6939 if (StringRef(A->getValue(0)) == "-disable-llvm-optzns") { 6940 CmdArgs.push_back("-disable-llvm-optzns"); 6941 } else { 6942 A->render(Args, CmdArgs); 6943 } 6944 } 6945 6946 // With -save-temps, we want to save the unoptimized bitcode output from the 6947 // CompileJobAction, use -disable-llvm-passes to get pristine IR generated 6948 // by the frontend. 6949 // When -fembed-bitcode is enabled, optimized bitcode is emitted because it 6950 // has slightly different breakdown between stages. 6951 // FIXME: -fembed-bitcode -save-temps will save optimized bitcode instead of 6952 // pristine IR generated by the frontend. Ideally, a new compile action should 6953 // be added so both IR can be captured. 6954 if ((C.getDriver().isSaveTempsEnabled() || 6955 JA.isHostOffloading(Action::OFK_OpenMP)) && 6956 !(C.getDriver().embedBitcodeInObject() && !IsUsingLTO) && 6957 isa<CompileJobAction>(JA)) 6958 CmdArgs.push_back("-disable-llvm-passes"); 6959 6960 Args.AddAllArgs(CmdArgs, options::OPT_undef); 6961 6962 const char *Exec = D.getClangProgramPath(); 6963 6964 // Optionally embed the -cc1 level arguments into the debug info or a 6965 // section, for build analysis. 6966 // Also record command line arguments into the debug info if 6967 // -grecord-gcc-switches options is set on. 6968 // By default, -gno-record-gcc-switches is set on and no recording. 6969 auto GRecordSwitches = 6970 Args.hasFlag(options::OPT_grecord_command_line, 6971 options::OPT_gno_record_command_line, false); 6972 auto FRecordSwitches = 6973 Args.hasFlag(options::OPT_frecord_command_line, 6974 options::OPT_fno_record_command_line, false); 6975 if (FRecordSwitches && !Triple.isOSBinFormatELF()) 6976 D.Diag(diag::err_drv_unsupported_opt_for_target) 6977 << Args.getLastArg(options::OPT_frecord_command_line)->getAsString(Args) 6978 << TripleStr; 6979 if (TC.UseDwarfDebugFlags() || GRecordSwitches || FRecordSwitches) { 6980 ArgStringList OriginalArgs; 6981 for (const auto &Arg : Args) 6982 Arg->render(Args, OriginalArgs); 6983 6984 SmallString<256> Flags; 6985 EscapeSpacesAndBackslashes(Exec, Flags); 6986 for (const char *OriginalArg : OriginalArgs) { 6987 SmallString<128> EscapedArg; 6988 EscapeSpacesAndBackslashes(OriginalArg, EscapedArg); 6989 Flags += " "; 6990 Flags += EscapedArg; 6991 } 6992 auto FlagsArgString = Args.MakeArgString(Flags); 6993 if (TC.UseDwarfDebugFlags() || GRecordSwitches) { 6994 CmdArgs.push_back("-dwarf-debug-flags"); 6995 CmdArgs.push_back(FlagsArgString); 6996 } 6997 if (FRecordSwitches) { 6998 CmdArgs.push_back("-record-command-line"); 6999 CmdArgs.push_back(FlagsArgString); 7000 } 7001 } 7002 7003 // Host-side offloading compilation receives all device-side outputs. Include 7004 // them in the host compilation depending on the target. If the host inputs 7005 // are not empty we use the new-driver scheme, otherwise use the old scheme. 7006 if ((IsCuda || IsHIP) && CudaDeviceInput) { 7007 CmdArgs.push_back("-fcuda-include-gpubinary"); 7008 CmdArgs.push_back(CudaDeviceInput->getFilename()); 7009 } else if (!HostOffloadingInputs.empty()) { 7010 if ((IsCuda || IsHIP) && !IsRDCMode) { 7011 assert(HostOffloadingInputs.size() == 1 && "Only one input expected"); 7012 CmdArgs.push_back("-fcuda-include-gpubinary"); 7013 CmdArgs.push_back(HostOffloadingInputs.front().getFilename()); 7014 } else { 7015 for (const InputInfo Input : HostOffloadingInputs) 7016 CmdArgs.push_back(Args.MakeArgString("-fembed-offload-object=" + 7017 TC.getInputFilename(Input))); 7018 } 7019 } 7020 7021 if (IsCuda) { 7022 if (Args.hasFlag(options::OPT_fcuda_short_ptr, 7023 options::OPT_fno_cuda_short_ptr, false)) 7024 CmdArgs.push_back("-fcuda-short-ptr"); 7025 } 7026 7027 if (IsCuda || IsHIP) { 7028 // Determine the original source input. 7029 const Action *SourceAction = &JA; 7030 while (SourceAction->getKind() != Action::InputClass) { 7031 assert(!SourceAction->getInputs().empty() && "unexpected root action!"); 7032 SourceAction = SourceAction->getInputs()[0]; 7033 } 7034 auto CUID = cast<InputAction>(SourceAction)->getId(); 7035 if (!CUID.empty()) 7036 CmdArgs.push_back(Args.MakeArgString(Twine("-cuid=") + Twine(CUID))); 7037 } 7038 7039 if (IsHIP) { 7040 CmdArgs.push_back("-fcuda-allow-variadic-functions"); 7041 Args.AddLastArg(CmdArgs, options::OPT_fgpu_default_stream_EQ); 7042 } 7043 7044 if (IsCudaDevice || IsHIPDevice) { 7045 StringRef InlineThresh = 7046 Args.getLastArgValue(options::OPT_fgpu_inline_threshold_EQ); 7047 if (!InlineThresh.empty()) { 7048 std::string ArgStr = 7049 std::string("-inline-threshold=") + InlineThresh.str(); 7050 CmdArgs.append({"-mllvm", Args.MakeArgStringRef(ArgStr)}); 7051 } 7052 } 7053 7054 // OpenMP offloading device jobs take the argument -fopenmp-host-ir-file-path 7055 // to specify the result of the compile phase on the host, so the meaningful 7056 // device declarations can be identified. Also, -fopenmp-is-device is passed 7057 // along to tell the frontend that it is generating code for a device, so that 7058 // only the relevant declarations are emitted. 7059 if (IsOpenMPDevice) { 7060 CmdArgs.push_back("-fopenmp-is-device"); 7061 if (OpenMPDeviceInput) { 7062 CmdArgs.push_back("-fopenmp-host-ir-file-path"); 7063 CmdArgs.push_back(Args.MakeArgString(OpenMPDeviceInput->getFilename())); 7064 } 7065 } 7066 7067 if (Triple.isAMDGPU()) { 7068 handleAMDGPUCodeObjectVersionOptions(D, Args, CmdArgs); 7069 7070 Args.addOptInFlag(CmdArgs, options::OPT_munsafe_fp_atomics, 7071 options::OPT_mno_unsafe_fp_atomics); 7072 } 7073 7074 // For all the host OpenMP offloading compile jobs we need to pass the targets 7075 // information using -fopenmp-targets= option. 7076 if (JA.isHostOffloading(Action::OFK_OpenMP)) { 7077 SmallString<128> Targets("-fopenmp-targets="); 7078 7079 SmallVector<std::string, 4> Triples; 7080 auto TCRange = C.getOffloadToolChains<Action::OFK_OpenMP>(); 7081 std::transform(TCRange.first, TCRange.second, std::back_inserter(Triples), 7082 [](auto TC) { return TC.second->getTripleString(); }); 7083 CmdArgs.push_back(Args.MakeArgString(Targets + llvm::join(Triples, ","))); 7084 } 7085 7086 bool VirtualFunctionElimination = 7087 Args.hasFlag(options::OPT_fvirtual_function_elimination, 7088 options::OPT_fno_virtual_function_elimination, false); 7089 if (VirtualFunctionElimination) { 7090 // VFE requires full LTO (currently, this might be relaxed to allow ThinLTO 7091 // in the future). 7092 if (LTOMode != LTOK_Full) 7093 D.Diag(diag::err_drv_argument_only_allowed_with) 7094 << "-fvirtual-function-elimination" 7095 << "-flto=full"; 7096 7097 CmdArgs.push_back("-fvirtual-function-elimination"); 7098 } 7099 7100 // VFE requires whole-program-vtables, and enables it by default. 7101 bool WholeProgramVTables = Args.hasFlag( 7102 options::OPT_fwhole_program_vtables, 7103 options::OPT_fno_whole_program_vtables, VirtualFunctionElimination); 7104 if (VirtualFunctionElimination && !WholeProgramVTables) { 7105 D.Diag(diag::err_drv_argument_not_allowed_with) 7106 << "-fno-whole-program-vtables" 7107 << "-fvirtual-function-elimination"; 7108 } 7109 7110 if (WholeProgramVTables) { 7111 // Propagate -fwhole-program-vtables if this is an LTO compile. 7112 if (IsUsingLTO) 7113 CmdArgs.push_back("-fwhole-program-vtables"); 7114 // Check if we passed LTO options but they were suppressed because this is a 7115 // device offloading action, or we passed device offload LTO options which 7116 // were suppressed because this is not the device offload action. 7117 // Otherwise, issue an error. 7118 else if (!D.isUsingLTO(!IsDeviceOffloadAction)) 7119 D.Diag(diag::err_drv_argument_only_allowed_with) 7120 << "-fwhole-program-vtables" 7121 << "-flto"; 7122 } 7123 7124 bool DefaultsSplitLTOUnit = 7125 (WholeProgramVTables || SanitizeArgs.needsLTO()) && 7126 (LTOMode == LTOK_Full || TC.canSplitThinLTOUnit()); 7127 bool SplitLTOUnit = 7128 Args.hasFlag(options::OPT_fsplit_lto_unit, 7129 options::OPT_fno_split_lto_unit, DefaultsSplitLTOUnit); 7130 if (SanitizeArgs.needsLTO() && !SplitLTOUnit) 7131 D.Diag(diag::err_drv_argument_not_allowed_with) << "-fno-split-lto-unit" 7132 << "-fsanitize=cfi"; 7133 if (SplitLTOUnit) 7134 CmdArgs.push_back("-fsplit-lto-unit"); 7135 7136 if (Arg *A = Args.getLastArg(options::OPT_fglobal_isel, 7137 options::OPT_fno_global_isel)) { 7138 CmdArgs.push_back("-mllvm"); 7139 if (A->getOption().matches(options::OPT_fglobal_isel)) { 7140 CmdArgs.push_back("-global-isel=1"); 7141 7142 // GISel is on by default on AArch64 -O0, so don't bother adding 7143 // the fallback remarks for it. Other combinations will add a warning of 7144 // some kind. 7145 bool IsArchSupported = Triple.getArch() == llvm::Triple::aarch64; 7146 bool IsOptLevelSupported = false; 7147 7148 Arg *A = Args.getLastArg(options::OPT_O_Group); 7149 if (Triple.getArch() == llvm::Triple::aarch64) { 7150 if (!A || A->getOption().matches(options::OPT_O0)) 7151 IsOptLevelSupported = true; 7152 } 7153 if (!IsArchSupported || !IsOptLevelSupported) { 7154 CmdArgs.push_back("-mllvm"); 7155 CmdArgs.push_back("-global-isel-abort=2"); 7156 7157 if (!IsArchSupported) 7158 D.Diag(diag::warn_drv_global_isel_incomplete) << Triple.getArchName(); 7159 else 7160 D.Diag(diag::warn_drv_global_isel_incomplete_opt); 7161 } 7162 } else { 7163 CmdArgs.push_back("-global-isel=0"); 7164 } 7165 } 7166 7167 if (Args.hasArg(options::OPT_forder_file_instrumentation)) { 7168 CmdArgs.push_back("-forder-file-instrumentation"); 7169 // Enable order file instrumentation when ThinLTO is not on. When ThinLTO is 7170 // on, we need to pass these flags as linker flags and that will be handled 7171 // outside of the compiler. 7172 if (!IsUsingLTO) { 7173 CmdArgs.push_back("-mllvm"); 7174 CmdArgs.push_back("-enable-order-file-instrumentation"); 7175 } 7176 } 7177 7178 if (Arg *A = Args.getLastArg(options::OPT_fforce_enable_int128, 7179 options::OPT_fno_force_enable_int128)) { 7180 if (A->getOption().matches(options::OPT_fforce_enable_int128)) 7181 CmdArgs.push_back("-fforce-enable-int128"); 7182 } 7183 7184 Args.addOptInFlag(CmdArgs, options::OPT_fkeep_static_consts, 7185 options::OPT_fno_keep_static_consts); 7186 Args.addOptInFlag(CmdArgs, options::OPT_fcomplete_member_pointers, 7187 options::OPT_fno_complete_member_pointers); 7188 7189 if (!Args.hasFlag(options::OPT_fcxx_static_destructors, 7190 options::OPT_fno_cxx_static_destructors, true)) 7191 CmdArgs.push_back("-fno-c++-static-destructors"); 7192 7193 addMachineOutlinerArgs(D, Args, CmdArgs, Triple, /*IsLTO=*/false); 7194 7195 if (Arg *A = Args.getLastArg(options::OPT_moutline_atomics, 7196 options::OPT_mno_outline_atomics)) { 7197 // Option -moutline-atomics supported for AArch64 target only. 7198 if (!Triple.isAArch64()) { 7199 D.Diag(diag::warn_drv_moutline_atomics_unsupported_opt) 7200 << Triple.getArchName() << A->getOption().getName(); 7201 } else { 7202 if (A->getOption().matches(options::OPT_moutline_atomics)) { 7203 CmdArgs.push_back("-target-feature"); 7204 CmdArgs.push_back("+outline-atomics"); 7205 } else { 7206 CmdArgs.push_back("-target-feature"); 7207 CmdArgs.push_back("-outline-atomics"); 7208 } 7209 } 7210 } else if (Triple.isAArch64() && 7211 getToolChain().IsAArch64OutlineAtomicsDefault(Args)) { 7212 CmdArgs.push_back("-target-feature"); 7213 CmdArgs.push_back("+outline-atomics"); 7214 } 7215 7216 if (Args.hasFlag(options::OPT_faddrsig, options::OPT_fno_addrsig, 7217 (TC.getTriple().isOSBinFormatELF() || 7218 TC.getTriple().isOSBinFormatCOFF()) && 7219 !TC.getTriple().isPS4() && !TC.getTriple().isVE() && 7220 !TC.getTriple().isOSNetBSD() && 7221 !Distro(D.getVFS(), TC.getTriple()).IsGentoo() && 7222 !TC.getTriple().isAndroid() && TC.useIntegratedAs())) 7223 CmdArgs.push_back("-faddrsig"); 7224 7225 if ((Triple.isOSBinFormatELF() || Triple.isOSBinFormatMachO()) && 7226 (EH || AsyncUnwindTables || UnwindTables || 7227 DebugInfoKind != codegenoptions::NoDebugInfo)) 7228 CmdArgs.push_back("-D__GCC_HAVE_DWARF2_CFI_ASM=1"); 7229 7230 if (Arg *A = Args.getLastArg(options::OPT_fsymbol_partition_EQ)) { 7231 std::string Str = A->getAsString(Args); 7232 if (!TC.getTriple().isOSBinFormatELF()) 7233 D.Diag(diag::err_drv_unsupported_opt_for_target) 7234 << Str << TC.getTripleString(); 7235 CmdArgs.push_back(Args.MakeArgString(Str)); 7236 } 7237 7238 // Add the output path to the object file for CodeView debug infos. 7239 if (EmitCodeView && Output.isFilename()) 7240 addDebugObjectName(Args, CmdArgs, DebugCompilationDir, 7241 Output.getFilename()); 7242 7243 // Add the "-o out -x type src.c" flags last. This is done primarily to make 7244 // the -cc1 command easier to edit when reproducing compiler crashes. 7245 if (Output.getType() == types::TY_Dependencies) { 7246 // Handled with other dependency code. 7247 } else if (Output.isFilename()) { 7248 if (Output.getType() == clang::driver::types::TY_IFS_CPP || 7249 Output.getType() == clang::driver::types::TY_IFS) { 7250 SmallString<128> OutputFilename(Output.getFilename()); 7251 llvm::sys::path::replace_extension(OutputFilename, "ifs"); 7252 CmdArgs.push_back("-o"); 7253 CmdArgs.push_back(Args.MakeArgString(OutputFilename)); 7254 } else { 7255 CmdArgs.push_back("-o"); 7256 CmdArgs.push_back(Output.getFilename()); 7257 } 7258 } else { 7259 assert(Output.isNothing() && "Invalid output."); 7260 } 7261 7262 addDashXForInput(Args, Input, CmdArgs); 7263 7264 ArrayRef<InputInfo> FrontendInputs = Input; 7265 if (IsHeaderModulePrecompile) 7266 FrontendInputs = ModuleHeaderInputs; 7267 else if (IsExtractAPI) 7268 FrontendInputs = ExtractAPIInputs; 7269 else if (Input.isNothing()) 7270 FrontendInputs = {}; 7271 7272 for (const InputInfo &Input : FrontendInputs) { 7273 if (Input.isFilename()) 7274 CmdArgs.push_back(Input.getFilename()); 7275 else 7276 Input.getInputArg().renderAsInput(Args, CmdArgs); 7277 } 7278 7279 if (D.CC1Main && !D.CCGenDiagnostics) { 7280 // Invoke the CC1 directly in this process 7281 C.addCommand(std::make_unique<CC1Command>(JA, *this, 7282 ResponseFileSupport::AtFileUTF8(), 7283 Exec, CmdArgs, Inputs, Output)); 7284 } else { 7285 C.addCommand(std::make_unique<Command>(JA, *this, 7286 ResponseFileSupport::AtFileUTF8(), 7287 Exec, CmdArgs, Inputs, Output)); 7288 } 7289 7290 // Make the compile command echo its inputs for /showFilenames. 7291 if (Output.getType() == types::TY_Object && 7292 Args.hasFlag(options::OPT__SLASH_showFilenames, 7293 options::OPT__SLASH_showFilenames_, false)) { 7294 C.getJobs().getJobs().back()->PrintInputFilenames = true; 7295 } 7296 7297 if (Arg *A = Args.getLastArg(options::OPT_pg)) 7298 if (FPKeepKind == CodeGenOptions::FramePointerKind::None && 7299 !Args.hasArg(options::OPT_mfentry)) 7300 D.Diag(diag::err_drv_argument_not_allowed_with) << "-fomit-frame-pointer" 7301 << A->getAsString(Args); 7302 7303 // Claim some arguments which clang supports automatically. 7304 7305 // -fpch-preprocess is used with gcc to add a special marker in the output to 7306 // include the PCH file. 7307 Args.ClaimAllArgs(options::OPT_fpch_preprocess); 7308 7309 // Claim some arguments which clang doesn't support, but we don't 7310 // care to warn the user about. 7311 Args.ClaimAllArgs(options::OPT_clang_ignored_f_Group); 7312 Args.ClaimAllArgs(options::OPT_clang_ignored_m_Group); 7313 7314 // Disable warnings for clang -E -emit-llvm foo.c 7315 Args.ClaimAllArgs(options::OPT_emit_llvm); 7316 } 7317 7318 Clang::Clang(const ToolChain &TC, bool HasIntegratedBackend) 7319 // CAUTION! The first constructor argument ("clang") is not arbitrary, 7320 // as it is for other tools. Some operations on a Tool actually test 7321 // whether that tool is Clang based on the Tool's Name as a string. 7322 : Tool("clang", "clang frontend", TC), HasBackend(HasIntegratedBackend) {} 7323 7324 Clang::~Clang() {} 7325 7326 /// Add options related to the Objective-C runtime/ABI. 7327 /// 7328 /// Returns true if the runtime is non-fragile. 7329 ObjCRuntime Clang::AddObjCRuntimeArgs(const ArgList &args, 7330 const InputInfoList &inputs, 7331 ArgStringList &cmdArgs, 7332 RewriteKind rewriteKind) const { 7333 // Look for the controlling runtime option. 7334 Arg *runtimeArg = 7335 args.getLastArg(options::OPT_fnext_runtime, options::OPT_fgnu_runtime, 7336 options::OPT_fobjc_runtime_EQ); 7337 7338 // Just forward -fobjc-runtime= to the frontend. This supercedes 7339 // options about fragility. 7340 if (runtimeArg && 7341 runtimeArg->getOption().matches(options::OPT_fobjc_runtime_EQ)) { 7342 ObjCRuntime runtime; 7343 StringRef value = runtimeArg->getValue(); 7344 if (runtime.tryParse(value)) { 7345 getToolChain().getDriver().Diag(diag::err_drv_unknown_objc_runtime) 7346 << value; 7347 } 7348 if ((runtime.getKind() == ObjCRuntime::GNUstep) && 7349 (runtime.getVersion() >= VersionTuple(2, 0))) 7350 if (!getToolChain().getTriple().isOSBinFormatELF() && 7351 !getToolChain().getTriple().isOSBinFormatCOFF()) { 7352 getToolChain().getDriver().Diag( 7353 diag::err_drv_gnustep_objc_runtime_incompatible_binary) 7354 << runtime.getVersion().getMajor(); 7355 } 7356 7357 runtimeArg->render(args, cmdArgs); 7358 return runtime; 7359 } 7360 7361 // Otherwise, we'll need the ABI "version". Version numbers are 7362 // slightly confusing for historical reasons: 7363 // 1 - Traditional "fragile" ABI 7364 // 2 - Non-fragile ABI, version 1 7365 // 3 - Non-fragile ABI, version 2 7366 unsigned objcABIVersion = 1; 7367 // If -fobjc-abi-version= is present, use that to set the version. 7368 if (Arg *abiArg = args.getLastArg(options::OPT_fobjc_abi_version_EQ)) { 7369 StringRef value = abiArg->getValue(); 7370 if (value == "1") 7371 objcABIVersion = 1; 7372 else if (value == "2") 7373 objcABIVersion = 2; 7374 else if (value == "3") 7375 objcABIVersion = 3; 7376 else 7377 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported) << value; 7378 } else { 7379 // Otherwise, determine if we are using the non-fragile ABI. 7380 bool nonFragileABIIsDefault = 7381 (rewriteKind == RK_NonFragile || 7382 (rewriteKind == RK_None && 7383 getToolChain().IsObjCNonFragileABIDefault())); 7384 if (args.hasFlag(options::OPT_fobjc_nonfragile_abi, 7385 options::OPT_fno_objc_nonfragile_abi, 7386 nonFragileABIIsDefault)) { 7387 // Determine the non-fragile ABI version to use. 7388 #ifdef DISABLE_DEFAULT_NONFRAGILEABI_TWO 7389 unsigned nonFragileABIVersion = 1; 7390 #else 7391 unsigned nonFragileABIVersion = 2; 7392 #endif 7393 7394 if (Arg *abiArg = 7395 args.getLastArg(options::OPT_fobjc_nonfragile_abi_version_EQ)) { 7396 StringRef value = abiArg->getValue(); 7397 if (value == "1") 7398 nonFragileABIVersion = 1; 7399 else if (value == "2") 7400 nonFragileABIVersion = 2; 7401 else 7402 getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported) 7403 << value; 7404 } 7405 7406 objcABIVersion = 1 + nonFragileABIVersion; 7407 } else { 7408 objcABIVersion = 1; 7409 } 7410 } 7411 7412 // We don't actually care about the ABI version other than whether 7413 // it's non-fragile. 7414 bool isNonFragile = objcABIVersion != 1; 7415 7416 // If we have no runtime argument, ask the toolchain for its default runtime. 7417 // However, the rewriter only really supports the Mac runtime, so assume that. 7418 ObjCRuntime runtime; 7419 if (!runtimeArg) { 7420 switch (rewriteKind) { 7421 case RK_None: 7422 runtime = getToolChain().getDefaultObjCRuntime(isNonFragile); 7423 break; 7424 case RK_Fragile: 7425 runtime = ObjCRuntime(ObjCRuntime::FragileMacOSX, VersionTuple()); 7426 break; 7427 case RK_NonFragile: 7428 runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple()); 7429 break; 7430 } 7431 7432 // -fnext-runtime 7433 } else if (runtimeArg->getOption().matches(options::OPT_fnext_runtime)) { 7434 // On Darwin, make this use the default behavior for the toolchain. 7435 if (getToolChain().getTriple().isOSDarwin()) { 7436 runtime = getToolChain().getDefaultObjCRuntime(isNonFragile); 7437 7438 // Otherwise, build for a generic macosx port. 7439 } else { 7440 runtime = ObjCRuntime(ObjCRuntime::MacOSX, VersionTuple()); 7441 } 7442 7443 // -fgnu-runtime 7444 } else { 7445 assert(runtimeArg->getOption().matches(options::OPT_fgnu_runtime)); 7446 // Legacy behaviour is to target the gnustep runtime if we are in 7447 // non-fragile mode or the GCC runtime in fragile mode. 7448 if (isNonFragile) 7449 runtime = ObjCRuntime(ObjCRuntime::GNUstep, VersionTuple(2, 0)); 7450 else 7451 runtime = ObjCRuntime(ObjCRuntime::GCC, VersionTuple()); 7452 } 7453 7454 if (llvm::any_of(inputs, [](const InputInfo &input) { 7455 return types::isObjC(input.getType()); 7456 })) 7457 cmdArgs.push_back( 7458 args.MakeArgString("-fobjc-runtime=" + runtime.getAsString())); 7459 return runtime; 7460 } 7461 7462 static bool maybeConsumeDash(const std::string &EH, size_t &I) { 7463 bool HaveDash = (I + 1 < EH.size() && EH[I + 1] == '-'); 7464 I += HaveDash; 7465 return !HaveDash; 7466 } 7467 7468 namespace { 7469 struct EHFlags { 7470 bool Synch = false; 7471 bool Asynch = false; 7472 bool NoUnwindC = false; 7473 }; 7474 } // end anonymous namespace 7475 7476 /// /EH controls whether to run destructor cleanups when exceptions are 7477 /// thrown. There are three modifiers: 7478 /// - s: Cleanup after "synchronous" exceptions, aka C++ exceptions. 7479 /// - a: Cleanup after "asynchronous" exceptions, aka structured exceptions. 7480 /// The 'a' modifier is unimplemented and fundamentally hard in LLVM IR. 7481 /// - c: Assume that extern "C" functions are implicitly nounwind. 7482 /// The default is /EHs-c-, meaning cleanups are disabled. 7483 static EHFlags parseClangCLEHFlags(const Driver &D, const ArgList &Args) { 7484 EHFlags EH; 7485 7486 std::vector<std::string> EHArgs = 7487 Args.getAllArgValues(options::OPT__SLASH_EH); 7488 for (auto EHVal : EHArgs) { 7489 for (size_t I = 0, E = EHVal.size(); I != E; ++I) { 7490 switch (EHVal[I]) { 7491 case 'a': 7492 EH.Asynch = maybeConsumeDash(EHVal, I); 7493 if (EH.Asynch) 7494 EH.Synch = false; 7495 continue; 7496 case 'c': 7497 EH.NoUnwindC = maybeConsumeDash(EHVal, I); 7498 continue; 7499 case 's': 7500 EH.Synch = maybeConsumeDash(EHVal, I); 7501 if (EH.Synch) 7502 EH.Asynch = false; 7503 continue; 7504 default: 7505 break; 7506 } 7507 D.Diag(clang::diag::err_drv_invalid_value) << "/EH" << EHVal; 7508 break; 7509 } 7510 } 7511 // The /GX, /GX- flags are only processed if there are not /EH flags. 7512 // The default is that /GX is not specified. 7513 if (EHArgs.empty() && 7514 Args.hasFlag(options::OPT__SLASH_GX, options::OPT__SLASH_GX_, 7515 /*Default=*/false)) { 7516 EH.Synch = true; 7517 EH.NoUnwindC = true; 7518 } 7519 7520 if (Args.hasArg(options::OPT__SLASH_kernel)) { 7521 EH.Synch = false; 7522 EH.NoUnwindC = false; 7523 EH.Asynch = false; 7524 } 7525 7526 return EH; 7527 } 7528 7529 void Clang::AddClangCLArgs(const ArgList &Args, types::ID InputType, 7530 ArgStringList &CmdArgs, 7531 codegenoptions::DebugInfoKind *DebugInfoKind, 7532 bool *EmitCodeView) const { 7533 unsigned RTOptionID = options::OPT__SLASH_MT; 7534 bool isNVPTX = getToolChain().getTriple().isNVPTX(); 7535 7536 if (Args.hasArg(options::OPT__SLASH_LDd)) 7537 // The /LDd option implies /MTd. The dependent lib part can be overridden, 7538 // but defining _DEBUG is sticky. 7539 RTOptionID = options::OPT__SLASH_MTd; 7540 7541 if (Arg *A = Args.getLastArg(options::OPT__SLASH_M_Group)) 7542 RTOptionID = A->getOption().getID(); 7543 7544 StringRef FlagForCRT; 7545 switch (RTOptionID) { 7546 case options::OPT__SLASH_MD: 7547 if (Args.hasArg(options::OPT__SLASH_LDd)) 7548 CmdArgs.push_back("-D_DEBUG"); 7549 CmdArgs.push_back("-D_MT"); 7550 CmdArgs.push_back("-D_DLL"); 7551 FlagForCRT = "--dependent-lib=msvcrt"; 7552 break; 7553 case options::OPT__SLASH_MDd: 7554 CmdArgs.push_back("-D_DEBUG"); 7555 CmdArgs.push_back("-D_MT"); 7556 CmdArgs.push_back("-D_DLL"); 7557 FlagForCRT = "--dependent-lib=msvcrtd"; 7558 break; 7559 case options::OPT__SLASH_MT: 7560 if (Args.hasArg(options::OPT__SLASH_LDd)) 7561 CmdArgs.push_back("-D_DEBUG"); 7562 CmdArgs.push_back("-D_MT"); 7563 CmdArgs.push_back("-flto-visibility-public-std"); 7564 FlagForCRT = "--dependent-lib=libcmt"; 7565 break; 7566 case options::OPT__SLASH_MTd: 7567 CmdArgs.push_back("-D_DEBUG"); 7568 CmdArgs.push_back("-D_MT"); 7569 CmdArgs.push_back("-flto-visibility-public-std"); 7570 FlagForCRT = "--dependent-lib=libcmtd"; 7571 break; 7572 default: 7573 llvm_unreachable("Unexpected option ID."); 7574 } 7575 7576 if (Args.hasArg(options::OPT__SLASH_Zl)) { 7577 CmdArgs.push_back("-D_VC_NODEFAULTLIB"); 7578 } else { 7579 CmdArgs.push_back(FlagForCRT.data()); 7580 7581 // This provides POSIX compatibility (maps 'open' to '_open'), which most 7582 // users want. The /Za flag to cl.exe turns this off, but it's not 7583 // implemented in clang. 7584 CmdArgs.push_back("--dependent-lib=oldnames"); 7585 } 7586 7587 if (Arg *ShowIncludes = 7588 Args.getLastArg(options::OPT__SLASH_showIncludes, 7589 options::OPT__SLASH_showIncludes_user)) { 7590 CmdArgs.push_back("--show-includes"); 7591 if (ShowIncludes->getOption().matches(options::OPT__SLASH_showIncludes)) 7592 CmdArgs.push_back("-sys-header-deps"); 7593 } 7594 7595 // This controls whether or not we emit RTTI data for polymorphic types. 7596 if (Args.hasFlag(options::OPT__SLASH_GR_, options::OPT__SLASH_GR, 7597 /*Default=*/false)) 7598 CmdArgs.push_back("-fno-rtti-data"); 7599 7600 // This controls whether or not we emit stack-protector instrumentation. 7601 // In MSVC, Buffer Security Check (/GS) is on by default. 7602 if (!isNVPTX && Args.hasFlag(options::OPT__SLASH_GS, options::OPT__SLASH_GS_, 7603 /*Default=*/true)) { 7604 CmdArgs.push_back("-stack-protector"); 7605 CmdArgs.push_back(Args.MakeArgString(Twine(LangOptions::SSPStrong))); 7606 } 7607 7608 // Emit CodeView if -Z7 or -gline-tables-only are present. 7609 if (Arg *DebugInfoArg = Args.getLastArg(options::OPT__SLASH_Z7, 7610 options::OPT_gline_tables_only)) { 7611 *EmitCodeView = true; 7612 if (DebugInfoArg->getOption().matches(options::OPT__SLASH_Z7)) 7613 *DebugInfoKind = codegenoptions::DebugInfoConstructor; 7614 else 7615 *DebugInfoKind = codegenoptions::DebugLineTablesOnly; 7616 } else { 7617 *EmitCodeView = false; 7618 } 7619 7620 const Driver &D = getToolChain().getDriver(); 7621 7622 // This controls whether or not we perform JustMyCode instrumentation. 7623 if (Args.hasFlag(options::OPT__SLASH_JMC, options::OPT__SLASH_JMC_, 7624 /*Default=*/false)) { 7625 if (*EmitCodeView && *DebugInfoKind >= codegenoptions::DebugInfoConstructor) 7626 CmdArgs.push_back("-fjmc"); 7627 else 7628 D.Diag(clang::diag::warn_drv_jmc_requires_debuginfo) << "/JMC" 7629 << "'/Zi', '/Z7'"; 7630 } 7631 7632 EHFlags EH = parseClangCLEHFlags(D, Args); 7633 if (!isNVPTX && (EH.Synch || EH.Asynch)) { 7634 if (types::isCXX(InputType)) 7635 CmdArgs.push_back("-fcxx-exceptions"); 7636 CmdArgs.push_back("-fexceptions"); 7637 } 7638 if (types::isCXX(InputType) && EH.Synch && EH.NoUnwindC) 7639 CmdArgs.push_back("-fexternc-nounwind"); 7640 7641 // /EP should expand to -E -P. 7642 if (Args.hasArg(options::OPT__SLASH_EP)) { 7643 CmdArgs.push_back("-E"); 7644 CmdArgs.push_back("-P"); 7645 } 7646 7647 unsigned VolatileOptionID; 7648 if (getToolChain().getTriple().isX86()) 7649 VolatileOptionID = options::OPT__SLASH_volatile_ms; 7650 else 7651 VolatileOptionID = options::OPT__SLASH_volatile_iso; 7652 7653 if (Arg *A = Args.getLastArg(options::OPT__SLASH_volatile_Group)) 7654 VolatileOptionID = A->getOption().getID(); 7655 7656 if (VolatileOptionID == options::OPT__SLASH_volatile_ms) 7657 CmdArgs.push_back("-fms-volatile"); 7658 7659 if (Args.hasFlag(options::OPT__SLASH_Zc_dllexportInlines_, 7660 options::OPT__SLASH_Zc_dllexportInlines, 7661 false)) { 7662 CmdArgs.push_back("-fno-dllexport-inlines"); 7663 } 7664 7665 if (Args.hasFlag(options::OPT__SLASH_Zc_wchar_t_, 7666 options::OPT__SLASH_Zc_wchar_t, false)) { 7667 CmdArgs.push_back("-fno-wchar"); 7668 } 7669 7670 if (Args.hasArg(options::OPT__SLASH_kernel)) { 7671 llvm::Triple::ArchType Arch = getToolChain().getArch(); 7672 std::vector<std::string> Values = 7673 Args.getAllArgValues(options::OPT__SLASH_arch); 7674 if (!Values.empty()) { 7675 llvm::SmallSet<std::string, 4> SupportedArches; 7676 if (Arch == llvm::Triple::x86) 7677 SupportedArches.insert("IA32"); 7678 7679 for (auto &V : Values) 7680 if (!SupportedArches.contains(V)) 7681 D.Diag(diag::err_drv_argument_not_allowed_with) 7682 << std::string("/arch:").append(V) << "/kernel"; 7683 } 7684 7685 CmdArgs.push_back("-fno-rtti"); 7686 if (Args.hasFlag(options::OPT__SLASH_GR, options::OPT__SLASH_GR_, false)) 7687 D.Diag(diag::err_drv_argument_not_allowed_with) << "/GR" 7688 << "/kernel"; 7689 } 7690 7691 Arg *MostGeneralArg = Args.getLastArg(options::OPT__SLASH_vmg); 7692 Arg *BestCaseArg = Args.getLastArg(options::OPT__SLASH_vmb); 7693 if (MostGeneralArg && BestCaseArg) 7694 D.Diag(clang::diag::err_drv_argument_not_allowed_with) 7695 << MostGeneralArg->getAsString(Args) << BestCaseArg->getAsString(Args); 7696 7697 if (MostGeneralArg) { 7698 Arg *SingleArg = Args.getLastArg(options::OPT__SLASH_vms); 7699 Arg *MultipleArg = Args.getLastArg(options::OPT__SLASH_vmm); 7700 Arg *VirtualArg = Args.getLastArg(options::OPT__SLASH_vmv); 7701 7702 Arg *FirstConflict = SingleArg ? SingleArg : MultipleArg; 7703 Arg *SecondConflict = VirtualArg ? VirtualArg : MultipleArg; 7704 if (FirstConflict && SecondConflict && FirstConflict != SecondConflict) 7705 D.Diag(clang::diag::err_drv_argument_not_allowed_with) 7706 << FirstConflict->getAsString(Args) 7707 << SecondConflict->getAsString(Args); 7708 7709 if (SingleArg) 7710 CmdArgs.push_back("-fms-memptr-rep=single"); 7711 else if (MultipleArg) 7712 CmdArgs.push_back("-fms-memptr-rep=multiple"); 7713 else 7714 CmdArgs.push_back("-fms-memptr-rep=virtual"); 7715 } 7716 7717 // Parse the default calling convention options. 7718 if (Arg *CCArg = 7719 Args.getLastArg(options::OPT__SLASH_Gd, options::OPT__SLASH_Gr, 7720 options::OPT__SLASH_Gz, options::OPT__SLASH_Gv, 7721 options::OPT__SLASH_Gregcall)) { 7722 unsigned DCCOptId = CCArg->getOption().getID(); 7723 const char *DCCFlag = nullptr; 7724 bool ArchSupported = !isNVPTX; 7725 llvm::Triple::ArchType Arch = getToolChain().getArch(); 7726 switch (DCCOptId) { 7727 case options::OPT__SLASH_Gd: 7728 DCCFlag = "-fdefault-calling-conv=cdecl"; 7729 break; 7730 case options::OPT__SLASH_Gr: 7731 ArchSupported = Arch == llvm::Triple::x86; 7732 DCCFlag = "-fdefault-calling-conv=fastcall"; 7733 break; 7734 case options::OPT__SLASH_Gz: 7735 ArchSupported = Arch == llvm::Triple::x86; 7736 DCCFlag = "-fdefault-calling-conv=stdcall"; 7737 break; 7738 case options::OPT__SLASH_Gv: 7739 ArchSupported = Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64; 7740 DCCFlag = "-fdefault-calling-conv=vectorcall"; 7741 break; 7742 case options::OPT__SLASH_Gregcall: 7743 ArchSupported = Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64; 7744 DCCFlag = "-fdefault-calling-conv=regcall"; 7745 break; 7746 } 7747 7748 // MSVC doesn't warn if /Gr or /Gz is used on x64, so we don't either. 7749 if (ArchSupported && DCCFlag) 7750 CmdArgs.push_back(DCCFlag); 7751 } 7752 7753 Args.AddLastArg(CmdArgs, options::OPT_vtordisp_mode_EQ); 7754 7755 if (!Args.hasArg(options::OPT_fdiagnostics_format_EQ)) { 7756 CmdArgs.push_back("-fdiagnostics-format"); 7757 CmdArgs.push_back("msvc"); 7758 } 7759 7760 if (Args.hasArg(options::OPT__SLASH_kernel)) 7761 CmdArgs.push_back("-fms-kernel"); 7762 7763 if (Arg *A = Args.getLastArg(options::OPT__SLASH_guard)) { 7764 StringRef GuardArgs = A->getValue(); 7765 // The only valid options are "cf", "cf,nochecks", "cf-", "ehcont" and 7766 // "ehcont-". 7767 if (GuardArgs.equals_insensitive("cf")) { 7768 // Emit CFG instrumentation and the table of address-taken functions. 7769 CmdArgs.push_back("-cfguard"); 7770 } else if (GuardArgs.equals_insensitive("cf,nochecks")) { 7771 // Emit only the table of address-taken functions. 7772 CmdArgs.push_back("-cfguard-no-checks"); 7773 } else if (GuardArgs.equals_insensitive("ehcont")) { 7774 // Emit EH continuation table. 7775 CmdArgs.push_back("-ehcontguard"); 7776 } else if (GuardArgs.equals_insensitive("cf-") || 7777 GuardArgs.equals_insensitive("ehcont-")) { 7778 // Do nothing, but we might want to emit a security warning in future. 7779 } else { 7780 D.Diag(diag::err_drv_invalid_value) << A->getSpelling() << GuardArgs; 7781 } 7782 } 7783 } 7784 7785 const char *Clang::getBaseInputName(const ArgList &Args, 7786 const InputInfo &Input) { 7787 return Args.MakeArgString(llvm::sys::path::filename(Input.getBaseInput())); 7788 } 7789 7790 const char *Clang::getBaseInputStem(const ArgList &Args, 7791 const InputInfoList &Inputs) { 7792 const char *Str = getBaseInputName(Args, Inputs[0]); 7793 7794 if (const char *End = strrchr(Str, '.')) 7795 return Args.MakeArgString(std::string(Str, End)); 7796 7797 return Str; 7798 } 7799 7800 const char *Clang::getDependencyFileName(const ArgList &Args, 7801 const InputInfoList &Inputs) { 7802 // FIXME: Think about this more. 7803 7804 if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) { 7805 SmallString<128> OutputFilename(OutputOpt->getValue()); 7806 llvm::sys::path::replace_extension(OutputFilename, llvm::Twine('d')); 7807 return Args.MakeArgString(OutputFilename); 7808 } 7809 7810 return Args.MakeArgString(Twine(getBaseInputStem(Args, Inputs)) + ".d"); 7811 } 7812 7813 // Begin ClangAs 7814 7815 void ClangAs::AddMIPSTargetArgs(const ArgList &Args, 7816 ArgStringList &CmdArgs) const { 7817 StringRef CPUName; 7818 StringRef ABIName; 7819 const llvm::Triple &Triple = getToolChain().getTriple(); 7820 mips::getMipsCPUAndABI(Args, Triple, CPUName, ABIName); 7821 7822 CmdArgs.push_back("-target-abi"); 7823 CmdArgs.push_back(ABIName.data()); 7824 } 7825 7826 void ClangAs::AddX86TargetArgs(const ArgList &Args, 7827 ArgStringList &CmdArgs) const { 7828 addX86AlignBranchArgs(getToolChain().getDriver(), Args, CmdArgs, 7829 /*IsLTO=*/false); 7830 7831 if (Arg *A = Args.getLastArg(options::OPT_masm_EQ)) { 7832 StringRef Value = A->getValue(); 7833 if (Value == "intel" || Value == "att") { 7834 CmdArgs.push_back("-mllvm"); 7835 CmdArgs.push_back(Args.MakeArgString("-x86-asm-syntax=" + Value)); 7836 } else { 7837 getToolChain().getDriver().Diag(diag::err_drv_unsupported_option_argument) 7838 << A->getOption().getName() << Value; 7839 } 7840 } 7841 } 7842 7843 void ClangAs::AddRISCVTargetArgs(const ArgList &Args, 7844 ArgStringList &CmdArgs) const { 7845 const llvm::Triple &Triple = getToolChain().getTriple(); 7846 StringRef ABIName = riscv::getRISCVABI(Args, Triple); 7847 7848 CmdArgs.push_back("-target-abi"); 7849 CmdArgs.push_back(ABIName.data()); 7850 } 7851 7852 void ClangAs::ConstructJob(Compilation &C, const JobAction &JA, 7853 const InputInfo &Output, const InputInfoList &Inputs, 7854 const ArgList &Args, 7855 const char *LinkingOutput) const { 7856 ArgStringList CmdArgs; 7857 7858 assert(Inputs.size() == 1 && "Unexpected number of inputs."); 7859 const InputInfo &Input = Inputs[0]; 7860 7861 const llvm::Triple &Triple = getToolChain().getEffectiveTriple(); 7862 const std::string &TripleStr = Triple.getTriple(); 7863 const Optional<llvm::Triple> TargetVariantTriple = 7864 getToolChain().getTargetVariantTriple(); 7865 const auto &D = getToolChain().getDriver(); 7866 7867 // Don't warn about "clang -w -c foo.s" 7868 Args.ClaimAllArgs(options::OPT_w); 7869 // and "clang -emit-llvm -c foo.s" 7870 Args.ClaimAllArgs(options::OPT_emit_llvm); 7871 7872 claimNoWarnArgs(Args); 7873 7874 // Invoke ourselves in -cc1as mode. 7875 // 7876 // FIXME: Implement custom jobs for internal actions. 7877 CmdArgs.push_back("-cc1as"); 7878 7879 // Add the "effective" target triple. 7880 CmdArgs.push_back("-triple"); 7881 CmdArgs.push_back(Args.MakeArgString(TripleStr)); 7882 if (TargetVariantTriple) { 7883 CmdArgs.push_back("-darwin-target-variant-triple"); 7884 CmdArgs.push_back(Args.MakeArgString(TargetVariantTriple->getTriple())); 7885 } 7886 7887 // Set the output mode, we currently only expect to be used as a real 7888 // assembler. 7889 CmdArgs.push_back("-filetype"); 7890 CmdArgs.push_back("obj"); 7891 7892 // Set the main file name, so that debug info works even with 7893 // -save-temps or preprocessed assembly. 7894 CmdArgs.push_back("-main-file-name"); 7895 CmdArgs.push_back(Clang::getBaseInputName(Args, Input)); 7896 7897 // Add the target cpu 7898 std::string CPU = getCPUName(D, Args, Triple, /*FromAs*/ true); 7899 if (!CPU.empty()) { 7900 CmdArgs.push_back("-target-cpu"); 7901 CmdArgs.push_back(Args.MakeArgString(CPU)); 7902 } 7903 7904 // Add the target features 7905 getTargetFeatures(D, Triple, Args, CmdArgs, true); 7906 7907 // Ignore explicit -force_cpusubtype_ALL option. 7908 (void)Args.hasArg(options::OPT_force__cpusubtype__ALL); 7909 7910 // Pass along any -I options so we get proper .include search paths. 7911 Args.AddAllArgs(CmdArgs, options::OPT_I_Group); 7912 7913 // Determine the original source input. 7914 auto FindSource = [](const Action *S) -> const Action * { 7915 while (S->getKind() != Action::InputClass) { 7916 assert(!S->getInputs().empty() && "unexpected root action!"); 7917 S = S->getInputs()[0]; 7918 } 7919 return S; 7920 }; 7921 const Action *SourceAction = FindSource(&JA); 7922 7923 // Forward -g and handle debug info related flags, assuming we are dealing 7924 // with an actual assembly file. 7925 bool WantDebug = false; 7926 Args.ClaimAllArgs(options::OPT_g_Group); 7927 if (Arg *A = Args.getLastArg(options::OPT_g_Group)) 7928 WantDebug = !A->getOption().matches(options::OPT_g0) && 7929 !A->getOption().matches(options::OPT_ggdb0); 7930 7931 unsigned DwarfVersion = ParseDebugDefaultVersion(getToolChain(), Args); 7932 if (const Arg *GDwarfN = getDwarfNArg(Args)) 7933 DwarfVersion = DwarfVersionNum(GDwarfN->getSpelling()); 7934 7935 if (DwarfVersion == 0) 7936 DwarfVersion = getToolChain().GetDefaultDwarfVersion(); 7937 7938 codegenoptions::DebugInfoKind DebugInfoKind = codegenoptions::NoDebugInfo; 7939 7940 // Add the -fdebug-compilation-dir flag if needed. 7941 const char *DebugCompilationDir = 7942 addDebugCompDirArg(Args, CmdArgs, C.getDriver().getVFS()); 7943 7944 if (SourceAction->getType() == types::TY_Asm || 7945 SourceAction->getType() == types::TY_PP_Asm) { 7946 // You might think that it would be ok to set DebugInfoKind outside of 7947 // the guard for source type, however there is a test which asserts 7948 // that some assembler invocation receives no -debug-info-kind, 7949 // and it's not clear whether that test is just overly restrictive. 7950 DebugInfoKind = (WantDebug ? codegenoptions::DebugInfoConstructor 7951 : codegenoptions::NoDebugInfo); 7952 7953 addDebugPrefixMapArg(getToolChain().getDriver(), getToolChain(), Args, 7954 CmdArgs); 7955 7956 // Set the AT_producer to the clang version when using the integrated 7957 // assembler on assembly source files. 7958 CmdArgs.push_back("-dwarf-debug-producer"); 7959 CmdArgs.push_back(Args.MakeArgString(getClangFullVersion())); 7960 7961 // And pass along -I options 7962 Args.AddAllArgs(CmdArgs, options::OPT_I); 7963 } 7964 RenderDebugEnablingArgs(Args, CmdArgs, DebugInfoKind, DwarfVersion, 7965 llvm::DebuggerKind::Default); 7966 renderDwarfFormat(D, Triple, Args, CmdArgs, DwarfVersion); 7967 RenderDebugInfoCompressionArgs(Args, CmdArgs, D, getToolChain()); 7968 7969 // Handle -fPIC et al -- the relocation-model affects the assembler 7970 // for some targets. 7971 llvm::Reloc::Model RelocationModel; 7972 unsigned PICLevel; 7973 bool IsPIE; 7974 std::tie(RelocationModel, PICLevel, IsPIE) = 7975 ParsePICArgs(getToolChain(), Args); 7976 7977 const char *RMName = RelocationModelName(RelocationModel); 7978 if (RMName) { 7979 CmdArgs.push_back("-mrelocation-model"); 7980 CmdArgs.push_back(RMName); 7981 } 7982 7983 // Optionally embed the -cc1as level arguments into the debug info, for build 7984 // analysis. 7985 if (getToolChain().UseDwarfDebugFlags()) { 7986 ArgStringList OriginalArgs; 7987 for (const auto &Arg : Args) 7988 Arg->render(Args, OriginalArgs); 7989 7990 SmallString<256> Flags; 7991 const char *Exec = getToolChain().getDriver().getClangProgramPath(); 7992 EscapeSpacesAndBackslashes(Exec, Flags); 7993 for (const char *OriginalArg : OriginalArgs) { 7994 SmallString<128> EscapedArg; 7995 EscapeSpacesAndBackslashes(OriginalArg, EscapedArg); 7996 Flags += " "; 7997 Flags += EscapedArg; 7998 } 7999 CmdArgs.push_back("-dwarf-debug-flags"); 8000 CmdArgs.push_back(Args.MakeArgString(Flags)); 8001 } 8002 8003 // FIXME: Add -static support, once we have it. 8004 8005 // Add target specific flags. 8006 switch (getToolChain().getArch()) { 8007 default: 8008 break; 8009 8010 case llvm::Triple::mips: 8011 case llvm::Triple::mipsel: 8012 case llvm::Triple::mips64: 8013 case llvm::Triple::mips64el: 8014 AddMIPSTargetArgs(Args, CmdArgs); 8015 break; 8016 8017 case llvm::Triple::x86: 8018 case llvm::Triple::x86_64: 8019 AddX86TargetArgs(Args, CmdArgs); 8020 break; 8021 8022 case llvm::Triple::arm: 8023 case llvm::Triple::armeb: 8024 case llvm::Triple::thumb: 8025 case llvm::Triple::thumbeb: 8026 // This isn't in AddARMTargetArgs because we want to do this for assembly 8027 // only, not C/C++. 8028 if (Args.hasFlag(options::OPT_mdefault_build_attributes, 8029 options::OPT_mno_default_build_attributes, true)) { 8030 CmdArgs.push_back("-mllvm"); 8031 CmdArgs.push_back("-arm-add-build-attributes"); 8032 } 8033 break; 8034 8035 case llvm::Triple::aarch64: 8036 case llvm::Triple::aarch64_32: 8037 case llvm::Triple::aarch64_be: 8038 if (Args.hasArg(options::OPT_mmark_bti_property)) { 8039 CmdArgs.push_back("-mllvm"); 8040 CmdArgs.push_back("-aarch64-mark-bti-property"); 8041 } 8042 break; 8043 8044 case llvm::Triple::riscv32: 8045 case llvm::Triple::riscv64: 8046 AddRISCVTargetArgs(Args, CmdArgs); 8047 break; 8048 } 8049 8050 // Consume all the warning flags. Usually this would be handled more 8051 // gracefully by -cc1 (warning about unknown warning flags, etc) but -cc1as 8052 // doesn't handle that so rather than warning about unused flags that are 8053 // actually used, we'll lie by omission instead. 8054 // FIXME: Stop lying and consume only the appropriate driver flags 8055 Args.ClaimAllArgs(options::OPT_W_Group); 8056 8057 CollectArgsForIntegratedAssembler(C, Args, CmdArgs, 8058 getToolChain().getDriver()); 8059 8060 Args.AddAllArgs(CmdArgs, options::OPT_mllvm); 8061 8062 if (DebugInfoKind > codegenoptions::NoDebugInfo && Output.isFilename()) 8063 addDebugObjectName(Args, CmdArgs, DebugCompilationDir, 8064 Output.getFilename()); 8065 8066 // Fixup any previous commands that use -object-file-name because when we 8067 // generated them, the final .obj name wasn't yet known. 8068 for (Command &J : C.getJobs()) { 8069 if (SourceAction != FindSource(&J.getSource())) 8070 continue; 8071 auto &JArgs = J.getArguments(); 8072 for (unsigned I = 0; I < JArgs.size(); ++I) { 8073 if (StringRef(JArgs[I]).startswith("-object-file-name=") && 8074 Output.isFilename()) { 8075 ArgStringList NewArgs(JArgs.begin(), JArgs.begin() + I); 8076 addDebugObjectName(Args, NewArgs, DebugCompilationDir, 8077 Output.getFilename()); 8078 NewArgs.append(JArgs.begin() + I + 1, JArgs.end()); 8079 J.replaceArguments(NewArgs); 8080 break; 8081 } 8082 } 8083 } 8084 8085 assert(Output.isFilename() && "Unexpected lipo output."); 8086 CmdArgs.push_back("-o"); 8087 CmdArgs.push_back(Output.getFilename()); 8088 8089 const llvm::Triple &T = getToolChain().getTriple(); 8090 Arg *A; 8091 if (getDebugFissionKind(D, Args, A) == DwarfFissionKind::Split && 8092 T.isOSBinFormatELF()) { 8093 CmdArgs.push_back("-split-dwarf-output"); 8094 CmdArgs.push_back(SplitDebugName(JA, Args, Input, Output)); 8095 } 8096 8097 if (Triple.isAMDGPU()) 8098 handleAMDGPUCodeObjectVersionOptions(D, Args, CmdArgs, /*IsCC1As=*/true); 8099 8100 assert(Input.isFilename() && "Invalid input."); 8101 CmdArgs.push_back(Input.getFilename()); 8102 8103 const char *Exec = getToolChain().getDriver().getClangProgramPath(); 8104 if (D.CC1Main && !D.CCGenDiagnostics) { 8105 // Invoke cc1as directly in this process. 8106 C.addCommand(std::make_unique<CC1Command>(JA, *this, 8107 ResponseFileSupport::AtFileUTF8(), 8108 Exec, CmdArgs, Inputs, Output)); 8109 } else { 8110 C.addCommand(std::make_unique<Command>(JA, *this, 8111 ResponseFileSupport::AtFileUTF8(), 8112 Exec, CmdArgs, Inputs, Output)); 8113 } 8114 } 8115 8116 // Begin OffloadBundler 8117 8118 void OffloadBundler::ConstructJob(Compilation &C, const JobAction &JA, 8119 const InputInfo &Output, 8120 const InputInfoList &Inputs, 8121 const llvm::opt::ArgList &TCArgs, 8122 const char *LinkingOutput) const { 8123 // The version with only one output is expected to refer to a bundling job. 8124 assert(isa<OffloadBundlingJobAction>(JA) && "Expecting bundling job!"); 8125 8126 // The bundling command looks like this: 8127 // clang-offload-bundler -type=bc 8128 // -targets=host-triple,openmp-triple1,openmp-triple2 8129 // -output=output_file 8130 // -input=unbundle_file_host 8131 // -input=unbundle_file_tgt1 8132 // -input=unbundle_file_tgt2 8133 8134 ArgStringList CmdArgs; 8135 8136 // Get the type. 8137 CmdArgs.push_back(TCArgs.MakeArgString( 8138 Twine("-type=") + types::getTypeTempSuffix(Output.getType()))); 8139 8140 assert(JA.getInputs().size() == Inputs.size() && 8141 "Not have inputs for all dependence actions??"); 8142 8143 // Get the targets. 8144 SmallString<128> Triples; 8145 Triples += "-targets="; 8146 for (unsigned I = 0; I < Inputs.size(); ++I) { 8147 if (I) 8148 Triples += ','; 8149 8150 // Find ToolChain for this input. 8151 Action::OffloadKind CurKind = Action::OFK_Host; 8152 const ToolChain *CurTC = &getToolChain(); 8153 const Action *CurDep = JA.getInputs()[I]; 8154 8155 if (const auto *OA = dyn_cast<OffloadAction>(CurDep)) { 8156 CurTC = nullptr; 8157 OA->doOnEachDependence([&](Action *A, const ToolChain *TC, const char *) { 8158 assert(CurTC == nullptr && "Expected one dependence!"); 8159 CurKind = A->getOffloadingDeviceKind(); 8160 CurTC = TC; 8161 }); 8162 } 8163 Triples += Action::GetOffloadKindName(CurKind); 8164 Triples += '-'; 8165 Triples += CurTC->getTriple().normalize(); 8166 if ((CurKind == Action::OFK_HIP || CurKind == Action::OFK_Cuda) && 8167 !StringRef(CurDep->getOffloadingArch()).empty()) { 8168 Triples += '-'; 8169 Triples += CurDep->getOffloadingArch(); 8170 } 8171 8172 // TODO: Replace parsing of -march flag. Can be done by storing GPUArch 8173 // with each toolchain. 8174 StringRef GPUArchName; 8175 if (CurKind == Action::OFK_OpenMP) { 8176 // Extract GPUArch from -march argument in TC argument list. 8177 for (unsigned ArgIndex = 0; ArgIndex < TCArgs.size(); ArgIndex++) { 8178 auto ArchStr = StringRef(TCArgs.getArgString(ArgIndex)); 8179 auto Arch = ArchStr.startswith_insensitive("-march="); 8180 if (Arch) { 8181 GPUArchName = ArchStr.substr(7); 8182 Triples += "-"; 8183 break; 8184 } 8185 } 8186 Triples += GPUArchName.str(); 8187 } 8188 } 8189 CmdArgs.push_back(TCArgs.MakeArgString(Triples)); 8190 8191 // Get bundled file command. 8192 CmdArgs.push_back( 8193 TCArgs.MakeArgString(Twine("-output=") + Output.getFilename())); 8194 8195 // Get unbundled files command. 8196 for (unsigned I = 0; I < Inputs.size(); ++I) { 8197 SmallString<128> UB; 8198 UB += "-input="; 8199 8200 // Find ToolChain for this input. 8201 const ToolChain *CurTC = &getToolChain(); 8202 if (const auto *OA = dyn_cast<OffloadAction>(JA.getInputs()[I])) { 8203 CurTC = nullptr; 8204 OA->doOnEachDependence([&](Action *, const ToolChain *TC, const char *) { 8205 assert(CurTC == nullptr && "Expected one dependence!"); 8206 CurTC = TC; 8207 }); 8208 UB += C.addTempFile( 8209 C.getArgs().MakeArgString(CurTC->getInputFilename(Inputs[I]))); 8210 } else { 8211 UB += CurTC->getInputFilename(Inputs[I]); 8212 } 8213 CmdArgs.push_back(TCArgs.MakeArgString(UB)); 8214 } 8215 // All the inputs are encoded as commands. 8216 C.addCommand(std::make_unique<Command>( 8217 JA, *this, ResponseFileSupport::None(), 8218 TCArgs.MakeArgString(getToolChain().GetProgramPath(getShortName())), 8219 CmdArgs, None, Output)); 8220 } 8221 8222 void OffloadBundler::ConstructJobMultipleOutputs( 8223 Compilation &C, const JobAction &JA, const InputInfoList &Outputs, 8224 const InputInfoList &Inputs, const llvm::opt::ArgList &TCArgs, 8225 const char *LinkingOutput) const { 8226 // The version with multiple outputs is expected to refer to a unbundling job. 8227 auto &UA = cast<OffloadUnbundlingJobAction>(JA); 8228 8229 // The unbundling command looks like this: 8230 // clang-offload-bundler -type=bc 8231 // -targets=host-triple,openmp-triple1,openmp-triple2 8232 // -input=input_file 8233 // -output=unbundle_file_host 8234 // -output=unbundle_file_tgt1 8235 // -output=unbundle_file_tgt2 8236 // -unbundle 8237 8238 ArgStringList CmdArgs; 8239 8240 assert(Inputs.size() == 1 && "Expecting to unbundle a single file!"); 8241 InputInfo Input = Inputs.front(); 8242 8243 // Get the type. 8244 CmdArgs.push_back(TCArgs.MakeArgString( 8245 Twine("-type=") + types::getTypeTempSuffix(Input.getType()))); 8246 8247 // Get the targets. 8248 SmallString<128> Triples; 8249 Triples += "-targets="; 8250 auto DepInfo = UA.getDependentActionsInfo(); 8251 for (unsigned I = 0; I < DepInfo.size(); ++I) { 8252 if (I) 8253 Triples += ','; 8254 8255 auto &Dep = DepInfo[I]; 8256 Triples += Action::GetOffloadKindName(Dep.DependentOffloadKind); 8257 Triples += '-'; 8258 Triples += Dep.DependentToolChain->getTriple().normalize(); 8259 if ((Dep.DependentOffloadKind == Action::OFK_HIP || 8260 Dep.DependentOffloadKind == Action::OFK_Cuda) && 8261 !Dep.DependentBoundArch.empty()) { 8262 Triples += '-'; 8263 Triples += Dep.DependentBoundArch; 8264 } 8265 // TODO: Replace parsing of -march flag. Can be done by storing GPUArch 8266 // with each toolchain. 8267 StringRef GPUArchName; 8268 if (Dep.DependentOffloadKind == Action::OFK_OpenMP) { 8269 // Extract GPUArch from -march argument in TC argument list. 8270 for (unsigned ArgIndex = 0; ArgIndex < TCArgs.size(); ArgIndex++) { 8271 StringRef ArchStr = StringRef(TCArgs.getArgString(ArgIndex)); 8272 auto Arch = ArchStr.startswith_insensitive("-march="); 8273 if (Arch) { 8274 GPUArchName = ArchStr.substr(7); 8275 Triples += "-"; 8276 break; 8277 } 8278 } 8279 Triples += GPUArchName.str(); 8280 } 8281 } 8282 8283 CmdArgs.push_back(TCArgs.MakeArgString(Triples)); 8284 8285 // Get bundled file command. 8286 CmdArgs.push_back( 8287 TCArgs.MakeArgString(Twine("-input=") + Input.getFilename())); 8288 8289 // Get unbundled files command. 8290 for (unsigned I = 0; I < Outputs.size(); ++I) { 8291 SmallString<128> UB; 8292 UB += "-output="; 8293 UB += DepInfo[I].DependentToolChain->getInputFilename(Outputs[I]); 8294 CmdArgs.push_back(TCArgs.MakeArgString(UB)); 8295 } 8296 CmdArgs.push_back("-unbundle"); 8297 CmdArgs.push_back("-allow-missing-bundles"); 8298 8299 // All the inputs are encoded as commands. 8300 C.addCommand(std::make_unique<Command>( 8301 JA, *this, ResponseFileSupport::None(), 8302 TCArgs.MakeArgString(getToolChain().GetProgramPath(getShortName())), 8303 CmdArgs, None, Outputs)); 8304 } 8305 8306 void OffloadWrapper::ConstructJob(Compilation &C, const JobAction &JA, 8307 const InputInfo &Output, 8308 const InputInfoList &Inputs, 8309 const ArgList &Args, 8310 const char *LinkingOutput) const { 8311 ArgStringList CmdArgs; 8312 8313 const llvm::Triple &Triple = getToolChain().getEffectiveTriple(); 8314 8315 // Add the "effective" target triple. 8316 CmdArgs.push_back("-target"); 8317 CmdArgs.push_back(Args.MakeArgString(Triple.getTriple())); 8318 8319 // Add the output file name. 8320 assert(Output.isFilename() && "Invalid output."); 8321 CmdArgs.push_back("-o"); 8322 CmdArgs.push_back(Output.getFilename()); 8323 8324 // Add inputs. 8325 for (const InputInfo &I : Inputs) { 8326 assert(I.isFilename() && "Invalid input."); 8327 CmdArgs.push_back(I.getFilename()); 8328 } 8329 8330 C.addCommand(std::make_unique<Command>( 8331 JA, *this, ResponseFileSupport::None(), 8332 Args.MakeArgString(getToolChain().GetProgramPath(getShortName())), 8333 CmdArgs, Inputs, Output)); 8334 } 8335 8336 void OffloadPackager::ConstructJob(Compilation &C, const JobAction &JA, 8337 const InputInfo &Output, 8338 const InputInfoList &Inputs, 8339 const llvm::opt::ArgList &Args, 8340 const char *LinkingOutput) const { 8341 ArgStringList CmdArgs; 8342 8343 // Add the output file name. 8344 assert(Output.isFilename() && "Invalid output."); 8345 CmdArgs.push_back("-o"); 8346 CmdArgs.push_back(Output.getFilename()); 8347 8348 // Create the inputs to bundle the needed metadata. 8349 for (const InputInfo &Input : Inputs) { 8350 const Action *OffloadAction = Input.getAction(); 8351 const ToolChain *TC = OffloadAction->getOffloadingToolChain(); 8352 const ArgList &TCArgs = 8353 C.getArgsForToolChain(TC, OffloadAction->getOffloadingArch(), 8354 OffloadAction->getOffloadingDeviceKind()); 8355 StringRef File = C.getArgs().MakeArgString(TC->getInputFilename(Input)); 8356 StringRef Arch = (OffloadAction->getOffloadingArch()) 8357 ? OffloadAction->getOffloadingArch() 8358 : TCArgs.getLastArgValue(options::OPT_march_EQ); 8359 StringRef Kind = 8360 Action::GetOffloadKindName(OffloadAction->getOffloadingDeviceKind()); 8361 8362 ArgStringList Features; 8363 SmallVector<StringRef> FeatureArgs; 8364 getTargetFeatures(TC->getDriver(), TC->getTriple(), TCArgs, Features, 8365 false); 8366 llvm::copy_if(Features, std::back_inserter(FeatureArgs), 8367 [](StringRef Arg) { return !Arg.startswith("-target"); }); 8368 8369 SmallVector<std::string> Parts{ 8370 "file=" + File.str(), 8371 "triple=" + TC->getTripleString(), 8372 "arch=" + Arch.str(), 8373 "kind=" + Kind.str(), 8374 }; 8375 8376 if (TC->getDriver().isUsingLTO(/* IsOffload */ true)) 8377 for (StringRef Feature : FeatureArgs) 8378 Parts.emplace_back("feature=" + Feature.str()); 8379 8380 CmdArgs.push_back(Args.MakeArgString("--image=" + llvm::join(Parts, ","))); 8381 } 8382 8383 C.addCommand(std::make_unique<Command>( 8384 JA, *this, ResponseFileSupport::None(), 8385 Args.MakeArgString(getToolChain().GetProgramPath(getShortName())), 8386 CmdArgs, Inputs, Output)); 8387 } 8388 8389 void LinkerWrapper::ConstructJob(Compilation &C, const JobAction &JA, 8390 const InputInfo &Output, 8391 const InputInfoList &Inputs, 8392 const ArgList &Args, 8393 const char *LinkingOutput) const { 8394 const Driver &D = getToolChain().getDriver(); 8395 const llvm::Triple TheTriple = getToolChain().getTriple(); 8396 auto OpenMPTCRange = C.getOffloadToolChains<Action::OFK_OpenMP>(); 8397 ArgStringList CmdArgs; 8398 8399 // Pass the CUDA path to the linker wrapper tool. 8400 for (Action::OffloadKind Kind : {Action::OFK_Cuda, Action::OFK_OpenMP}) { 8401 auto TCRange = C.getOffloadToolChains(Kind); 8402 for (auto &I : llvm::make_range(TCRange.first, TCRange.second)) { 8403 const ToolChain *TC = I.second; 8404 if (TC->getTriple().isNVPTX()) { 8405 CudaInstallationDetector CudaInstallation(D, TheTriple, Args); 8406 if (CudaInstallation.isValid()) 8407 CmdArgs.push_back(Args.MakeArgString( 8408 "--cuda-path=" + CudaInstallation.getInstallPath())); 8409 break; 8410 } 8411 } 8412 } 8413 8414 // Get the AMDGPU math libraries. 8415 // FIXME: This method is bad, remove once AMDGPU has a proper math library 8416 // (see AMDGCN::OpenMPLinker::constructLLVMLinkCommand). 8417 for (auto &I : llvm::make_range(OpenMPTCRange.first, OpenMPTCRange.second)) { 8418 const ToolChain *TC = I.second; 8419 8420 if (!TC->getTriple().isAMDGPU() || Args.hasArg(options::OPT_nogpulib)) 8421 continue; 8422 8423 const ArgList &TCArgs = C.getArgsForToolChain(TC, "", Action::OFK_OpenMP); 8424 StringRef Arch = TCArgs.getLastArgValue(options::OPT_march_EQ); 8425 const toolchains::ROCMToolChain RocmTC(TC->getDriver(), TC->getTriple(), 8426 TCArgs); 8427 8428 SmallVector<std::string, 12> BCLibs = 8429 RocmTC.getCommonDeviceLibNames(TCArgs, Arch.str()); 8430 8431 for (StringRef LibName : BCLibs) 8432 CmdArgs.push_back(Args.MakeArgString( 8433 "--bitcode-library=" + Action::GetOffloadKindName(Action::OFK_OpenMP) + 8434 "-" + TC->getTripleString() + "-" + Arch + "=" + LibName)); 8435 } 8436 8437 if (D.isUsingLTO(/* IsOffload */ true)) { 8438 // Pass in the optimization level to use for LTO. 8439 if (const Arg *A = Args.getLastArg(options::OPT_O_Group)) { 8440 StringRef OOpt; 8441 if (A->getOption().matches(options::OPT_O4) || 8442 A->getOption().matches(options::OPT_Ofast)) 8443 OOpt = "3"; 8444 else if (A->getOption().matches(options::OPT_O)) { 8445 OOpt = A->getValue(); 8446 if (OOpt == "g") 8447 OOpt = "1"; 8448 else if (OOpt == "s" || OOpt == "z") 8449 OOpt = "2"; 8450 } else if (A->getOption().matches(options::OPT_O0)) 8451 OOpt = "0"; 8452 if (!OOpt.empty()) 8453 CmdArgs.push_back(Args.MakeArgString(Twine("--opt-level=O") + OOpt)); 8454 } 8455 } 8456 8457 CmdArgs.push_back( 8458 Args.MakeArgString("--host-triple=" + TheTriple.getTriple())); 8459 if (Args.hasArg(options::OPT_v)) 8460 CmdArgs.push_back("--verbose"); 8461 8462 if (const Arg *A = Args.getLastArg(options::OPT_g_Group)) { 8463 if (!A->getOption().matches(options::OPT_g0)) 8464 CmdArgs.push_back("--device-debug"); 8465 } 8466 8467 for (const auto &A : Args.getAllArgValues(options::OPT_Xcuda_ptxas)) 8468 CmdArgs.push_back(Args.MakeArgString("--ptxas-args=" + A)); 8469 8470 // Forward remarks passes to the LLVM backend in the wrapper. 8471 if (const Arg *A = Args.getLastArg(options::OPT_Rpass_EQ)) 8472 CmdArgs.push_back(Args.MakeArgString(Twine("--offload-opt=-pass-remarks=") + 8473 A->getValue())); 8474 if (const Arg *A = Args.getLastArg(options::OPT_Rpass_missed_EQ)) 8475 CmdArgs.push_back(Args.MakeArgString( 8476 Twine("--offload-opt=-pass-remarks-missed=") + A->getValue())); 8477 if (const Arg *A = Args.getLastArg(options::OPT_Rpass_analysis_EQ)) 8478 CmdArgs.push_back(Args.MakeArgString( 8479 Twine("--offload-opt=-pass-remarks-analysis=") + A->getValue())); 8480 if (Args.getLastArg(options::OPT_save_temps_EQ)) 8481 CmdArgs.push_back("--save-temps"); 8482 8483 // Construct the link job so we can wrap around it. 8484 Linker->ConstructJob(C, JA, Output, Inputs, Args, LinkingOutput); 8485 const auto &LinkCommand = C.getJobs().getJobs().back(); 8486 8487 // Forward -Xoffload-linker<-triple> arguments to the device link job. 8488 for (Arg *A : Args.filtered(options::OPT_Xoffload_linker)) { 8489 StringRef Val = A->getValue(0); 8490 if (Val.empty()) 8491 CmdArgs.push_back( 8492 Args.MakeArgString(Twine("--device-linker=") + A->getValue(1))); 8493 else 8494 CmdArgs.push_back(Args.MakeArgString( 8495 "--device-linker=" + 8496 ToolChain::getOpenMPTriple(Val.drop_front()).getTriple() + "=" + 8497 A->getValue(1))); 8498 } 8499 Args.ClaimAllArgs(options::OPT_Xoffload_linker); 8500 8501 // Forward `-mllvm` arguments to the LLVM invocations if present. 8502 for (Arg *A : Args.filtered(options::OPT_mllvm)) { 8503 CmdArgs.push_back("-mllvm"); 8504 CmdArgs.push_back(A->getValue()); 8505 A->claim(); 8506 } 8507 8508 // Add the linker arguments to be forwarded by the wrapper. 8509 CmdArgs.push_back(Args.MakeArgString(Twine("--linker-path=") + 8510 LinkCommand->getExecutable())); 8511 CmdArgs.push_back("--"); 8512 for (const char *LinkArg : LinkCommand->getArguments()) 8513 CmdArgs.push_back(LinkArg); 8514 8515 const char *Exec = 8516 Args.MakeArgString(getToolChain().GetProgramPath("clang-linker-wrapper")); 8517 8518 // Replace the executable and arguments of the link job with the 8519 // wrapper. 8520 LinkCommand->replaceExecutable(Exec); 8521 LinkCommand->replaceArguments(CmdArgs); 8522 } 8523