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