1 //===- CompilerInvocation.cpp ---------------------------------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include "clang/Frontend/CompilerInvocation.h" 10 #include "TestModuleFileExtension.h" 11 #include "clang/Basic/Builtins.h" 12 #include "clang/Basic/CharInfo.h" 13 #include "clang/Basic/CodeGenOptions.h" 14 #include "clang/Basic/CommentOptions.h" 15 #include "clang/Basic/DebugInfoOptions.h" 16 #include "clang/Basic/Diagnostic.h" 17 #include "clang/Basic/DiagnosticDriver.h" 18 #include "clang/Basic/DiagnosticOptions.h" 19 #include "clang/Basic/FileSystemOptions.h" 20 #include "clang/Basic/LLVM.h" 21 #include "clang/Basic/LangOptions.h" 22 #include "clang/Basic/LangStandard.h" 23 #include "clang/Basic/ObjCRuntime.h" 24 #include "clang/Basic/Sanitizers.h" 25 #include "clang/Basic/SourceLocation.h" 26 #include "clang/Basic/TargetOptions.h" 27 #include "clang/Basic/Version.h" 28 #include "clang/Basic/Visibility.h" 29 #include "clang/Basic/XRayInstr.h" 30 #include "clang/Config/config.h" 31 #include "clang/Driver/Driver.h" 32 #include "clang/Driver/DriverDiagnostic.h" 33 #include "clang/Driver/Options.h" 34 #include "clang/Frontend/CommandLineSourceLoc.h" 35 #include "clang/Frontend/DependencyOutputOptions.h" 36 #include "clang/Frontend/FrontendDiagnostic.h" 37 #include "clang/Frontend/FrontendOptions.h" 38 #include "clang/Frontend/FrontendPluginRegistry.h" 39 #include "clang/Frontend/MigratorOptions.h" 40 #include "clang/Frontend/PreprocessorOutputOptions.h" 41 #include "clang/Frontend/Utils.h" 42 #include "clang/Lex/HeaderSearchOptions.h" 43 #include "clang/Lex/PreprocessorOptions.h" 44 #include "clang/Sema/CodeCompleteOptions.h" 45 #include "clang/Serialization/ASTBitCodes.h" 46 #include "clang/Serialization/ModuleFileExtension.h" 47 #include "clang/StaticAnalyzer/Core/AnalyzerOptions.h" 48 #include "llvm/ADT/APInt.h" 49 #include "llvm/ADT/ArrayRef.h" 50 #include "llvm/ADT/CachedHashString.h" 51 #include "llvm/ADT/FloatingPointMode.h" 52 #include "llvm/ADT/Hashing.h" 53 #include "llvm/ADT/None.h" 54 #include "llvm/ADT/Optional.h" 55 #include "llvm/ADT/SmallString.h" 56 #include "llvm/ADT/SmallVector.h" 57 #include "llvm/ADT/StringRef.h" 58 #include "llvm/ADT/StringSwitch.h" 59 #include "llvm/ADT/Triple.h" 60 #include "llvm/ADT/Twine.h" 61 #include "llvm/Config/llvm-config.h" 62 #include "llvm/IR/DebugInfoMetadata.h" 63 #include "llvm/Linker/Linker.h" 64 #include "llvm/MC/MCTargetOptions.h" 65 #include "llvm/Option/Arg.h" 66 #include "llvm/Option/ArgList.h" 67 #include "llvm/Option/OptSpecifier.h" 68 #include "llvm/Option/OptTable.h" 69 #include "llvm/Option/Option.h" 70 #include "llvm/ProfileData/InstrProfReader.h" 71 #include "llvm/Remarks/HotnessThresholdParser.h" 72 #include "llvm/Support/CodeGen.h" 73 #include "llvm/Support/Compiler.h" 74 #include "llvm/Support/Error.h" 75 #include "llvm/Support/ErrorHandling.h" 76 #include "llvm/Support/ErrorOr.h" 77 #include "llvm/Support/FileSystem.h" 78 #include "llvm/Support/Host.h" 79 #include "llvm/Support/MathExtras.h" 80 #include "llvm/Support/MemoryBuffer.h" 81 #include "llvm/Support/Path.h" 82 #include "llvm/Support/Process.h" 83 #include "llvm/Support/Regex.h" 84 #include "llvm/Support/VersionTuple.h" 85 #include "llvm/Support/VirtualFileSystem.h" 86 #include "llvm/Support/raw_ostream.h" 87 #include "llvm/Target/TargetOptions.h" 88 #include <algorithm> 89 #include <atomic> 90 #include <cassert> 91 #include <cstddef> 92 #include <cstring> 93 #include <memory> 94 #include <string> 95 #include <tuple> 96 #include <type_traits> 97 #include <utility> 98 #include <vector> 99 100 using namespace clang; 101 using namespace driver; 102 using namespace options; 103 using namespace llvm::opt; 104 105 //===----------------------------------------------------------------------===// 106 // Initialization. 107 //===----------------------------------------------------------------------===// 108 109 CompilerInvocationBase::CompilerInvocationBase() 110 : LangOpts(new LangOptions()), TargetOpts(new TargetOptions()), 111 DiagnosticOpts(new DiagnosticOptions()), 112 HeaderSearchOpts(new HeaderSearchOptions()), 113 PreprocessorOpts(new PreprocessorOptions()) {} 114 115 CompilerInvocationBase::CompilerInvocationBase(const CompilerInvocationBase &X) 116 : LangOpts(new LangOptions(*X.getLangOpts())), 117 TargetOpts(new TargetOptions(X.getTargetOpts())), 118 DiagnosticOpts(new DiagnosticOptions(X.getDiagnosticOpts())), 119 HeaderSearchOpts(new HeaderSearchOptions(X.getHeaderSearchOpts())), 120 PreprocessorOpts(new PreprocessorOptions(X.getPreprocessorOpts())) {} 121 122 CompilerInvocationBase::~CompilerInvocationBase() = default; 123 124 //===----------------------------------------------------------------------===// 125 // Normalizers 126 //===----------------------------------------------------------------------===// 127 128 #define SIMPLE_ENUM_VALUE_TABLE 129 #include "clang/Driver/Options.inc" 130 #undef SIMPLE_ENUM_VALUE_TABLE 131 132 static llvm::Optional<bool> 133 normalizeSimpleFlag(OptSpecifier Opt, unsigned TableIndex, const ArgList &Args, 134 DiagnosticsEngine &Diags, bool &Success) { 135 if (Args.hasArg(Opt)) 136 return true; 137 return None; 138 } 139 140 static Optional<bool> normalizeSimpleNegativeFlag(OptSpecifier Opt, unsigned, 141 const ArgList &Args, 142 DiagnosticsEngine &, 143 bool &Success) { 144 if (Args.hasArg(Opt)) 145 return false; 146 return None; 147 } 148 149 /// The tblgen-erated code passes in a fifth parameter of an arbitrary type, but 150 /// denormalizeSimpleFlags never looks at it. Avoid bloating compile-time with 151 /// unnecessary template instantiations and just ignore it with a variadic 152 /// argument. 153 static void denormalizeSimpleFlag(SmallVectorImpl<const char *> &Args, 154 const char *Spelling, 155 CompilerInvocation::StringAllocator, 156 Option::OptionClass, unsigned, /*T*/...) { 157 Args.push_back(Spelling); 158 } 159 160 template <typename T> static constexpr bool is_uint64_t_convertible() { 161 return !std::is_same<T, uint64_t>::value && 162 llvm::is_integral_or_enum<T>::value; 163 } 164 165 template <typename T, 166 std::enable_if_t<!is_uint64_t_convertible<T>(), bool> = false> 167 static auto makeFlagToValueNormalizer(T Value) { 168 return [Value](OptSpecifier Opt, unsigned, const ArgList &Args, 169 DiagnosticsEngine &, bool &Success) -> Optional<T> { 170 if (Args.hasArg(Opt)) 171 return Value; 172 return None; 173 }; 174 } 175 176 template <typename T, 177 std::enable_if_t<is_uint64_t_convertible<T>(), bool> = false> 178 static auto makeFlagToValueNormalizer(T Value) { 179 return makeFlagToValueNormalizer(uint64_t(Value)); 180 } 181 182 static auto makeBooleanOptionNormalizer(bool Value, bool OtherValue, 183 OptSpecifier OtherOpt) { 184 return [Value, OtherValue, OtherOpt](OptSpecifier Opt, unsigned, 185 const ArgList &Args, DiagnosticsEngine &, 186 bool &Success) -> Optional<bool> { 187 if (const Arg *A = Args.getLastArg(Opt, OtherOpt)) { 188 return A->getOption().matches(Opt) ? Value : OtherValue; 189 } 190 return None; 191 }; 192 } 193 194 static auto makeBooleanOptionDenormalizer(bool Value) { 195 return [Value](SmallVectorImpl<const char *> &Args, const char *Spelling, 196 CompilerInvocation::StringAllocator, Option::OptionClass, 197 unsigned, bool KeyPath) { 198 if (KeyPath == Value) 199 Args.push_back(Spelling); 200 }; 201 } 202 203 static void denormalizeStringImpl(SmallVectorImpl<const char *> &Args, 204 const char *Spelling, 205 CompilerInvocation::StringAllocator SA, 206 Option::OptionClass OptClass, unsigned, 207 Twine Value) { 208 switch (OptClass) { 209 case Option::SeparateClass: 210 case Option::JoinedOrSeparateClass: 211 Args.push_back(Spelling); 212 Args.push_back(SA(Value)); 213 break; 214 case Option::JoinedClass: 215 Args.push_back(SA(Twine(Spelling) + Value)); 216 break; 217 default: 218 llvm_unreachable("Cannot denormalize an option with option class " 219 "incompatible with string denormalization."); 220 } 221 } 222 223 template <typename T> 224 static void 225 denormalizeString(SmallVectorImpl<const char *> &Args, const char *Spelling, 226 CompilerInvocation::StringAllocator SA, 227 Option::OptionClass OptClass, unsigned TableIndex, T Value) { 228 denormalizeStringImpl(Args, Spelling, SA, OptClass, TableIndex, Twine(Value)); 229 } 230 231 static Optional<SimpleEnumValue> 232 findValueTableByName(const SimpleEnumValueTable &Table, StringRef Name) { 233 for (int I = 0, E = Table.Size; I != E; ++I) 234 if (Name == Table.Table[I].Name) 235 return Table.Table[I]; 236 237 return None; 238 } 239 240 static Optional<SimpleEnumValue> 241 findValueTableByValue(const SimpleEnumValueTable &Table, unsigned Value) { 242 for (int I = 0, E = Table.Size; I != E; ++I) 243 if (Value == Table.Table[I].Value) 244 return Table.Table[I]; 245 246 return None; 247 } 248 249 static llvm::Optional<unsigned> 250 normalizeSimpleEnum(OptSpecifier Opt, unsigned TableIndex, const ArgList &Args, 251 DiagnosticsEngine &Diags, bool &Success) { 252 assert(TableIndex < SimpleEnumValueTablesSize); 253 const SimpleEnumValueTable &Table = SimpleEnumValueTables[TableIndex]; 254 255 auto *Arg = Args.getLastArg(Opt); 256 if (!Arg) 257 return None; 258 259 StringRef ArgValue = Arg->getValue(); 260 if (auto MaybeEnumVal = findValueTableByName(Table, ArgValue)) 261 return MaybeEnumVal->Value; 262 263 Success = false; 264 Diags.Report(diag::err_drv_invalid_value) 265 << Arg->getAsString(Args) << ArgValue; 266 return None; 267 } 268 269 static void denormalizeSimpleEnumImpl(SmallVectorImpl<const char *> &Args, 270 const char *Spelling, 271 CompilerInvocation::StringAllocator SA, 272 Option::OptionClass OptClass, 273 unsigned TableIndex, unsigned Value) { 274 assert(TableIndex < SimpleEnumValueTablesSize); 275 const SimpleEnumValueTable &Table = SimpleEnumValueTables[TableIndex]; 276 if (auto MaybeEnumVal = findValueTableByValue(Table, Value)) { 277 denormalizeString(Args, Spelling, SA, OptClass, TableIndex, 278 MaybeEnumVal->Name); 279 } else { 280 llvm_unreachable("The simple enum value was not correctly defined in " 281 "the tablegen option description"); 282 } 283 } 284 285 template <typename T> 286 static void denormalizeSimpleEnum(SmallVectorImpl<const char *> &Args, 287 const char *Spelling, 288 CompilerInvocation::StringAllocator SA, 289 Option::OptionClass OptClass, 290 unsigned TableIndex, T Value) { 291 return denormalizeSimpleEnumImpl(Args, Spelling, SA, OptClass, TableIndex, 292 static_cast<unsigned>(Value)); 293 } 294 295 static Optional<std::string> normalizeString(OptSpecifier Opt, int TableIndex, 296 const ArgList &Args, 297 DiagnosticsEngine &Diags, 298 bool &Success) { 299 auto *Arg = Args.getLastArg(Opt); 300 if (!Arg) 301 return None; 302 return std::string(Arg->getValue()); 303 } 304 305 template <typename IntTy> 306 static Optional<IntTy> 307 normalizeStringIntegral(OptSpecifier Opt, int, const ArgList &Args, 308 DiagnosticsEngine &Diags, bool &Success) { 309 auto *Arg = Args.getLastArg(Opt); 310 if (!Arg) 311 return None; 312 IntTy Res; 313 if (StringRef(Arg->getValue()).getAsInteger(0, Res)) { 314 Success = false; 315 Diags.Report(diag::err_drv_invalid_int_value) 316 << Arg->getAsString(Args) << Arg->getValue(); 317 return None; 318 } 319 return Res; 320 } 321 322 static Optional<std::vector<std::string>> 323 normalizeStringVector(OptSpecifier Opt, int, const ArgList &Args, 324 DiagnosticsEngine &, bool &Success) { 325 return Args.getAllArgValues(Opt); 326 } 327 328 static void denormalizeStringVector(SmallVectorImpl<const char *> &Args, 329 const char *Spelling, 330 CompilerInvocation::StringAllocator SA, 331 Option::OptionClass OptClass, 332 unsigned TableIndex, 333 const std::vector<std::string> &Values) { 334 switch (OptClass) { 335 case Option::CommaJoinedClass: { 336 std::string CommaJoinedValue; 337 if (!Values.empty()) { 338 CommaJoinedValue.append(Values.front()); 339 for (const std::string &Value : llvm::drop_begin(Values, 1)) { 340 CommaJoinedValue.append(","); 341 CommaJoinedValue.append(Value); 342 } 343 } 344 denormalizeString(Args, Spelling, SA, Option::OptionClass::JoinedClass, 345 TableIndex, CommaJoinedValue); 346 break; 347 } 348 case Option::JoinedClass: 349 case Option::SeparateClass: 350 case Option::JoinedOrSeparateClass: 351 for (const std::string &Value : Values) 352 denormalizeString(Args, Spelling, SA, OptClass, TableIndex, Value); 353 break; 354 default: 355 llvm_unreachable("Cannot denormalize an option with option class " 356 "incompatible with string vector denormalization."); 357 } 358 } 359 360 static Optional<std::string> normalizeTriple(OptSpecifier Opt, int TableIndex, 361 const ArgList &Args, 362 DiagnosticsEngine &Diags, 363 bool &Success) { 364 auto *Arg = Args.getLastArg(Opt); 365 if (!Arg) 366 return None; 367 return llvm::Triple::normalize(Arg->getValue()); 368 } 369 370 template <typename T, typename U> 371 static T mergeForwardValue(T KeyPath, U Value) { 372 return static_cast<T>(Value); 373 } 374 375 template <typename T, typename U> static T mergeMaskValue(T KeyPath, U Value) { 376 return KeyPath | Value; 377 } 378 379 template <typename T> static T extractForwardValue(T KeyPath) { 380 return KeyPath; 381 } 382 383 template <typename T, typename U, U Value> 384 static T extractMaskValue(T KeyPath) { 385 return KeyPath & Value; 386 } 387 388 static void FixupInvocation(CompilerInvocation &Invocation, 389 DiagnosticsEngine &Diags, 390 const InputArgList &Args) { 391 LangOptions &LangOpts = *Invocation.getLangOpts(); 392 CodeGenOptions &CodeGenOpts = Invocation.getCodeGenOpts(); 393 TargetOptions &TargetOpts = Invocation.getTargetOpts(); 394 FrontendOptions &FrontendOpts = Invocation.getFrontendOpts(); 395 CodeGenOpts.XRayInstrumentFunctions = LangOpts.XRayInstrument; 396 CodeGenOpts.XRayAlwaysEmitCustomEvents = LangOpts.XRayAlwaysEmitCustomEvents; 397 CodeGenOpts.XRayAlwaysEmitTypedEvents = LangOpts.XRayAlwaysEmitTypedEvents; 398 CodeGenOpts.DisableFree = FrontendOpts.DisableFree; 399 FrontendOpts.GenerateGlobalModuleIndex = FrontendOpts.UseGlobalModuleIndex; 400 401 LangOpts.ForceEmitVTables = CodeGenOpts.ForceEmitVTables; 402 LangOpts.SpeculativeLoadHardening = CodeGenOpts.SpeculativeLoadHardening; 403 LangOpts.CurrentModule = LangOpts.ModuleName; 404 405 llvm::Triple T(TargetOpts.Triple); 406 llvm::Triple::ArchType Arch = T.getArch(); 407 408 CodeGenOpts.CodeModel = TargetOpts.CodeModel; 409 410 if (LangOpts.getExceptionHandling() != llvm::ExceptionHandling::None && 411 T.isWindowsMSVCEnvironment()) 412 Diags.Report(diag::err_fe_invalid_exception_model) 413 << static_cast<unsigned>(LangOpts.getExceptionHandling()) << T.str(); 414 415 if (LangOpts.AppleKext && !LangOpts.CPlusPlus) 416 Diags.Report(diag::warn_c_kext); 417 418 if (LangOpts.NewAlignOverride && 419 !llvm::isPowerOf2_32(LangOpts.NewAlignOverride)) { 420 Arg *A = Args.getLastArg(OPT_fnew_alignment_EQ); 421 Diags.Report(diag::err_fe_invalid_alignment) 422 << A->getAsString(Args) << A->getValue(); 423 LangOpts.NewAlignOverride = 0; 424 } 425 426 if (Arg *A = Args.getLastArg(OPT_fdefault_calling_conv_EQ)) { 427 auto DefaultCC = LangOpts.getDefaultCallingConv(); 428 429 bool emitError = (DefaultCC == LangOptions::DCC_FastCall || 430 DefaultCC == LangOptions::DCC_StdCall) && 431 Arch != llvm::Triple::x86; 432 emitError |= (DefaultCC == LangOptions::DCC_VectorCall || 433 DefaultCC == LangOptions::DCC_RegCall) && 434 !T.isX86(); 435 if (emitError) 436 Diags.Report(diag::err_drv_argument_not_allowed_with) 437 << A->getSpelling() << T.getTriple(); 438 } 439 440 if (!CodeGenOpts.ProfileRemappingFile.empty() && CodeGenOpts.LegacyPassManager) 441 Diags.Report(diag::err_drv_argument_only_allowed_with) 442 << Args.getLastArg(OPT_fprofile_remapping_file_EQ)->getAsString(Args) 443 << "-fno-legacy-pass-manager"; 444 } 445 446 //===----------------------------------------------------------------------===// 447 // Deserialization (from args) 448 //===----------------------------------------------------------------------===// 449 450 static unsigned getOptimizationLevel(ArgList &Args, InputKind IK, 451 DiagnosticsEngine &Diags) { 452 unsigned DefaultOpt = llvm::CodeGenOpt::None; 453 if (IK.getLanguage() == Language::OpenCL && !Args.hasArg(OPT_cl_opt_disable)) 454 DefaultOpt = llvm::CodeGenOpt::Default; 455 456 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) { 457 if (A->getOption().matches(options::OPT_O0)) 458 return llvm::CodeGenOpt::None; 459 460 if (A->getOption().matches(options::OPT_Ofast)) 461 return llvm::CodeGenOpt::Aggressive; 462 463 assert(A->getOption().matches(options::OPT_O)); 464 465 StringRef S(A->getValue()); 466 if (S == "s" || S == "z") 467 return llvm::CodeGenOpt::Default; 468 469 if (S == "g") 470 return llvm::CodeGenOpt::Less; 471 472 return getLastArgIntValue(Args, OPT_O, DefaultOpt, Diags); 473 } 474 475 return DefaultOpt; 476 } 477 478 static unsigned getOptimizationLevelSize(ArgList &Args) { 479 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) { 480 if (A->getOption().matches(options::OPT_O)) { 481 switch (A->getValue()[0]) { 482 default: 483 return 0; 484 case 's': 485 return 1; 486 case 'z': 487 return 2; 488 } 489 } 490 } 491 return 0; 492 } 493 494 static void addDiagnosticArgs(ArgList &Args, OptSpecifier Group, 495 OptSpecifier GroupWithValue, 496 std::vector<std::string> &Diagnostics) { 497 for (auto *A : Args.filtered(Group)) { 498 if (A->getOption().getKind() == Option::FlagClass) { 499 // The argument is a pure flag (such as OPT_Wall or OPT_Wdeprecated). Add 500 // its name (minus the "W" or "R" at the beginning) to the warning list. 501 Diagnostics.push_back( 502 std::string(A->getOption().getName().drop_front(1))); 503 } else if (A->getOption().matches(GroupWithValue)) { 504 // This is -Wfoo= or -Rfoo=, where foo is the name of the diagnostic group. 505 Diagnostics.push_back( 506 std::string(A->getOption().getName().drop_front(1).rtrim("=-"))); 507 } else { 508 // Otherwise, add its value (for OPT_W_Joined and similar). 509 for (const auto *Arg : A->getValues()) 510 Diagnostics.emplace_back(Arg); 511 } 512 } 513 } 514 515 // Parse the Static Analyzer configuration. If \p Diags is set to nullptr, 516 // it won't verify the input. 517 static void parseAnalyzerConfigs(AnalyzerOptions &AnOpts, 518 DiagnosticsEngine *Diags); 519 520 static void getAllNoBuiltinFuncValues(ArgList &Args, 521 std::vector<std::string> &Funcs) { 522 SmallVector<const char *, 8> Values; 523 for (const auto &Arg : Args) { 524 const Option &O = Arg->getOption(); 525 if (O.matches(options::OPT_fno_builtin_)) { 526 const char *FuncName = Arg->getValue(); 527 if (Builtin::Context::isBuiltinFunc(FuncName)) 528 Values.push_back(FuncName); 529 } 530 } 531 Funcs.insert(Funcs.end(), Values.begin(), Values.end()); 532 } 533 534 static bool ParseAnalyzerArgs(AnalyzerOptions &Opts, ArgList &Args, 535 DiagnosticsEngine &Diags) { 536 bool Success = true; 537 if (Arg *A = Args.getLastArg(OPT_analyzer_store)) { 538 StringRef Name = A->getValue(); 539 AnalysisStores Value = llvm::StringSwitch<AnalysisStores>(Name) 540 #define ANALYSIS_STORE(NAME, CMDFLAG, DESC, CREATFN) \ 541 .Case(CMDFLAG, NAME##Model) 542 #include "clang/StaticAnalyzer/Core/Analyses.def" 543 .Default(NumStores); 544 if (Value == NumStores) { 545 Diags.Report(diag::err_drv_invalid_value) 546 << A->getAsString(Args) << Name; 547 Success = false; 548 } else { 549 Opts.AnalysisStoreOpt = Value; 550 } 551 } 552 553 if (Arg *A = Args.getLastArg(OPT_analyzer_constraints)) { 554 StringRef Name = A->getValue(); 555 AnalysisConstraints Value = llvm::StringSwitch<AnalysisConstraints>(Name) 556 #define ANALYSIS_CONSTRAINTS(NAME, CMDFLAG, DESC, CREATFN) \ 557 .Case(CMDFLAG, NAME##Model) 558 #include "clang/StaticAnalyzer/Core/Analyses.def" 559 .Default(NumConstraints); 560 if (Value == NumConstraints) { 561 Diags.Report(diag::err_drv_invalid_value) 562 << A->getAsString(Args) << Name; 563 Success = false; 564 } else { 565 Opts.AnalysisConstraintsOpt = Value; 566 } 567 } 568 569 if (Arg *A = Args.getLastArg(OPT_analyzer_output)) { 570 StringRef Name = A->getValue(); 571 AnalysisDiagClients Value = llvm::StringSwitch<AnalysisDiagClients>(Name) 572 #define ANALYSIS_DIAGNOSTICS(NAME, CMDFLAG, DESC, CREATFN) \ 573 .Case(CMDFLAG, PD_##NAME) 574 #include "clang/StaticAnalyzer/Core/Analyses.def" 575 .Default(NUM_ANALYSIS_DIAG_CLIENTS); 576 if (Value == NUM_ANALYSIS_DIAG_CLIENTS) { 577 Diags.Report(diag::err_drv_invalid_value) 578 << A->getAsString(Args) << Name; 579 Success = false; 580 } else { 581 Opts.AnalysisDiagOpt = Value; 582 } 583 } 584 585 if (Arg *A = Args.getLastArg(OPT_analyzer_purge)) { 586 StringRef Name = A->getValue(); 587 AnalysisPurgeMode Value = llvm::StringSwitch<AnalysisPurgeMode>(Name) 588 #define ANALYSIS_PURGE(NAME, CMDFLAG, DESC) \ 589 .Case(CMDFLAG, NAME) 590 #include "clang/StaticAnalyzer/Core/Analyses.def" 591 .Default(NumPurgeModes); 592 if (Value == NumPurgeModes) { 593 Diags.Report(diag::err_drv_invalid_value) 594 << A->getAsString(Args) << Name; 595 Success = false; 596 } else { 597 Opts.AnalysisPurgeOpt = Value; 598 } 599 } 600 601 if (Arg *A = Args.getLastArg(OPT_analyzer_inlining_mode)) { 602 StringRef Name = A->getValue(); 603 AnalysisInliningMode Value = llvm::StringSwitch<AnalysisInliningMode>(Name) 604 #define ANALYSIS_INLINING_MODE(NAME, CMDFLAG, DESC) \ 605 .Case(CMDFLAG, NAME) 606 #include "clang/StaticAnalyzer/Core/Analyses.def" 607 .Default(NumInliningModes); 608 if (Value == NumInliningModes) { 609 Diags.Report(diag::err_drv_invalid_value) 610 << A->getAsString(Args) << Name; 611 Success = false; 612 } else { 613 Opts.InliningMode = Value; 614 } 615 } 616 617 Opts.ShouldEmitErrorsOnInvalidConfigValue = 618 /* negated */!llvm::StringSwitch<bool>( 619 Args.getLastArgValue(OPT_analyzer_config_compatibility_mode)) 620 .Case("true", true) 621 .Case("false", false) 622 .Default(false); 623 624 Opts.CheckersAndPackages.clear(); 625 for (const Arg *A : 626 Args.filtered(OPT_analyzer_checker, OPT_analyzer_disable_checker)) { 627 A->claim(); 628 bool IsEnabled = A->getOption().getID() == OPT_analyzer_checker; 629 // We can have a list of comma separated checker names, e.g: 630 // '-analyzer-checker=cocoa,unix' 631 StringRef CheckerAndPackageList = A->getValue(); 632 SmallVector<StringRef, 16> CheckersAndPackages; 633 CheckerAndPackageList.split(CheckersAndPackages, ","); 634 for (const StringRef &CheckerOrPackage : CheckersAndPackages) 635 Opts.CheckersAndPackages.emplace_back(std::string(CheckerOrPackage), 636 IsEnabled); 637 } 638 639 // Go through the analyzer configuration options. 640 for (const auto *A : Args.filtered(OPT_analyzer_config)) { 641 642 // We can have a list of comma separated config names, e.g: 643 // '-analyzer-config key1=val1,key2=val2' 644 StringRef configList = A->getValue(); 645 SmallVector<StringRef, 4> configVals; 646 configList.split(configVals, ","); 647 for (const auto &configVal : configVals) { 648 StringRef key, val; 649 std::tie(key, val) = configVal.split("="); 650 if (val.empty()) { 651 Diags.Report(SourceLocation(), 652 diag::err_analyzer_config_no_value) << configVal; 653 Success = false; 654 break; 655 } 656 if (val.find('=') != StringRef::npos) { 657 Diags.Report(SourceLocation(), 658 diag::err_analyzer_config_multiple_values) 659 << configVal; 660 Success = false; 661 break; 662 } 663 664 // TODO: Check checker options too, possibly in CheckerRegistry. 665 // Leave unknown non-checker configs unclaimed. 666 if (!key.contains(":") && Opts.isUnknownAnalyzerConfig(key)) { 667 if (Opts.ShouldEmitErrorsOnInvalidConfigValue) 668 Diags.Report(diag::err_analyzer_config_unknown) << key; 669 continue; 670 } 671 672 A->claim(); 673 Opts.Config[key] = std::string(val); 674 } 675 } 676 677 if (Opts.ShouldEmitErrorsOnInvalidConfigValue) 678 parseAnalyzerConfigs(Opts, &Diags); 679 else 680 parseAnalyzerConfigs(Opts, nullptr); 681 682 llvm::raw_string_ostream os(Opts.FullCompilerInvocation); 683 for (unsigned i = 0; i < Args.getNumInputArgStrings(); ++i) { 684 if (i != 0) 685 os << " "; 686 os << Args.getArgString(i); 687 } 688 os.flush(); 689 690 return Success; 691 } 692 693 static StringRef getStringOption(AnalyzerOptions::ConfigTable &Config, 694 StringRef OptionName, StringRef DefaultVal) { 695 return Config.insert({OptionName, std::string(DefaultVal)}).first->second; 696 } 697 698 static void initOption(AnalyzerOptions::ConfigTable &Config, 699 DiagnosticsEngine *Diags, 700 StringRef &OptionField, StringRef Name, 701 StringRef DefaultVal) { 702 // String options may be known to invalid (e.g. if the expected string is a 703 // file name, but the file does not exist), those will have to be checked in 704 // parseConfigs. 705 OptionField = getStringOption(Config, Name, DefaultVal); 706 } 707 708 static void initOption(AnalyzerOptions::ConfigTable &Config, 709 DiagnosticsEngine *Diags, 710 bool &OptionField, StringRef Name, bool DefaultVal) { 711 auto PossiblyInvalidVal = llvm::StringSwitch<Optional<bool>>( 712 getStringOption(Config, Name, (DefaultVal ? "true" : "false"))) 713 .Case("true", true) 714 .Case("false", false) 715 .Default(None); 716 717 if (!PossiblyInvalidVal) { 718 if (Diags) 719 Diags->Report(diag::err_analyzer_config_invalid_input) 720 << Name << "a boolean"; 721 else 722 OptionField = DefaultVal; 723 } else 724 OptionField = PossiblyInvalidVal.getValue(); 725 } 726 727 static void initOption(AnalyzerOptions::ConfigTable &Config, 728 DiagnosticsEngine *Diags, 729 unsigned &OptionField, StringRef Name, 730 unsigned DefaultVal) { 731 732 OptionField = DefaultVal; 733 bool HasFailed = getStringOption(Config, Name, std::to_string(DefaultVal)) 734 .getAsInteger(0, OptionField); 735 if (Diags && HasFailed) 736 Diags->Report(diag::err_analyzer_config_invalid_input) 737 << Name << "an unsigned"; 738 } 739 740 static void parseAnalyzerConfigs(AnalyzerOptions &AnOpts, 741 DiagnosticsEngine *Diags) { 742 // TODO: There's no need to store the entire configtable, it'd be plenty 743 // enough tostore checker options. 744 745 #define ANALYZER_OPTION(TYPE, NAME, CMDFLAG, DESC, DEFAULT_VAL) \ 746 initOption(AnOpts.Config, Diags, AnOpts.NAME, CMDFLAG, DEFAULT_VAL); 747 748 #define ANALYZER_OPTION_DEPENDS_ON_USER_MODE(TYPE, NAME, CMDFLAG, DESC, \ 749 SHALLOW_VAL, DEEP_VAL) \ 750 switch (AnOpts.getUserMode()) { \ 751 case UMK_Shallow: \ 752 initOption(AnOpts.Config, Diags, AnOpts.NAME, CMDFLAG, SHALLOW_VAL); \ 753 break; \ 754 case UMK_Deep: \ 755 initOption(AnOpts.Config, Diags, AnOpts.NAME, CMDFLAG, DEEP_VAL); \ 756 break; \ 757 } \ 758 759 #include "clang/StaticAnalyzer/Core/AnalyzerOptions.def" 760 #undef ANALYZER_OPTION 761 #undef ANALYZER_OPTION_DEPENDS_ON_USER_MODE 762 763 // At this point, AnalyzerOptions is configured. Let's validate some options. 764 765 // FIXME: Here we try to validate the silenced checkers or packages are valid. 766 // The current approach only validates the registered checkers which does not 767 // contain the runtime enabled checkers and optimally we would validate both. 768 if (!AnOpts.RawSilencedCheckersAndPackages.empty()) { 769 std::vector<StringRef> Checkers = 770 AnOpts.getRegisteredCheckers(/*IncludeExperimental=*/true); 771 std::vector<StringRef> Packages = 772 AnOpts.getRegisteredPackages(/*IncludeExperimental=*/true); 773 774 SmallVector<StringRef, 16> CheckersAndPackages; 775 AnOpts.RawSilencedCheckersAndPackages.split(CheckersAndPackages, ";"); 776 777 for (const StringRef &CheckerOrPackage : CheckersAndPackages) { 778 if (Diags) { 779 bool IsChecker = CheckerOrPackage.contains('.'); 780 bool IsValidName = 781 IsChecker 782 ? llvm::find(Checkers, CheckerOrPackage) != Checkers.end() 783 : llvm::find(Packages, CheckerOrPackage) != Packages.end(); 784 785 if (!IsValidName) 786 Diags->Report(diag::err_unknown_analyzer_checker_or_package) 787 << CheckerOrPackage; 788 } 789 790 AnOpts.SilencedCheckersAndPackages.emplace_back(CheckerOrPackage); 791 } 792 } 793 794 if (!Diags) 795 return; 796 797 if (AnOpts.ShouldTrackConditionsDebug && !AnOpts.ShouldTrackConditions) 798 Diags->Report(diag::err_analyzer_config_invalid_input) 799 << "track-conditions-debug" << "'track-conditions' to also be enabled"; 800 801 if (!AnOpts.CTUDir.empty() && !llvm::sys::fs::is_directory(AnOpts.CTUDir)) 802 Diags->Report(diag::err_analyzer_config_invalid_input) << "ctu-dir" 803 << "a filename"; 804 805 if (!AnOpts.ModelPath.empty() && 806 !llvm::sys::fs::is_directory(AnOpts.ModelPath)) 807 Diags->Report(diag::err_analyzer_config_invalid_input) << "model-path" 808 << "a filename"; 809 } 810 811 static void ParseCommentArgs(CommentOptions &Opts, ArgList &Args) { 812 Opts.ParseAllComments = Args.hasArg(OPT_fparse_all_comments); 813 } 814 815 /// Create a new Regex instance out of the string value in \p RpassArg. 816 /// It returns a pointer to the newly generated Regex instance. 817 static std::shared_ptr<llvm::Regex> 818 GenerateOptimizationRemarkRegex(DiagnosticsEngine &Diags, ArgList &Args, 819 Arg *RpassArg) { 820 StringRef Val = RpassArg->getValue(); 821 std::string RegexError; 822 std::shared_ptr<llvm::Regex> Pattern = std::make_shared<llvm::Regex>(Val); 823 if (!Pattern->isValid(RegexError)) { 824 Diags.Report(diag::err_drv_optimization_remark_pattern) 825 << RegexError << RpassArg->getAsString(Args); 826 Pattern.reset(); 827 } 828 return Pattern; 829 } 830 831 static bool parseDiagnosticLevelMask(StringRef FlagName, 832 const std::vector<std::string> &Levels, 833 DiagnosticsEngine &Diags, 834 DiagnosticLevelMask &M) { 835 bool Success = true; 836 for (const auto &Level : Levels) { 837 DiagnosticLevelMask const PM = 838 llvm::StringSwitch<DiagnosticLevelMask>(Level) 839 .Case("note", DiagnosticLevelMask::Note) 840 .Case("remark", DiagnosticLevelMask::Remark) 841 .Case("warning", DiagnosticLevelMask::Warning) 842 .Case("error", DiagnosticLevelMask::Error) 843 .Default(DiagnosticLevelMask::None); 844 if (PM == DiagnosticLevelMask::None) { 845 Success = false; 846 Diags.Report(diag::err_drv_invalid_value) << FlagName << Level; 847 } 848 M = M | PM; 849 } 850 return Success; 851 } 852 853 static void parseSanitizerKinds(StringRef FlagName, 854 const std::vector<std::string> &Sanitizers, 855 DiagnosticsEngine &Diags, SanitizerSet &S) { 856 for (const auto &Sanitizer : Sanitizers) { 857 SanitizerMask K = parseSanitizerValue(Sanitizer, /*AllowGroups=*/false); 858 if (K == SanitizerMask()) 859 Diags.Report(diag::err_drv_invalid_value) << FlagName << Sanitizer; 860 else 861 S.set(K, true); 862 } 863 } 864 865 static void parseXRayInstrumentationBundle(StringRef FlagName, StringRef Bundle, 866 ArgList &Args, DiagnosticsEngine &D, 867 XRayInstrSet &S) { 868 llvm::SmallVector<StringRef, 2> BundleParts; 869 llvm::SplitString(Bundle, BundleParts, ","); 870 for (const auto &B : BundleParts) { 871 auto Mask = parseXRayInstrValue(B); 872 if (Mask == XRayInstrKind::None) 873 if (B != "none") 874 D.Report(diag::err_drv_invalid_value) << FlagName << Bundle; 875 else 876 S.Mask = Mask; 877 else if (Mask == XRayInstrKind::All) 878 S.Mask = Mask; 879 else 880 S.set(Mask, true); 881 } 882 } 883 884 // Set the profile kind using fprofile-instrument-use-path. 885 static void setPGOUseInstrumentor(CodeGenOptions &Opts, 886 const Twine &ProfileName) { 887 auto ReaderOrErr = llvm::IndexedInstrProfReader::create(ProfileName); 888 // In error, return silently and let Clang PGOUse report the error message. 889 if (auto E = ReaderOrErr.takeError()) { 890 llvm::consumeError(std::move(E)); 891 Opts.setProfileUse(CodeGenOptions::ProfileClangInstr); 892 return; 893 } 894 std::unique_ptr<llvm::IndexedInstrProfReader> PGOReader = 895 std::move(ReaderOrErr.get()); 896 if (PGOReader->isIRLevelProfile()) { 897 if (PGOReader->hasCSIRLevelProfile()) 898 Opts.setProfileUse(CodeGenOptions::ProfileCSIRInstr); 899 else 900 Opts.setProfileUse(CodeGenOptions::ProfileIRInstr); 901 } else 902 Opts.setProfileUse(CodeGenOptions::ProfileClangInstr); 903 } 904 905 static bool ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args, InputKind IK, 906 DiagnosticsEngine &Diags, const llvm::Triple &T, 907 const std::string &OutputFile) { 908 bool Success = true; 909 910 unsigned OptimizationLevel = getOptimizationLevel(Args, IK, Diags); 911 // TODO: This could be done in Driver 912 unsigned MaxOptLevel = 3; 913 if (OptimizationLevel > MaxOptLevel) { 914 // If the optimization level is not supported, fall back on the default 915 // optimization 916 Diags.Report(diag::warn_drv_optimization_value) 917 << Args.getLastArg(OPT_O)->getAsString(Args) << "-O" << MaxOptLevel; 918 OptimizationLevel = MaxOptLevel; 919 } 920 Opts.OptimizationLevel = OptimizationLevel; 921 922 // At O0 we want to fully disable inlining outside of cases marked with 923 // 'alwaysinline' that are required for correctness. 924 Opts.setInlining((Opts.OptimizationLevel == 0) 925 ? CodeGenOptions::OnlyAlwaysInlining 926 : CodeGenOptions::NormalInlining); 927 // Explicit inlining flags can disable some or all inlining even at 928 // optimization levels above zero. 929 if (Arg *InlineArg = Args.getLastArg( 930 options::OPT_finline_functions, options::OPT_finline_hint_functions, 931 options::OPT_fno_inline_functions, options::OPT_fno_inline)) { 932 if (Opts.OptimizationLevel > 0) { 933 const Option &InlineOpt = InlineArg->getOption(); 934 if (InlineOpt.matches(options::OPT_finline_functions)) 935 Opts.setInlining(CodeGenOptions::NormalInlining); 936 else if (InlineOpt.matches(options::OPT_finline_hint_functions)) 937 Opts.setInlining(CodeGenOptions::OnlyHintInlining); 938 else 939 Opts.setInlining(CodeGenOptions::OnlyAlwaysInlining); 940 } 941 } 942 943 // PIC defaults to -fno-direct-access-external-data while non-PIC defaults to 944 // -fdirect-access-external-data. 945 Opts.DirectAccessExternalData = 946 Args.hasArg(OPT_fdirect_access_external_data) || 947 (!Args.hasArg(OPT_fno_direct_access_external_data) && 948 getLastArgIntValue(Args, OPT_pic_level, 0, Diags) == 0); 949 950 // If -fuse-ctor-homing is set and limited debug info is already on, then use 951 // constructor homing. 952 if (Args.getLastArg(OPT_fuse_ctor_homing)) 953 if (Opts.getDebugInfo() == codegenoptions::LimitedDebugInfo) 954 Opts.setDebugInfo(codegenoptions::DebugInfoConstructor); 955 956 for (const auto &Arg : Args.getAllArgValues(OPT_fdebug_prefix_map_EQ)) { 957 auto Split = StringRef(Arg).split('='); 958 Opts.DebugPrefixMap.insert( 959 {std::string(Split.first), std::string(Split.second)}); 960 } 961 962 const llvm::Triple::ArchType DebugEntryValueArchs[] = { 963 llvm::Triple::x86, llvm::Triple::x86_64, llvm::Triple::aarch64, 964 llvm::Triple::arm, llvm::Triple::armeb, llvm::Triple::mips, 965 llvm::Triple::mipsel, llvm::Triple::mips64, llvm::Triple::mips64el}; 966 967 if (Opts.OptimizationLevel > 0 && Opts.hasReducedDebugInfo() && 968 llvm::is_contained(DebugEntryValueArchs, T.getArch())) 969 Opts.EmitCallSiteInfo = true; 970 971 Opts.NewStructPathTBAA = !Args.hasArg(OPT_no_struct_path_tbaa) && 972 Args.hasArg(OPT_new_struct_path_tbaa); 973 Opts.OptimizeSize = getOptimizationLevelSize(Args); 974 Opts.SimplifyLibCalls = !(Args.hasArg(OPT_fno_builtin) || 975 Args.hasArg(OPT_ffreestanding)); 976 if (Opts.SimplifyLibCalls) 977 getAllNoBuiltinFuncValues(Args, Opts.NoBuiltinFuncs); 978 Opts.UnrollLoops = 979 Args.hasFlag(OPT_funroll_loops, OPT_fno_unroll_loops, 980 (Opts.OptimizationLevel > 1)); 981 982 Opts.DebugNameTable = static_cast<unsigned>( 983 Args.hasArg(OPT_ggnu_pubnames) 984 ? llvm::DICompileUnit::DebugNameTableKind::GNU 985 : Args.hasArg(OPT_gpubnames) 986 ? llvm::DICompileUnit::DebugNameTableKind::Default 987 : llvm::DICompileUnit::DebugNameTableKind::None); 988 989 if (!Opts.ProfileInstrumentUsePath.empty()) 990 setPGOUseInstrumentor(Opts, Opts.ProfileInstrumentUsePath); 991 992 if (const Arg *A = Args.getLastArg(OPT_ftime_report, OPT_ftime_report_EQ)) { 993 Opts.TimePasses = true; 994 995 // -ftime-report= is only for new pass manager. 996 if (A->getOption().getID() == OPT_ftime_report_EQ) { 997 if (Opts.LegacyPassManager) 998 Diags.Report(diag::err_drv_argument_only_allowed_with) 999 << A->getAsString(Args) << "-fno-legacy-pass-manager"; 1000 1001 StringRef Val = A->getValue(); 1002 if (Val == "per-pass") 1003 Opts.TimePassesPerRun = false; 1004 else if (Val == "per-pass-run") 1005 Opts.TimePassesPerRun = true; 1006 else 1007 Diags.Report(diag::err_drv_invalid_value) 1008 << A->getAsString(Args) << A->getValue(); 1009 } 1010 } 1011 1012 // Basic Block Sections implies Function Sections. 1013 Opts.FunctionSections = 1014 Args.hasArg(OPT_ffunction_sections) || 1015 (Opts.BBSections != "none" && Opts.BBSections != "labels"); 1016 1017 Opts.PrepareForLTO = Args.hasArg(OPT_flto, OPT_flto_EQ); 1018 Opts.PrepareForThinLTO = false; 1019 if (Arg *A = Args.getLastArg(OPT_flto_EQ)) { 1020 StringRef S = A->getValue(); 1021 if (S == "thin") 1022 Opts.PrepareForThinLTO = true; 1023 else if (S != "full") 1024 Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << S; 1025 } 1026 if (Arg *A = Args.getLastArg(OPT_fthinlto_index_EQ)) { 1027 if (IK.getLanguage() != Language::LLVM_IR) 1028 Diags.Report(diag::err_drv_argument_only_allowed_with) 1029 << A->getAsString(Args) << "-x ir"; 1030 Opts.ThinLTOIndexFile = 1031 std::string(Args.getLastArgValue(OPT_fthinlto_index_EQ)); 1032 } 1033 if (Arg *A = Args.getLastArg(OPT_save_temps_EQ)) 1034 Opts.SaveTempsFilePrefix = 1035 llvm::StringSwitch<std::string>(A->getValue()) 1036 .Case("obj", OutputFile) 1037 .Default(llvm::sys::path::filename(OutputFile).str()); 1038 1039 // The memory profile runtime appends the pid to make this name more unique. 1040 const char *MemProfileBasename = "memprof.profraw"; 1041 if (Args.hasArg(OPT_fmemory_profile_EQ)) { 1042 SmallString<128> Path( 1043 std::string(Args.getLastArgValue(OPT_fmemory_profile_EQ))); 1044 llvm::sys::path::append(Path, MemProfileBasename); 1045 Opts.MemoryProfileOutput = std::string(Path); 1046 } else if (Args.hasArg(OPT_fmemory_profile)) 1047 Opts.MemoryProfileOutput = MemProfileBasename; 1048 1049 if (Opts.EmitGcovArcs || Opts.EmitGcovNotes) { 1050 if (Args.hasArg(OPT_coverage_version_EQ)) { 1051 StringRef CoverageVersion = Args.getLastArgValue(OPT_coverage_version_EQ); 1052 if (CoverageVersion.size() != 4) { 1053 Diags.Report(diag::err_drv_invalid_value) 1054 << Args.getLastArg(OPT_coverage_version_EQ)->getAsString(Args) 1055 << CoverageVersion; 1056 } else { 1057 memcpy(Opts.CoverageVersion, CoverageVersion.data(), 4); 1058 } 1059 } 1060 } 1061 // FIXME: For backend options that are not yet recorded as function 1062 // attributes in the IR, keep track of them so we can embed them in a 1063 // separate data section and use them when building the bitcode. 1064 for (const auto &A : Args) { 1065 // Do not encode output and input. 1066 if (A->getOption().getID() == options::OPT_o || 1067 A->getOption().getID() == options::OPT_INPUT || 1068 A->getOption().getID() == options::OPT_x || 1069 A->getOption().getID() == options::OPT_fembed_bitcode || 1070 A->getOption().matches(options::OPT_W_Group)) 1071 continue; 1072 ArgStringList ASL; 1073 A->render(Args, ASL); 1074 for (const auto &arg : ASL) { 1075 StringRef ArgStr(arg); 1076 Opts.CmdArgs.insert(Opts.CmdArgs.end(), ArgStr.begin(), ArgStr.end()); 1077 // using \00 to separate each commandline options. 1078 Opts.CmdArgs.push_back('\0'); 1079 } 1080 } 1081 1082 auto XRayInstrBundles = 1083 Args.getAllArgValues(OPT_fxray_instrumentation_bundle); 1084 if (XRayInstrBundles.empty()) 1085 Opts.XRayInstrumentationBundle.Mask = XRayInstrKind::All; 1086 else 1087 for (const auto &A : XRayInstrBundles) 1088 parseXRayInstrumentationBundle("-fxray-instrumentation-bundle=", A, Args, 1089 Diags, Opts.XRayInstrumentationBundle); 1090 1091 if (const Arg *A = Args.getLastArg(OPT_fcf_protection_EQ)) { 1092 StringRef Name = A->getValue(); 1093 if (Name == "full") { 1094 Opts.CFProtectionReturn = 1; 1095 Opts.CFProtectionBranch = 1; 1096 } else if (Name == "return") 1097 Opts.CFProtectionReturn = 1; 1098 else if (Name == "branch") 1099 Opts.CFProtectionBranch = 1; 1100 else if (Name != "none") { 1101 Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Name; 1102 Success = false; 1103 } 1104 } 1105 1106 for (auto *A : 1107 Args.filtered(OPT_mlink_bitcode_file, OPT_mlink_builtin_bitcode)) { 1108 CodeGenOptions::BitcodeFileToLink F; 1109 F.Filename = A->getValue(); 1110 if (A->getOption().matches(OPT_mlink_builtin_bitcode)) { 1111 F.LinkFlags = llvm::Linker::Flags::LinkOnlyNeeded; 1112 // When linking CUDA bitcode, propagate function attributes so that 1113 // e.g. libdevice gets fast-math attrs if we're building with fast-math. 1114 F.PropagateAttrs = true; 1115 F.Internalize = true; 1116 } 1117 Opts.LinkBitcodeFiles.push_back(F); 1118 } 1119 1120 if (Args.getLastArg(OPT_femulated_tls) || 1121 Args.getLastArg(OPT_fno_emulated_tls)) { 1122 Opts.ExplicitEmulatedTLS = true; 1123 } 1124 1125 if (Arg *A = Args.getLastArg(OPT_fdenormal_fp_math_EQ)) { 1126 StringRef Val = A->getValue(); 1127 Opts.FPDenormalMode = llvm::parseDenormalFPAttribute(Val); 1128 if (!Opts.FPDenormalMode.isValid()) 1129 Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Val; 1130 } 1131 1132 if (Arg *A = Args.getLastArg(OPT_fdenormal_fp_math_f32_EQ)) { 1133 StringRef Val = A->getValue(); 1134 Opts.FP32DenormalMode = llvm::parseDenormalFPAttribute(Val); 1135 if (!Opts.FP32DenormalMode.isValid()) 1136 Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Val; 1137 } 1138 1139 // X86_32 has -fppc-struct-return and -freg-struct-return. 1140 // PPC32 has -maix-struct-return and -msvr4-struct-return. 1141 if (Arg *A = 1142 Args.getLastArg(OPT_fpcc_struct_return, OPT_freg_struct_return, 1143 OPT_maix_struct_return, OPT_msvr4_struct_return)) { 1144 // TODO: We might want to consider enabling these options on AIX in the 1145 // future. 1146 if (T.isOSAIX()) 1147 Diags.Report(diag::err_drv_unsupported_opt_for_target) 1148 << A->getSpelling() << T.str(); 1149 1150 const Option &O = A->getOption(); 1151 if (O.matches(OPT_fpcc_struct_return) || 1152 O.matches(OPT_maix_struct_return)) { 1153 Opts.setStructReturnConvention(CodeGenOptions::SRCK_OnStack); 1154 } else { 1155 assert(O.matches(OPT_freg_struct_return) || 1156 O.matches(OPT_msvr4_struct_return)); 1157 Opts.setStructReturnConvention(CodeGenOptions::SRCK_InRegs); 1158 } 1159 } 1160 1161 if (T.isOSAIX() && (Args.hasArg(OPT_mignore_xcoff_visibility) || 1162 !Args.hasArg(OPT_fvisibility))) 1163 Opts.IgnoreXCOFFVisibility = 1; 1164 1165 if (Arg *A = 1166 Args.getLastArg(OPT_mabi_EQ_vec_default, OPT_mabi_EQ_vec_extabi)) { 1167 if (!T.isOSAIX()) 1168 Diags.Report(diag::err_drv_unsupported_opt_for_target) 1169 << A->getSpelling() << T.str(); 1170 1171 const Option &O = A->getOption(); 1172 if (O.matches(OPT_mabi_EQ_vec_default)) 1173 Diags.Report(diag::err_aix_default_altivec_abi) 1174 << A->getSpelling() << T.str(); 1175 else { 1176 assert(O.matches(OPT_mabi_EQ_vec_extabi)); 1177 Opts.EnableAIXExtendedAltivecABI = 1; 1178 } 1179 } 1180 1181 bool NeedLocTracking = false; 1182 1183 if (!Opts.OptRecordFile.empty()) 1184 NeedLocTracking = true; 1185 1186 if (Arg *A = Args.getLastArg(OPT_opt_record_passes)) { 1187 Opts.OptRecordPasses = A->getValue(); 1188 NeedLocTracking = true; 1189 } 1190 1191 if (Arg *A = Args.getLastArg(OPT_opt_record_format)) { 1192 Opts.OptRecordFormat = A->getValue(); 1193 NeedLocTracking = true; 1194 } 1195 1196 if (Arg *A = Args.getLastArg(OPT_Rpass_EQ)) { 1197 Opts.OptimizationRemarkPattern = 1198 GenerateOptimizationRemarkRegex(Diags, Args, A); 1199 NeedLocTracking = true; 1200 } 1201 1202 if (Arg *A = Args.getLastArg(OPT_Rpass_missed_EQ)) { 1203 Opts.OptimizationRemarkMissedPattern = 1204 GenerateOptimizationRemarkRegex(Diags, Args, A); 1205 NeedLocTracking = true; 1206 } 1207 1208 if (Arg *A = Args.getLastArg(OPT_Rpass_analysis_EQ)) { 1209 Opts.OptimizationRemarkAnalysisPattern = 1210 GenerateOptimizationRemarkRegex(Diags, Args, A); 1211 NeedLocTracking = true; 1212 } 1213 1214 bool UsingSampleProfile = !Opts.SampleProfileFile.empty(); 1215 bool UsingProfile = UsingSampleProfile || 1216 (Opts.getProfileUse() != CodeGenOptions::ProfileNone); 1217 1218 if (Opts.DiagnosticsWithHotness && !UsingProfile && 1219 // An IR file will contain PGO as metadata 1220 IK.getLanguage() != Language::LLVM_IR) 1221 Diags.Report(diag::warn_drv_diagnostics_hotness_requires_pgo) 1222 << "-fdiagnostics-show-hotness"; 1223 1224 // Parse remarks hotness threshold. Valid value is either integer or 'auto'. 1225 if (auto *arg = 1226 Args.getLastArg(options::OPT_fdiagnostics_hotness_threshold_EQ)) { 1227 auto ResultOrErr = 1228 llvm::remarks::parseHotnessThresholdOption(arg->getValue()); 1229 1230 if (!ResultOrErr) { 1231 Diags.Report(diag::err_drv_invalid_diagnotics_hotness_threshold) 1232 << "-fdiagnostics-hotness-threshold="; 1233 } else { 1234 Opts.DiagnosticsHotnessThreshold = *ResultOrErr; 1235 if ((!Opts.DiagnosticsHotnessThreshold.hasValue() || 1236 Opts.DiagnosticsHotnessThreshold.getValue() > 0) && 1237 !UsingProfile) 1238 Diags.Report(diag::warn_drv_diagnostics_hotness_requires_pgo) 1239 << "-fdiagnostics-hotness-threshold="; 1240 } 1241 } 1242 1243 // If the user requested to use a sample profile for PGO, then the 1244 // backend will need to track source location information so the profile 1245 // can be incorporated into the IR. 1246 if (UsingSampleProfile) 1247 NeedLocTracking = true; 1248 1249 // If the user requested a flag that requires source locations available in 1250 // the backend, make sure that the backend tracks source location information. 1251 if (NeedLocTracking && Opts.getDebugInfo() == codegenoptions::NoDebugInfo) 1252 Opts.setDebugInfo(codegenoptions::LocTrackingOnly); 1253 1254 // Parse -fsanitize-recover= arguments. 1255 // FIXME: Report unrecoverable sanitizers incorrectly specified here. 1256 parseSanitizerKinds("-fsanitize-recover=", 1257 Args.getAllArgValues(OPT_fsanitize_recover_EQ), Diags, 1258 Opts.SanitizeRecover); 1259 parseSanitizerKinds("-fsanitize-trap=", 1260 Args.getAllArgValues(OPT_fsanitize_trap_EQ), Diags, 1261 Opts.SanitizeTrap); 1262 1263 Opts.EmitVersionIdentMetadata = Args.hasFlag(OPT_Qy, OPT_Qn, true); 1264 1265 return Success; 1266 } 1267 1268 static void ParseDependencyOutputArgs(DependencyOutputOptions &Opts, 1269 ArgList &Args) { 1270 if (Args.hasArg(OPT_show_includes)) { 1271 // Writing both /showIncludes and preprocessor output to stdout 1272 // would produce interleaved output, so use stderr for /showIncludes. 1273 // This behaves the same as cl.exe, when /E, /EP or /P are passed. 1274 if (Args.hasArg(options::OPT_E) || Args.hasArg(options::OPT_P)) 1275 Opts.ShowIncludesDest = ShowIncludesDestination::Stderr; 1276 else 1277 Opts.ShowIncludesDest = ShowIncludesDestination::Stdout; 1278 } else { 1279 Opts.ShowIncludesDest = ShowIncludesDestination::None; 1280 } 1281 // Add sanitizer blacklists as extra dependencies. 1282 // They won't be discovered by the regular preprocessor, so 1283 // we let make / ninja to know about this implicit dependency. 1284 if (!Args.hasArg(OPT_fno_sanitize_blacklist)) { 1285 for (const auto *A : Args.filtered(OPT_fsanitize_blacklist)) { 1286 StringRef Val = A->getValue(); 1287 if (Val.find('=') == StringRef::npos) 1288 Opts.ExtraDeps.push_back(std::string(Val)); 1289 } 1290 if (Opts.IncludeSystemHeaders) { 1291 for (const auto *A : Args.filtered(OPT_fsanitize_system_blacklist)) { 1292 StringRef Val = A->getValue(); 1293 if (Val.find('=') == StringRef::npos) 1294 Opts.ExtraDeps.push_back(std::string(Val)); 1295 } 1296 } 1297 } 1298 1299 // Propagate the extra dependencies. 1300 for (const auto *A : Args.filtered(OPT_fdepfile_entry)) { 1301 Opts.ExtraDeps.push_back(A->getValue()); 1302 } 1303 1304 // Only the -fmodule-file=<file> form. 1305 for (const auto *A : Args.filtered(OPT_fmodule_file)) { 1306 StringRef Val = A->getValue(); 1307 if (Val.find('=') == StringRef::npos) 1308 Opts.ExtraDeps.push_back(std::string(Val)); 1309 } 1310 } 1311 1312 static bool parseShowColorsArgs(const ArgList &Args, bool DefaultColor) { 1313 // Color diagnostics default to auto ("on" if terminal supports) in the driver 1314 // but default to off in cc1, needing an explicit OPT_fdiagnostics_color. 1315 // Support both clang's -f[no-]color-diagnostics and gcc's 1316 // -f[no-]diagnostics-colors[=never|always|auto]. 1317 enum { 1318 Colors_On, 1319 Colors_Off, 1320 Colors_Auto 1321 } ShowColors = DefaultColor ? Colors_Auto : Colors_Off; 1322 for (auto *A : Args) { 1323 const Option &O = A->getOption(); 1324 if (O.matches(options::OPT_fcolor_diagnostics) || 1325 O.matches(options::OPT_fdiagnostics_color)) { 1326 ShowColors = Colors_On; 1327 } else if (O.matches(options::OPT_fno_color_diagnostics) || 1328 O.matches(options::OPT_fno_diagnostics_color)) { 1329 ShowColors = Colors_Off; 1330 } else if (O.matches(options::OPT_fdiagnostics_color_EQ)) { 1331 StringRef Value(A->getValue()); 1332 if (Value == "always") 1333 ShowColors = Colors_On; 1334 else if (Value == "never") 1335 ShowColors = Colors_Off; 1336 else if (Value == "auto") 1337 ShowColors = Colors_Auto; 1338 } 1339 } 1340 return ShowColors == Colors_On || 1341 (ShowColors == Colors_Auto && 1342 llvm::sys::Process::StandardErrHasColors()); 1343 } 1344 1345 static bool checkVerifyPrefixes(const std::vector<std::string> &VerifyPrefixes, 1346 DiagnosticsEngine &Diags) { 1347 bool Success = true; 1348 for (const auto &Prefix : VerifyPrefixes) { 1349 // Every prefix must start with a letter and contain only alphanumeric 1350 // characters, hyphens, and underscores. 1351 auto BadChar = llvm::find_if(Prefix, [](char C) { 1352 return !isAlphanumeric(C) && C != '-' && C != '_'; 1353 }); 1354 if (BadChar != Prefix.end() || !isLetter(Prefix[0])) { 1355 Success = false; 1356 Diags.Report(diag::err_drv_invalid_value) << "-verify=" << Prefix; 1357 Diags.Report(diag::note_drv_verify_prefix_spelling); 1358 } 1359 } 1360 return Success; 1361 } 1362 1363 #define PARSE_OPTION_WITH_MARSHALLING(ARGS, DIAGS, SUCCESS, ID, FLAGS, PARAM, \ 1364 SHOULD_PARSE, KEYPATH, DEFAULT_VALUE, \ 1365 IMPLIED_CHECK, IMPLIED_VALUE, \ 1366 NORMALIZER, MERGER, TABLE_INDEX) \ 1367 if ((FLAGS)&options::CC1Option) { \ 1368 KEYPATH = MERGER(KEYPATH, DEFAULT_VALUE); \ 1369 if (IMPLIED_CHECK) \ 1370 KEYPATH = MERGER(KEYPATH, IMPLIED_VALUE); \ 1371 if (SHOULD_PARSE) \ 1372 if (auto MaybeValue = \ 1373 NORMALIZER(OPT_##ID, TABLE_INDEX, ARGS, DIAGS, SUCCESS)) \ 1374 KEYPATH = \ 1375 MERGER(KEYPATH, static_cast<decltype(KEYPATH)>(*MaybeValue)); \ 1376 } 1377 1378 bool CompilerInvocation::parseSimpleArgs(const ArgList &Args, 1379 DiagnosticsEngine &Diags) { 1380 bool Success = true; 1381 1382 #define OPTION_WITH_MARSHALLING( \ 1383 PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM, \ 1384 HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH, \ 1385 DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER, \ 1386 MERGER, EXTRACTOR, TABLE_INDEX) \ 1387 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, Success, ID, FLAGS, PARAM, \ 1388 SHOULD_PARSE, this->KEYPATH, DEFAULT_VALUE, \ 1389 IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, \ 1390 MERGER, TABLE_INDEX) 1391 #include "clang/Driver/Options.inc" 1392 #undef OPTION_WITH_MARSHALLING 1393 1394 return Success; 1395 } 1396 1397 bool clang::ParseDiagnosticArgs(DiagnosticOptions &Opts, ArgList &Args, 1398 DiagnosticsEngine *Diags, 1399 bool DefaultDiagColor) { 1400 Optional<DiagnosticsEngine> IgnoringDiags; 1401 if (!Diags) { 1402 IgnoringDiags.emplace(new DiagnosticIDs(), new DiagnosticOptions(), 1403 new IgnoringDiagConsumer()); 1404 Diags = &*IgnoringDiags; 1405 } 1406 1407 bool Success = true; 1408 1409 #define DIAG_OPTION_WITH_MARSHALLING( \ 1410 PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM, \ 1411 HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH, \ 1412 DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER, \ 1413 MERGER, EXTRACTOR, TABLE_INDEX) \ 1414 PARSE_OPTION_WITH_MARSHALLING(Args, *Diags, Success, ID, FLAGS, PARAM, \ 1415 SHOULD_PARSE, Opts.KEYPATH, DEFAULT_VALUE, \ 1416 IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, \ 1417 MERGER, TABLE_INDEX) 1418 #include "clang/Driver/Options.inc" 1419 #undef DIAG_OPTION_WITH_MARSHALLING 1420 1421 llvm::sys::Process::UseANSIEscapeCodes(Opts.UseANSIEscapeCodes); 1422 1423 if (Arg *A = 1424 Args.getLastArg(OPT_diagnostic_serialized_file, OPT__serialize_diags)) 1425 Opts.DiagnosticSerializationFile = A->getValue(); 1426 Opts.ShowColors = parseShowColorsArgs(Args, DefaultDiagColor); 1427 1428 if (Args.getLastArgValue(OPT_fdiagnostics_format) == "msvc-fallback") 1429 Opts.CLFallbackMode = true; 1430 1431 Opts.VerifyDiagnostics = Args.hasArg(OPT_verify) || Args.hasArg(OPT_verify_EQ); 1432 if (Args.hasArg(OPT_verify)) 1433 Opts.VerifyPrefixes.push_back("expected"); 1434 // Keep VerifyPrefixes in its original order for the sake of diagnostics, and 1435 // then sort it to prepare for fast lookup using std::binary_search. 1436 if (!checkVerifyPrefixes(Opts.VerifyPrefixes, *Diags)) { 1437 Opts.VerifyDiagnostics = false; 1438 Success = false; 1439 } 1440 else 1441 llvm::sort(Opts.VerifyPrefixes); 1442 DiagnosticLevelMask DiagMask = DiagnosticLevelMask::None; 1443 Success &= parseDiagnosticLevelMask("-verify-ignore-unexpected=", 1444 Args.getAllArgValues(OPT_verify_ignore_unexpected_EQ), 1445 *Diags, DiagMask); 1446 if (Args.hasArg(OPT_verify_ignore_unexpected)) 1447 DiagMask = DiagnosticLevelMask::All; 1448 Opts.setVerifyIgnoreUnexpected(DiagMask); 1449 if (Opts.TabStop == 0 || Opts.TabStop > DiagnosticOptions::MaxTabStop) { 1450 Opts.TabStop = DiagnosticOptions::DefaultTabStop; 1451 Diags->Report(diag::warn_ignoring_ftabstop_value) 1452 << Opts.TabStop << DiagnosticOptions::DefaultTabStop; 1453 } 1454 1455 addDiagnosticArgs(Args, OPT_W_Group, OPT_W_value_Group, Opts.Warnings); 1456 addDiagnosticArgs(Args, OPT_R_Group, OPT_R_value_Group, Opts.Remarks); 1457 1458 return Success; 1459 } 1460 1461 #undef PARSE_OPTION_WITH_MARSHALLING 1462 1463 /// Parse the argument to the -ftest-module-file-extension 1464 /// command-line argument. 1465 /// 1466 /// \returns true on error, false on success. 1467 static bool parseTestModuleFileExtensionArg(StringRef Arg, 1468 std::string &BlockName, 1469 unsigned &MajorVersion, 1470 unsigned &MinorVersion, 1471 bool &Hashed, 1472 std::string &UserInfo) { 1473 SmallVector<StringRef, 5> Args; 1474 Arg.split(Args, ':', 5); 1475 if (Args.size() < 5) 1476 return true; 1477 1478 BlockName = std::string(Args[0]); 1479 if (Args[1].getAsInteger(10, MajorVersion)) return true; 1480 if (Args[2].getAsInteger(10, MinorVersion)) return true; 1481 if (Args[3].getAsInteger(2, Hashed)) return true; 1482 if (Args.size() > 4) 1483 UserInfo = std::string(Args[4]); 1484 return false; 1485 } 1486 1487 static InputKind ParseFrontendArgs(FrontendOptions &Opts, ArgList &Args, 1488 DiagnosticsEngine &Diags, 1489 bool &IsHeaderFile) { 1490 Opts.ProgramAction = frontend::ParseSyntaxOnly; 1491 if (const Arg *A = Args.getLastArg(OPT_Action_Group)) { 1492 switch (A->getOption().getID()) { 1493 default: 1494 llvm_unreachable("Invalid option in group!"); 1495 case OPT_ast_list: 1496 Opts.ProgramAction = frontend::ASTDeclList; break; 1497 case OPT_ast_dump_all_EQ: 1498 case OPT_ast_dump_EQ: { 1499 unsigned Val = llvm::StringSwitch<unsigned>(A->getValue()) 1500 .CaseLower("default", ADOF_Default) 1501 .CaseLower("json", ADOF_JSON) 1502 .Default(std::numeric_limits<unsigned>::max()); 1503 1504 if (Val != std::numeric_limits<unsigned>::max()) 1505 Opts.ASTDumpFormat = static_cast<ASTDumpOutputFormat>(Val); 1506 else { 1507 Diags.Report(diag::err_drv_invalid_value) 1508 << A->getAsString(Args) << A->getValue(); 1509 Opts.ASTDumpFormat = ADOF_Default; 1510 } 1511 LLVM_FALLTHROUGH; 1512 } 1513 case OPT_ast_dump: 1514 case OPT_ast_dump_all: 1515 case OPT_ast_dump_lookups: 1516 case OPT_ast_dump_decl_types: 1517 Opts.ProgramAction = frontend::ASTDump; break; 1518 case OPT_ast_print: 1519 Opts.ProgramAction = frontend::ASTPrint; break; 1520 case OPT_ast_view: 1521 Opts.ProgramAction = frontend::ASTView; break; 1522 case OPT_compiler_options_dump: 1523 Opts.ProgramAction = frontend::DumpCompilerOptions; break; 1524 case OPT_dump_raw_tokens: 1525 Opts.ProgramAction = frontend::DumpRawTokens; break; 1526 case OPT_dump_tokens: 1527 Opts.ProgramAction = frontend::DumpTokens; break; 1528 case OPT_S: 1529 Opts.ProgramAction = frontend::EmitAssembly; break; 1530 case OPT_emit_llvm_bc: 1531 Opts.ProgramAction = frontend::EmitBC; break; 1532 case OPT_emit_html: 1533 Opts.ProgramAction = frontend::EmitHTML; break; 1534 case OPT_emit_llvm: 1535 Opts.ProgramAction = frontend::EmitLLVM; break; 1536 case OPT_emit_llvm_only: 1537 Opts.ProgramAction = frontend::EmitLLVMOnly; break; 1538 case OPT_emit_codegen_only: 1539 Opts.ProgramAction = frontend::EmitCodeGenOnly; break; 1540 case OPT_emit_obj: 1541 Opts.ProgramAction = frontend::EmitObj; break; 1542 case OPT_fixit_EQ: 1543 Opts.FixItSuffix = A->getValue(); 1544 LLVM_FALLTHROUGH; 1545 case OPT_fixit: 1546 Opts.ProgramAction = frontend::FixIt; break; 1547 case OPT_emit_module: 1548 Opts.ProgramAction = frontend::GenerateModule; break; 1549 case OPT_emit_module_interface: 1550 Opts.ProgramAction = frontend::GenerateModuleInterface; break; 1551 case OPT_emit_header_module: 1552 Opts.ProgramAction = frontend::GenerateHeaderModule; break; 1553 case OPT_emit_pch: 1554 Opts.ProgramAction = frontend::GeneratePCH; break; 1555 case OPT_emit_interface_stubs: { 1556 StringRef ArgStr = 1557 Args.hasArg(OPT_interface_stub_version_EQ) 1558 ? Args.getLastArgValue(OPT_interface_stub_version_EQ) 1559 : "experimental-ifs-v2"; 1560 if (ArgStr == "experimental-yaml-elf-v1" || 1561 ArgStr == "experimental-ifs-v1" || 1562 ArgStr == "experimental-tapi-elf-v1") { 1563 std::string ErrorMessage = 1564 "Invalid interface stub format: " + ArgStr.str() + 1565 " is deprecated."; 1566 Diags.Report(diag::err_drv_invalid_value) 1567 << "Must specify a valid interface stub format type, ie: " 1568 "-interface-stub-version=experimental-ifs-v2" 1569 << ErrorMessage; 1570 } else if (!ArgStr.startswith("experimental-ifs-")) { 1571 std::string ErrorMessage = 1572 "Invalid interface stub format: " + ArgStr.str() + "."; 1573 Diags.Report(diag::err_drv_invalid_value) 1574 << "Must specify a valid interface stub format type, ie: " 1575 "-interface-stub-version=experimental-ifs-v2" 1576 << ErrorMessage; 1577 } else { 1578 Opts.ProgramAction = frontend::GenerateInterfaceStubs; 1579 } 1580 break; 1581 } 1582 case OPT_init_only: 1583 Opts.ProgramAction = frontend::InitOnly; break; 1584 case OPT_fsyntax_only: 1585 Opts.ProgramAction = frontend::ParseSyntaxOnly; break; 1586 case OPT_module_file_info: 1587 Opts.ProgramAction = frontend::ModuleFileInfo; break; 1588 case OPT_verify_pch: 1589 Opts.ProgramAction = frontend::VerifyPCH; break; 1590 case OPT_print_preamble: 1591 Opts.ProgramAction = frontend::PrintPreamble; break; 1592 case OPT_E: 1593 Opts.ProgramAction = frontend::PrintPreprocessedInput; break; 1594 case OPT_templight_dump: 1595 Opts.ProgramAction = frontend::TemplightDump; break; 1596 case OPT_rewrite_macros: 1597 Opts.ProgramAction = frontend::RewriteMacros; break; 1598 case OPT_rewrite_objc: 1599 Opts.ProgramAction = frontend::RewriteObjC; break; 1600 case OPT_rewrite_test: 1601 Opts.ProgramAction = frontend::RewriteTest; break; 1602 case OPT_analyze: 1603 Opts.ProgramAction = frontend::RunAnalysis; break; 1604 case OPT_migrate: 1605 Opts.ProgramAction = frontend::MigrateSource; break; 1606 case OPT_Eonly: 1607 Opts.ProgramAction = frontend::RunPreprocessorOnly; break; 1608 case OPT_print_dependency_directives_minimized_source: 1609 Opts.ProgramAction = 1610 frontend::PrintDependencyDirectivesSourceMinimizerOutput; 1611 break; 1612 } 1613 } 1614 1615 if (const Arg* A = Args.getLastArg(OPT_plugin)) { 1616 Opts.Plugins.emplace_back(A->getValue(0)); 1617 Opts.ProgramAction = frontend::PluginAction; 1618 Opts.ActionName = A->getValue(); 1619 } 1620 Opts.AddPluginActions = Args.getAllArgValues(OPT_add_plugin); 1621 for (const auto *AA : Args.filtered(OPT_plugin_arg)) 1622 Opts.PluginArgs[AA->getValue(0)].emplace_back(AA->getValue(1)); 1623 1624 for (const std::string &Arg : 1625 Args.getAllArgValues(OPT_ftest_module_file_extension_EQ)) { 1626 std::string BlockName; 1627 unsigned MajorVersion; 1628 unsigned MinorVersion; 1629 bool Hashed; 1630 std::string UserInfo; 1631 if (parseTestModuleFileExtensionArg(Arg, BlockName, MajorVersion, 1632 MinorVersion, Hashed, UserInfo)) { 1633 Diags.Report(diag::err_test_module_file_extension_format) << Arg; 1634 1635 continue; 1636 } 1637 1638 // Add the testing module file extension. 1639 Opts.ModuleFileExtensions.push_back( 1640 std::make_shared<TestModuleFileExtension>( 1641 BlockName, MajorVersion, MinorVersion, Hashed, UserInfo)); 1642 } 1643 1644 if (const Arg *A = Args.getLastArg(OPT_code_completion_at)) { 1645 Opts.CodeCompletionAt = 1646 ParsedSourceLocation::FromString(A->getValue()); 1647 if (Opts.CodeCompletionAt.FileName.empty()) 1648 Diags.Report(diag::err_drv_invalid_value) 1649 << A->getAsString(Args) << A->getValue(); 1650 } 1651 1652 Opts.Plugins = Args.getAllArgValues(OPT_load); 1653 Opts.ASTDumpDecls = Args.hasArg(OPT_ast_dump, OPT_ast_dump_EQ); 1654 Opts.ASTDumpAll = Args.hasArg(OPT_ast_dump_all, OPT_ast_dump_all_EQ); 1655 // Only the -fmodule-file=<file> form. 1656 for (const auto *A : Args.filtered(OPT_fmodule_file)) { 1657 StringRef Val = A->getValue(); 1658 if (Val.find('=') == StringRef::npos) 1659 Opts.ModuleFiles.push_back(std::string(Val)); 1660 } 1661 Opts.AllowPCMWithCompilerErrors = Args.hasArg(OPT_fallow_pcm_with_errors); 1662 1663 if (Opts.ProgramAction != frontend::GenerateModule && Opts.IsSystemModule) 1664 Diags.Report(diag::err_drv_argument_only_allowed_with) << "-fsystem-module" 1665 << "-emit-module"; 1666 1667 if (Args.hasArg(OPT_aux_target_cpu)) 1668 Opts.AuxTargetCPU = std::string(Args.getLastArgValue(OPT_aux_target_cpu)); 1669 if (Args.hasArg(OPT_aux_target_feature)) 1670 Opts.AuxTargetFeatures = Args.getAllArgValues(OPT_aux_target_feature); 1671 1672 if (Opts.ARCMTAction != FrontendOptions::ARCMT_None && 1673 Opts.ObjCMTAction != FrontendOptions::ObjCMT_None) { 1674 Diags.Report(diag::err_drv_argument_not_allowed_with) 1675 << "ARC migration" << "ObjC migration"; 1676 } 1677 1678 InputKind DashX(Language::Unknown); 1679 if (const Arg *A = Args.getLastArg(OPT_x)) { 1680 StringRef XValue = A->getValue(); 1681 1682 // Parse suffixes: '<lang>(-header|[-module-map][-cpp-output])'. 1683 // FIXME: Supporting '<lang>-header-cpp-output' would be useful. 1684 bool Preprocessed = XValue.consume_back("-cpp-output"); 1685 bool ModuleMap = XValue.consume_back("-module-map"); 1686 IsHeaderFile = !Preprocessed && !ModuleMap && 1687 XValue != "precompiled-header" && 1688 XValue.consume_back("-header"); 1689 1690 // Principal languages. 1691 DashX = llvm::StringSwitch<InputKind>(XValue) 1692 .Case("c", Language::C) 1693 .Case("cl", Language::OpenCL) 1694 .Case("cuda", Language::CUDA) 1695 .Case("hip", Language::HIP) 1696 .Case("c++", Language::CXX) 1697 .Case("objective-c", Language::ObjC) 1698 .Case("objective-c++", Language::ObjCXX) 1699 .Case("renderscript", Language::RenderScript) 1700 .Default(Language::Unknown); 1701 1702 // "objc[++]-cpp-output" is an acceptable synonym for 1703 // "objective-c[++]-cpp-output". 1704 if (DashX.isUnknown() && Preprocessed && !IsHeaderFile && !ModuleMap) 1705 DashX = llvm::StringSwitch<InputKind>(XValue) 1706 .Case("objc", Language::ObjC) 1707 .Case("objc++", Language::ObjCXX) 1708 .Default(Language::Unknown); 1709 1710 // Some special cases cannot be combined with suffixes. 1711 if (DashX.isUnknown() && !Preprocessed && !ModuleMap && !IsHeaderFile) 1712 DashX = llvm::StringSwitch<InputKind>(XValue) 1713 .Case("cpp-output", InputKind(Language::C).getPreprocessed()) 1714 .Case("assembler-with-cpp", Language::Asm) 1715 .Cases("ast", "pcm", "precompiled-header", 1716 InputKind(Language::Unknown, InputKind::Precompiled)) 1717 .Case("ir", Language::LLVM_IR) 1718 .Default(Language::Unknown); 1719 1720 if (DashX.isUnknown()) 1721 Diags.Report(diag::err_drv_invalid_value) 1722 << A->getAsString(Args) << A->getValue(); 1723 1724 if (Preprocessed) 1725 DashX = DashX.getPreprocessed(); 1726 if (ModuleMap) 1727 DashX = DashX.withFormat(InputKind::ModuleMap); 1728 } 1729 1730 // '-' is the default input if none is given. 1731 std::vector<std::string> Inputs = Args.getAllArgValues(OPT_INPUT); 1732 Opts.Inputs.clear(); 1733 if (Inputs.empty()) 1734 Inputs.push_back("-"); 1735 for (unsigned i = 0, e = Inputs.size(); i != e; ++i) { 1736 InputKind IK = DashX; 1737 if (IK.isUnknown()) { 1738 IK = FrontendOptions::getInputKindForExtension( 1739 StringRef(Inputs[i]).rsplit('.').second); 1740 // FIXME: Warn on this? 1741 if (IK.isUnknown()) 1742 IK = Language::C; 1743 // FIXME: Remove this hack. 1744 if (i == 0) 1745 DashX = IK; 1746 } 1747 1748 bool IsSystem = false; 1749 1750 // The -emit-module action implicitly takes a module map. 1751 if (Opts.ProgramAction == frontend::GenerateModule && 1752 IK.getFormat() == InputKind::Source) { 1753 IK = IK.withFormat(InputKind::ModuleMap); 1754 IsSystem = Opts.IsSystemModule; 1755 } 1756 1757 Opts.Inputs.emplace_back(std::move(Inputs[i]), IK, IsSystem); 1758 } 1759 1760 return DashX; 1761 } 1762 1763 std::string CompilerInvocation::GetResourcesPath(const char *Argv0, 1764 void *MainAddr) { 1765 std::string ClangExecutable = 1766 llvm::sys::fs::getMainExecutable(Argv0, MainAddr); 1767 return Driver::GetResourcesPath(ClangExecutable, CLANG_RESOURCE_DIR); 1768 } 1769 1770 static void ParseHeaderSearchArgs(HeaderSearchOptions &Opts, ArgList &Args, 1771 const std::string &WorkingDir) { 1772 if (const Arg *A = Args.getLastArg(OPT_stdlib_EQ)) 1773 Opts.UseLibcxx = (strcmp(A->getValue(), "libc++") == 0); 1774 1775 // Canonicalize -fmodules-cache-path before storing it. 1776 SmallString<128> P(Args.getLastArgValue(OPT_fmodules_cache_path)); 1777 if (!(P.empty() || llvm::sys::path::is_absolute(P))) { 1778 if (WorkingDir.empty()) 1779 llvm::sys::fs::make_absolute(P); 1780 else 1781 llvm::sys::fs::make_absolute(WorkingDir, P); 1782 } 1783 llvm::sys::path::remove_dots(P); 1784 Opts.ModuleCachePath = std::string(P.str()); 1785 1786 // Only the -fmodule-file=<name>=<file> form. 1787 for (const auto *A : Args.filtered(OPT_fmodule_file)) { 1788 StringRef Val = A->getValue(); 1789 if (Val.find('=') != StringRef::npos){ 1790 auto Split = Val.split('='); 1791 Opts.PrebuiltModuleFiles.insert( 1792 {std::string(Split.first), std::string(Split.second)}); 1793 } 1794 } 1795 for (const auto *A : Args.filtered(OPT_fprebuilt_module_path)) 1796 Opts.AddPrebuiltModulePath(A->getValue()); 1797 1798 for (const auto *A : Args.filtered(OPT_fmodules_ignore_macro)) { 1799 StringRef MacroDef = A->getValue(); 1800 Opts.ModulesIgnoreMacros.insert( 1801 llvm::CachedHashString(MacroDef.split('=').first)); 1802 } 1803 1804 // Add -I..., -F..., and -index-header-map options in order. 1805 bool IsIndexHeaderMap = false; 1806 bool IsSysrootSpecified = 1807 Args.hasArg(OPT__sysroot_EQ) || Args.hasArg(OPT_isysroot); 1808 for (const auto *A : Args.filtered(OPT_I, OPT_F, OPT_index_header_map)) { 1809 if (A->getOption().matches(OPT_index_header_map)) { 1810 // -index-header-map applies to the next -I or -F. 1811 IsIndexHeaderMap = true; 1812 continue; 1813 } 1814 1815 frontend::IncludeDirGroup Group = 1816 IsIndexHeaderMap ? frontend::IndexHeaderMap : frontend::Angled; 1817 1818 bool IsFramework = A->getOption().matches(OPT_F); 1819 std::string Path = A->getValue(); 1820 1821 if (IsSysrootSpecified && !IsFramework && A->getValue()[0] == '=') { 1822 SmallString<32> Buffer; 1823 llvm::sys::path::append(Buffer, Opts.Sysroot, 1824 llvm::StringRef(A->getValue()).substr(1)); 1825 Path = std::string(Buffer.str()); 1826 } 1827 1828 Opts.AddPath(Path, Group, IsFramework, 1829 /*IgnoreSysroot*/ true); 1830 IsIndexHeaderMap = false; 1831 } 1832 1833 // Add -iprefix/-iwithprefix/-iwithprefixbefore options. 1834 StringRef Prefix = ""; // FIXME: This isn't the correct default prefix. 1835 for (const auto *A : 1836 Args.filtered(OPT_iprefix, OPT_iwithprefix, OPT_iwithprefixbefore)) { 1837 if (A->getOption().matches(OPT_iprefix)) 1838 Prefix = A->getValue(); 1839 else if (A->getOption().matches(OPT_iwithprefix)) 1840 Opts.AddPath(Prefix.str() + A->getValue(), frontend::After, false, true); 1841 else 1842 Opts.AddPath(Prefix.str() + A->getValue(), frontend::Angled, false, true); 1843 } 1844 1845 for (const auto *A : Args.filtered(OPT_idirafter)) 1846 Opts.AddPath(A->getValue(), frontend::After, false, true); 1847 for (const auto *A : Args.filtered(OPT_iquote)) 1848 Opts.AddPath(A->getValue(), frontend::Quoted, false, true); 1849 for (const auto *A : Args.filtered(OPT_isystem, OPT_iwithsysroot)) 1850 Opts.AddPath(A->getValue(), frontend::System, false, 1851 !A->getOption().matches(OPT_iwithsysroot)); 1852 for (const auto *A : Args.filtered(OPT_iframework)) 1853 Opts.AddPath(A->getValue(), frontend::System, true, true); 1854 for (const auto *A : Args.filtered(OPT_iframeworkwithsysroot)) 1855 Opts.AddPath(A->getValue(), frontend::System, /*IsFramework=*/true, 1856 /*IgnoreSysRoot=*/false); 1857 1858 // Add the paths for the various language specific isystem flags. 1859 for (const auto *A : Args.filtered(OPT_c_isystem)) 1860 Opts.AddPath(A->getValue(), frontend::CSystem, false, true); 1861 for (const auto *A : Args.filtered(OPT_cxx_isystem)) 1862 Opts.AddPath(A->getValue(), frontend::CXXSystem, false, true); 1863 for (const auto *A : Args.filtered(OPT_objc_isystem)) 1864 Opts.AddPath(A->getValue(), frontend::ObjCSystem, false,true); 1865 for (const auto *A : Args.filtered(OPT_objcxx_isystem)) 1866 Opts.AddPath(A->getValue(), frontend::ObjCXXSystem, false, true); 1867 1868 // Add the internal paths from a driver that detects standard include paths. 1869 for (const auto *A : 1870 Args.filtered(OPT_internal_isystem, OPT_internal_externc_isystem)) { 1871 frontend::IncludeDirGroup Group = frontend::System; 1872 if (A->getOption().matches(OPT_internal_externc_isystem)) 1873 Group = frontend::ExternCSystem; 1874 Opts.AddPath(A->getValue(), Group, false, true); 1875 } 1876 1877 // Add the path prefixes which are implicitly treated as being system headers. 1878 for (const auto *A : 1879 Args.filtered(OPT_system_header_prefix, OPT_no_system_header_prefix)) 1880 Opts.AddSystemHeaderPrefix( 1881 A->getValue(), A->getOption().matches(OPT_system_header_prefix)); 1882 1883 for (const auto *A : Args.filtered(OPT_ivfsoverlay)) 1884 Opts.AddVFSOverlayFile(A->getValue()); 1885 } 1886 1887 void CompilerInvocation::setLangDefaults(LangOptions &Opts, InputKind IK, 1888 const llvm::Triple &T, 1889 std::vector<std::string> &Includes, 1890 LangStandard::Kind LangStd) { 1891 // Set some properties which depend solely on the input kind; it would be nice 1892 // to move these to the language standard, and have the driver resolve the 1893 // input kind + language standard. 1894 // 1895 // FIXME: Perhaps a better model would be for a single source file to have 1896 // multiple language standards (C / C++ std, ObjC std, OpenCL std, OpenMP std) 1897 // simultaneously active? 1898 if (IK.getLanguage() == Language::Asm) { 1899 Opts.AsmPreprocessor = 1; 1900 } else if (IK.isObjectiveC()) { 1901 Opts.ObjC = 1; 1902 } 1903 1904 if (LangStd == LangStandard::lang_unspecified) { 1905 // Based on the base language, pick one. 1906 switch (IK.getLanguage()) { 1907 case Language::Unknown: 1908 case Language::LLVM_IR: 1909 llvm_unreachable("Invalid input kind!"); 1910 case Language::OpenCL: 1911 LangStd = LangStandard::lang_opencl10; 1912 break; 1913 case Language::CUDA: 1914 LangStd = LangStandard::lang_cuda; 1915 break; 1916 case Language::Asm: 1917 case Language::C: 1918 #if defined(CLANG_DEFAULT_STD_C) 1919 LangStd = CLANG_DEFAULT_STD_C; 1920 #else 1921 // The PS4 uses C99 as the default C standard. 1922 if (T.isPS4()) 1923 LangStd = LangStandard::lang_gnu99; 1924 else 1925 LangStd = LangStandard::lang_gnu17; 1926 #endif 1927 break; 1928 case Language::ObjC: 1929 #if defined(CLANG_DEFAULT_STD_C) 1930 LangStd = CLANG_DEFAULT_STD_C; 1931 #else 1932 LangStd = LangStandard::lang_gnu11; 1933 #endif 1934 break; 1935 case Language::CXX: 1936 case Language::ObjCXX: 1937 #if defined(CLANG_DEFAULT_STD_CXX) 1938 LangStd = CLANG_DEFAULT_STD_CXX; 1939 #else 1940 LangStd = LangStandard::lang_gnucxx14; 1941 #endif 1942 break; 1943 case Language::RenderScript: 1944 LangStd = LangStandard::lang_c99; 1945 break; 1946 case Language::HIP: 1947 LangStd = LangStandard::lang_hip; 1948 break; 1949 } 1950 } 1951 1952 const LangStandard &Std = LangStandard::getLangStandardForKind(LangStd); 1953 Opts.LineComment = Std.hasLineComments(); 1954 Opts.C99 = Std.isC99(); 1955 Opts.C11 = Std.isC11(); 1956 Opts.C17 = Std.isC17(); 1957 Opts.C2x = Std.isC2x(); 1958 Opts.CPlusPlus = Std.isCPlusPlus(); 1959 Opts.CPlusPlus11 = Std.isCPlusPlus11(); 1960 Opts.CPlusPlus14 = Std.isCPlusPlus14(); 1961 Opts.CPlusPlus17 = Std.isCPlusPlus17(); 1962 Opts.CPlusPlus20 = Std.isCPlusPlus20(); 1963 Opts.CPlusPlus2b = Std.isCPlusPlus2b(); 1964 Opts.Digraphs = Std.hasDigraphs(); 1965 Opts.GNUMode = Std.isGNUMode(); 1966 Opts.GNUInline = !Opts.C99 && !Opts.CPlusPlus; 1967 Opts.GNUCVersion = 0; 1968 Opts.HexFloats = Std.hasHexFloats(); 1969 Opts.ImplicitInt = Std.hasImplicitInt(); 1970 1971 // Set OpenCL Version. 1972 Opts.OpenCL = Std.isOpenCL(); 1973 if (LangStd == LangStandard::lang_opencl10) 1974 Opts.OpenCLVersion = 100; 1975 else if (LangStd == LangStandard::lang_opencl11) 1976 Opts.OpenCLVersion = 110; 1977 else if (LangStd == LangStandard::lang_opencl12) 1978 Opts.OpenCLVersion = 120; 1979 else if (LangStd == LangStandard::lang_opencl20) 1980 Opts.OpenCLVersion = 200; 1981 else if (LangStd == LangStandard::lang_opencl30) 1982 Opts.OpenCLVersion = 300; 1983 else if (LangStd == LangStandard::lang_openclcpp) 1984 Opts.OpenCLCPlusPlusVersion = 100; 1985 1986 // OpenCL has some additional defaults. 1987 if (Opts.OpenCL) { 1988 Opts.AltiVec = 0; 1989 Opts.ZVector = 0; 1990 Opts.setLaxVectorConversions(LangOptions::LaxVectorConversionKind::None); 1991 Opts.setDefaultFPContractMode(LangOptions::FPM_On); 1992 Opts.NativeHalfType = 1; 1993 Opts.NativeHalfArgsAndReturns = 1; 1994 Opts.OpenCLCPlusPlus = Opts.CPlusPlus; 1995 1996 // Include default header file for OpenCL. 1997 if (Opts.IncludeDefaultHeader) { 1998 if (Opts.DeclareOpenCLBuiltins) { 1999 // Only include base header file for builtin types and constants. 2000 Includes.push_back("opencl-c-base.h"); 2001 } else { 2002 Includes.push_back("opencl-c.h"); 2003 } 2004 } 2005 } 2006 2007 Opts.HIP = IK.getLanguage() == Language::HIP; 2008 Opts.CUDA = IK.getLanguage() == Language::CUDA || Opts.HIP; 2009 if (Opts.HIP) { 2010 // HIP toolchain does not support 'Fast' FPOpFusion in backends since it 2011 // fuses multiplication/addition instructions without contract flag from 2012 // device library functions in LLVM bitcode, which causes accuracy loss in 2013 // certain math functions, e.g. tan(-1e20) becomes -0.933 instead of 0.8446. 2014 // For device library functions in bitcode to work, 'Strict' or 'Standard' 2015 // FPOpFusion options in backends is needed. Therefore 'fast-honor-pragmas' 2016 // FP contract option is used to allow fuse across statements in frontend 2017 // whereas respecting contract flag in backend. 2018 Opts.setDefaultFPContractMode(LangOptions::FPM_FastHonorPragmas); 2019 } else if (Opts.CUDA) { 2020 // Allow fuse across statements disregarding pragmas. 2021 Opts.setDefaultFPContractMode(LangOptions::FPM_Fast); 2022 } 2023 2024 Opts.RenderScript = IK.getLanguage() == Language::RenderScript; 2025 if (Opts.RenderScript) { 2026 Opts.NativeHalfType = 1; 2027 Opts.NativeHalfArgsAndReturns = 1; 2028 } 2029 2030 // OpenCL and C++ both have bool, true, false keywords. 2031 Opts.Bool = Opts.OpenCL || Opts.CPlusPlus; 2032 2033 // OpenCL has half keyword 2034 Opts.Half = Opts.OpenCL; 2035 2036 // C++ has wchar_t keyword. 2037 Opts.WChar = Opts.CPlusPlus; 2038 2039 Opts.GNUKeywords = Opts.GNUMode; 2040 Opts.CXXOperatorNames = Opts.CPlusPlus; 2041 2042 Opts.AlignedAllocation = Opts.CPlusPlus17; 2043 2044 Opts.DollarIdents = !Opts.AsmPreprocessor; 2045 2046 // Enable [[]] attributes in C++11 and C2x by default. 2047 Opts.DoubleSquareBracketAttributes = Opts.CPlusPlus11 || Opts.C2x; 2048 } 2049 2050 /// Attempt to parse a visibility value out of the given argument. 2051 static Visibility parseVisibility(Arg *arg, ArgList &args, 2052 DiagnosticsEngine &diags) { 2053 StringRef value = arg->getValue(); 2054 if (value == "default") { 2055 return DefaultVisibility; 2056 } else if (value == "hidden" || value == "internal") { 2057 return HiddenVisibility; 2058 } else if (value == "protected") { 2059 // FIXME: diagnose if target does not support protected visibility 2060 return ProtectedVisibility; 2061 } 2062 2063 diags.Report(diag::err_drv_invalid_value) 2064 << arg->getAsString(args) << value; 2065 return DefaultVisibility; 2066 } 2067 2068 /// Check if input file kind and language standard are compatible. 2069 static bool IsInputCompatibleWithStandard(InputKind IK, 2070 const LangStandard &S) { 2071 switch (IK.getLanguage()) { 2072 case Language::Unknown: 2073 case Language::LLVM_IR: 2074 llvm_unreachable("should not parse language flags for this input"); 2075 2076 case Language::C: 2077 case Language::ObjC: 2078 case Language::RenderScript: 2079 return S.getLanguage() == Language::C; 2080 2081 case Language::OpenCL: 2082 return S.getLanguage() == Language::OpenCL; 2083 2084 case Language::CXX: 2085 case Language::ObjCXX: 2086 return S.getLanguage() == Language::CXX; 2087 2088 case Language::CUDA: 2089 // FIXME: What -std= values should be permitted for CUDA compilations? 2090 return S.getLanguage() == Language::CUDA || 2091 S.getLanguage() == Language::CXX; 2092 2093 case Language::HIP: 2094 return S.getLanguage() == Language::CXX || S.getLanguage() == Language::HIP; 2095 2096 case Language::Asm: 2097 // Accept (and ignore) all -std= values. 2098 // FIXME: The -std= value is not ignored; it affects the tokenization 2099 // and preprocessing rules if we're preprocessing this asm input. 2100 return true; 2101 } 2102 2103 llvm_unreachable("unexpected input language"); 2104 } 2105 2106 /// Get language name for given input kind. 2107 static const StringRef GetInputKindName(InputKind IK) { 2108 switch (IK.getLanguage()) { 2109 case Language::C: 2110 return "C"; 2111 case Language::ObjC: 2112 return "Objective-C"; 2113 case Language::CXX: 2114 return "C++"; 2115 case Language::ObjCXX: 2116 return "Objective-C++"; 2117 case Language::OpenCL: 2118 return "OpenCL"; 2119 case Language::CUDA: 2120 return "CUDA"; 2121 case Language::RenderScript: 2122 return "RenderScript"; 2123 case Language::HIP: 2124 return "HIP"; 2125 2126 case Language::Asm: 2127 return "Asm"; 2128 case Language::LLVM_IR: 2129 return "LLVM IR"; 2130 2131 case Language::Unknown: 2132 break; 2133 } 2134 llvm_unreachable("unknown input language"); 2135 } 2136 2137 static void ParseLangArgs(LangOptions &Opts, ArgList &Args, InputKind IK, 2138 const llvm::Triple &T, 2139 std::vector<std::string> &Includes, 2140 DiagnosticsEngine &Diags) { 2141 // FIXME: Cleanup per-file based stuff. 2142 LangStandard::Kind LangStd = LangStandard::lang_unspecified; 2143 if (const Arg *A = Args.getLastArg(OPT_std_EQ)) { 2144 LangStd = LangStandard::getLangKind(A->getValue()); 2145 if (LangStd == LangStandard::lang_unspecified) { 2146 Diags.Report(diag::err_drv_invalid_value) 2147 << A->getAsString(Args) << A->getValue(); 2148 // Report supported standards with short description. 2149 for (unsigned KindValue = 0; 2150 KindValue != LangStandard::lang_unspecified; 2151 ++KindValue) { 2152 const LangStandard &Std = LangStandard::getLangStandardForKind( 2153 static_cast<LangStandard::Kind>(KindValue)); 2154 if (IsInputCompatibleWithStandard(IK, Std)) { 2155 auto Diag = Diags.Report(diag::note_drv_use_standard); 2156 Diag << Std.getName() << Std.getDescription(); 2157 unsigned NumAliases = 0; 2158 #define LANGSTANDARD(id, name, lang, desc, features) 2159 #define LANGSTANDARD_ALIAS(id, alias) \ 2160 if (KindValue == LangStandard::lang_##id) ++NumAliases; 2161 #define LANGSTANDARD_ALIAS_DEPR(id, alias) 2162 #include "clang/Basic/LangStandards.def" 2163 Diag << NumAliases; 2164 #define LANGSTANDARD(id, name, lang, desc, features) 2165 #define LANGSTANDARD_ALIAS(id, alias) \ 2166 if (KindValue == LangStandard::lang_##id) Diag << alias; 2167 #define LANGSTANDARD_ALIAS_DEPR(id, alias) 2168 #include "clang/Basic/LangStandards.def" 2169 } 2170 } 2171 } else { 2172 // Valid standard, check to make sure language and standard are 2173 // compatible. 2174 const LangStandard &Std = LangStandard::getLangStandardForKind(LangStd); 2175 if (!IsInputCompatibleWithStandard(IK, Std)) { 2176 Diags.Report(diag::err_drv_argument_not_allowed_with) 2177 << A->getAsString(Args) << GetInputKindName(IK); 2178 } 2179 } 2180 } 2181 2182 if (const Arg *A = Args.getLastArg(OPT_fcf_protection_EQ)) { 2183 StringRef Name = A->getValue(); 2184 if (Name == "full" || Name == "branch") { 2185 Opts.CFProtectionBranch = 1; 2186 } 2187 } 2188 // -cl-std only applies for OpenCL language standards. 2189 // Override the -std option in this case. 2190 if (const Arg *A = Args.getLastArg(OPT_cl_std_EQ)) { 2191 LangStandard::Kind OpenCLLangStd 2192 = llvm::StringSwitch<LangStandard::Kind>(A->getValue()) 2193 .Cases("cl", "CL", LangStandard::lang_opencl10) 2194 .Cases("cl1.0", "CL1.0", LangStandard::lang_opencl10) 2195 .Cases("cl1.1", "CL1.1", LangStandard::lang_opencl11) 2196 .Cases("cl1.2", "CL1.2", LangStandard::lang_opencl12) 2197 .Cases("cl2.0", "CL2.0", LangStandard::lang_opencl20) 2198 .Cases("cl3.0", "CL3.0", LangStandard::lang_opencl30) 2199 .Cases("clc++", "CLC++", LangStandard::lang_openclcpp) 2200 .Default(LangStandard::lang_unspecified); 2201 2202 if (OpenCLLangStd == LangStandard::lang_unspecified) { 2203 Diags.Report(diag::err_drv_invalid_value) 2204 << A->getAsString(Args) << A->getValue(); 2205 } 2206 else 2207 LangStd = OpenCLLangStd; 2208 } 2209 2210 Opts.SYCLIsDevice = Opts.SYCL && Args.hasArg(options::OPT_fsycl_is_device); 2211 2212 CompilerInvocation::setLangDefaults(Opts, IK, T, Includes, LangStd); 2213 2214 // -cl-strict-aliasing needs to emit diagnostic in the case where CL > 1.0. 2215 // This option should be deprecated for CL > 1.0 because 2216 // this option was added for compatibility with OpenCL 1.0. 2217 if (Args.getLastArg(OPT_cl_strict_aliasing) 2218 && Opts.OpenCLVersion > 100) { 2219 Diags.Report(diag::warn_option_invalid_ocl_version) 2220 << Opts.getOpenCLVersionTuple().getAsString() 2221 << Args.getLastArg(OPT_cl_strict_aliasing)->getAsString(Args); 2222 } 2223 2224 // We abuse '-f[no-]gnu-keywords' to force overriding all GNU-extension 2225 // keywords. This behavior is provided by GCC's poorly named '-fasm' flag, 2226 // while a subset (the non-C++ GNU keywords) is provided by GCC's 2227 // '-fgnu-keywords'. Clang conflates the two for simplicity under the single 2228 // name, as it doesn't seem a useful distinction. 2229 Opts.GNUKeywords = Args.hasFlag(OPT_fgnu_keywords, OPT_fno_gnu_keywords, 2230 Opts.GNUKeywords); 2231 2232 Opts.Digraphs = Args.hasFlag(OPT_fdigraphs, OPT_fno_digraphs, Opts.Digraphs); 2233 2234 if (Args.hasArg(OPT_fno_operator_names)) 2235 Opts.CXXOperatorNames = 0; 2236 2237 if (Opts.CUDAIsDevice && Args.hasArg(OPT_fcuda_approx_transcendentals)) 2238 Opts.CUDADeviceApproxTranscendentals = 1; 2239 2240 if (Args.hasArg(OPT_fgpu_allow_device_init)) { 2241 if (Opts.HIP) 2242 Opts.GPUAllowDeviceInit = 1; 2243 else 2244 Diags.Report(diag::warn_ignored_hip_only_option) 2245 << Args.getLastArg(OPT_fgpu_allow_device_init)->getAsString(Args); 2246 } 2247 if (Opts.HIP) 2248 Opts.GPUMaxThreadsPerBlock = getLastArgIntValue( 2249 Args, OPT_gpu_max_threads_per_block_EQ, Opts.GPUMaxThreadsPerBlock); 2250 else if (Args.hasArg(OPT_gpu_max_threads_per_block_EQ)) 2251 Diags.Report(diag::warn_ignored_hip_only_option) 2252 << Args.getLastArg(OPT_gpu_max_threads_per_block_EQ)->getAsString(Args); 2253 2254 if (Opts.ObjC) { 2255 if (Arg *arg = Args.getLastArg(OPT_fobjc_runtime_EQ)) { 2256 StringRef value = arg->getValue(); 2257 if (Opts.ObjCRuntime.tryParse(value)) 2258 Diags.Report(diag::err_drv_unknown_objc_runtime) << value; 2259 } 2260 2261 if (Args.hasArg(OPT_fobjc_gc_only)) 2262 Opts.setGC(LangOptions::GCOnly); 2263 else if (Args.hasArg(OPT_fobjc_gc)) 2264 Opts.setGC(LangOptions::HybridGC); 2265 else if (Args.hasArg(OPT_fobjc_arc)) { 2266 Opts.ObjCAutoRefCount = 1; 2267 if (!Opts.ObjCRuntime.allowsARC()) 2268 Diags.Report(diag::err_arc_unsupported_on_runtime); 2269 } 2270 2271 // ObjCWeakRuntime tracks whether the runtime supports __weak, not 2272 // whether the feature is actually enabled. This is predominantly 2273 // determined by -fobjc-runtime, but we allow it to be overridden 2274 // from the command line for testing purposes. 2275 if (Args.hasArg(OPT_fobjc_runtime_has_weak)) 2276 Opts.ObjCWeakRuntime = 1; 2277 else 2278 Opts.ObjCWeakRuntime = Opts.ObjCRuntime.allowsWeak(); 2279 2280 // ObjCWeak determines whether __weak is actually enabled. 2281 // Note that we allow -fno-objc-weak to disable this even in ARC mode. 2282 if (auto weakArg = Args.getLastArg(OPT_fobjc_weak, OPT_fno_objc_weak)) { 2283 if (!weakArg->getOption().matches(OPT_fobjc_weak)) { 2284 assert(!Opts.ObjCWeak); 2285 } else if (Opts.getGC() != LangOptions::NonGC) { 2286 Diags.Report(diag::err_objc_weak_with_gc); 2287 } else if (!Opts.ObjCWeakRuntime) { 2288 Diags.Report(diag::err_objc_weak_unsupported); 2289 } else { 2290 Opts.ObjCWeak = 1; 2291 } 2292 } else if (Opts.ObjCAutoRefCount) { 2293 Opts.ObjCWeak = Opts.ObjCWeakRuntime; 2294 } 2295 2296 if (Args.hasArg(OPT_fobjc_subscripting_legacy_runtime)) 2297 Opts.ObjCSubscriptingLegacyRuntime = 2298 (Opts.ObjCRuntime.getKind() == ObjCRuntime::FragileMacOSX); 2299 } 2300 2301 if (Arg *A = Args.getLastArg(options::OPT_fgnuc_version_EQ)) { 2302 // Check that the version has 1 to 3 components and the minor and patch 2303 // versions fit in two decimal digits. 2304 VersionTuple GNUCVer; 2305 bool Invalid = GNUCVer.tryParse(A->getValue()); 2306 unsigned Major = GNUCVer.getMajor(); 2307 unsigned Minor = GNUCVer.getMinor().getValueOr(0); 2308 unsigned Patch = GNUCVer.getSubminor().getValueOr(0); 2309 if (Invalid || GNUCVer.getBuild() || Minor >= 100 || Patch >= 100) { 2310 Diags.Report(diag::err_drv_invalid_value) 2311 << A->getAsString(Args) << A->getValue(); 2312 } 2313 Opts.GNUCVersion = Major * 100 * 100 + Minor * 100 + Patch; 2314 } 2315 2316 if (Args.hasArg(OPT_fgnu89_inline)) { 2317 if (Opts.CPlusPlus) 2318 Diags.Report(diag::err_drv_argument_not_allowed_with) 2319 << "-fgnu89-inline" << GetInputKindName(IK); 2320 else 2321 Opts.GNUInline = 1; 2322 } 2323 2324 // The type-visibility mode defaults to the value-visibility mode. 2325 if (Arg *typeVisOpt = Args.getLastArg(OPT_ftype_visibility)) { 2326 Opts.setTypeVisibilityMode(parseVisibility(typeVisOpt, Args, Diags)); 2327 } else { 2328 Opts.setTypeVisibilityMode(Opts.getValueVisibilityMode()); 2329 } 2330 2331 if (Args.hasArg(OPT_fvisibility_from_dllstorageclass)) { 2332 Opts.VisibilityFromDLLStorageClass = 1; 2333 2334 // Translate dllexport defintions to default visibility, by default. 2335 if (Arg *O = Args.getLastArg(OPT_fvisibility_dllexport_EQ)) 2336 Opts.setDLLExportVisibility(parseVisibility(O, Args, Diags)); 2337 else 2338 Opts.setDLLExportVisibility(DefaultVisibility); 2339 2340 // Translate defintions without an explict DLL storage class to hidden 2341 // visibility, by default. 2342 if (Arg *O = Args.getLastArg(OPT_fvisibility_nodllstorageclass_EQ)) 2343 Opts.setNoDLLStorageClassVisibility(parseVisibility(O, Args, Diags)); 2344 else 2345 Opts.setNoDLLStorageClassVisibility(HiddenVisibility); 2346 2347 // Translate dllimport external declarations to default visibility, by 2348 // default. 2349 if (Arg *O = Args.getLastArg(OPT_fvisibility_externs_dllimport_EQ)) 2350 Opts.setExternDeclDLLImportVisibility(parseVisibility(O, Args, Diags)); 2351 else 2352 Opts.setExternDeclDLLImportVisibility(DefaultVisibility); 2353 2354 // Translate external declarations without an explicit DLL storage class 2355 // to hidden visibility, by default. 2356 if (Arg *O = Args.getLastArg(OPT_fvisibility_externs_nodllstorageclass_EQ)) 2357 Opts.setExternDeclNoDLLStorageClassVisibility( 2358 parseVisibility(O, Args, Diags)); 2359 else 2360 Opts.setExternDeclNoDLLStorageClassVisibility(HiddenVisibility); 2361 } 2362 2363 if (Args.hasArg(OPT_ftrapv)) { 2364 Opts.setSignedOverflowBehavior(LangOptions::SOB_Trapping); 2365 // Set the handler, if one is specified. 2366 Opts.OverflowHandler = 2367 std::string(Args.getLastArgValue(OPT_ftrapv_handler)); 2368 } 2369 else if (Args.hasArg(OPT_fwrapv)) 2370 Opts.setSignedOverflowBehavior(LangOptions::SOB_Defined); 2371 2372 Opts.MicrosoftExt = Opts.MSVCCompat || Args.hasArg(OPT_fms_extensions); 2373 Opts.AsmBlocks = Args.hasArg(OPT_fasm_blocks) || Opts.MicrosoftExt; 2374 Opts.MSCompatibilityVersion = 0; 2375 if (const Arg *A = Args.getLastArg(OPT_fms_compatibility_version)) { 2376 VersionTuple VT; 2377 if (VT.tryParse(A->getValue())) 2378 Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) 2379 << A->getValue(); 2380 Opts.MSCompatibilityVersion = VT.getMajor() * 10000000 + 2381 VT.getMinor().getValueOr(0) * 100000 + 2382 VT.getSubminor().getValueOr(0); 2383 } 2384 2385 // Mimicking gcc's behavior, trigraphs are only enabled if -trigraphs 2386 // is specified, or -std is set to a conforming mode. 2387 // Trigraphs are disabled by default in c++1z onwards. 2388 // For z/OS, trigraphs are enabled by default (without regard to the above). 2389 Opts.Trigraphs = 2390 (!Opts.GNUMode && !Opts.MSVCCompat && !Opts.CPlusPlus17) || T.isOSzOS(); 2391 Opts.Trigraphs = 2392 Args.hasFlag(OPT_ftrigraphs, OPT_fno_trigraphs, Opts.Trigraphs); 2393 2394 Opts.DollarIdents = Args.hasFlag(OPT_fdollars_in_identifiers, 2395 OPT_fno_dollars_in_identifiers, 2396 Opts.DollarIdents); 2397 2398 // -ffixed-point 2399 Opts.FixedPoint = 2400 Args.hasFlag(OPT_ffixed_point, OPT_fno_fixed_point, /*Default=*/false) && 2401 !Opts.CPlusPlus; 2402 Opts.PaddingOnUnsignedFixedPoint = 2403 Args.hasFlag(OPT_fpadding_on_unsigned_fixed_point, 2404 OPT_fno_padding_on_unsigned_fixed_point, 2405 /*Default=*/false) && 2406 Opts.FixedPoint; 2407 2408 Opts.RTTI = Opts.CPlusPlus && !Args.hasArg(OPT_fno_rtti); 2409 Opts.RTTIData = Opts.RTTI && !Args.hasArg(OPT_fno_rtti_data); 2410 Opts.Blocks = Args.hasArg(OPT_fblocks) || (Opts.OpenCL 2411 && Opts.OpenCLVersion == 200); 2412 Opts.Coroutines = Opts.CPlusPlus20 || Args.hasArg(OPT_fcoroutines_ts); 2413 2414 Opts.ConvergentFunctions = Opts.OpenCL || (Opts.CUDA && Opts.CUDAIsDevice) || 2415 Opts.SYCLIsDevice || 2416 Args.hasArg(OPT_fconvergent_functions); 2417 2418 Opts.DoubleSquareBracketAttributes = 2419 Args.hasFlag(OPT_fdouble_square_bracket_attributes, 2420 OPT_fno_double_square_bracket_attributes, 2421 Opts.DoubleSquareBracketAttributes); 2422 2423 Opts.CPlusPlusModules = Opts.CPlusPlus20; 2424 Opts.Modules = 2425 Args.hasArg(OPT_fmodules) || Opts.ModulesTS || Opts.CPlusPlusModules; 2426 Opts.ModulesDeclUse = 2427 Args.hasArg(OPT_fmodules_decluse) || Opts.ModulesStrictDeclUse; 2428 // FIXME: We only need this in C++ modules / Modules TS if we might textually 2429 // enter a different module (eg, when building a header unit). 2430 Opts.ModulesLocalVisibility = 2431 Args.hasArg(OPT_fmodules_local_submodule_visibility) || Opts.ModulesTS || 2432 Opts.CPlusPlusModules; 2433 Opts.ModulesSearchAll = Opts.Modules && 2434 !Args.hasArg(OPT_fno_modules_search_all) && 2435 Args.hasArg(OPT_fmodules_search_all); 2436 Opts.CharIsSigned = Opts.OpenCL || !Args.hasArg(OPT_fno_signed_char); 2437 Opts.WChar = Opts.CPlusPlus && !Args.hasArg(OPT_fno_wchar); 2438 Opts.Char8 = Args.hasFlag(OPT_fchar8__t, OPT_fno_char8__t, Opts.CPlusPlus20); 2439 Opts.NoBuiltin = Args.hasArg(OPT_fno_builtin) || Opts.Freestanding; 2440 if (!Opts.NoBuiltin) 2441 getAllNoBuiltinFuncValues(Args, Opts.NoBuiltinFuncs); 2442 Opts.AlignedAllocation = 2443 Args.hasFlag(OPT_faligned_allocation, OPT_fno_aligned_allocation, 2444 Opts.AlignedAllocation); 2445 Opts.AlignedAllocationUnavailable = 2446 Opts.AlignedAllocation && Args.hasArg(OPT_aligned_alloc_unavailable); 2447 if (Args.hasArg(OPT_fconcepts_ts)) 2448 Diags.Report(diag::warn_fe_concepts_ts_flag); 2449 Opts.MathErrno = !Opts.OpenCL && Args.hasArg(OPT_fmath_errno); 2450 Opts.LongDoubleSize = Args.hasArg(OPT_mlong_double_128) 2451 ? 128 2452 : Args.hasArg(OPT_mlong_double_64) ? 64 : 0; 2453 Opts.EnableAIXExtendedAltivecABI = Args.hasArg(OPT_mabi_EQ_vec_extabi); 2454 Opts.PICLevel = getLastArgIntValue(Args, OPT_pic_level, 0, Diags); 2455 Opts.DumpRecordLayouts = Opts.DumpRecordLayoutsSimple 2456 || Args.hasArg(OPT_fdump_record_layouts); 2457 if (Opts.FastRelaxedMath) 2458 Opts.setDefaultFPContractMode(LangOptions::FPM_Fast); 2459 Opts.XLPragmaPack = Args.hasArg(OPT_fxl_pragma_pack); 2460 llvm::sort(Opts.ModuleFeatures); 2461 Opts.NativeHalfType |= Args.hasArg(OPT_fnative_half_type); 2462 Opts.NativeHalfArgsAndReturns |= Args.hasArg(OPT_fnative_half_arguments_and_returns); 2463 // Enable HalfArgsAndReturns if present in Args or if NativeHalfArgsAndReturns 2464 // is enabled. 2465 Opts.HalfArgsAndReturns = Args.hasArg(OPT_fallow_half_arguments_and_returns) 2466 | Opts.NativeHalfArgsAndReturns; 2467 2468 Opts.ArmSveVectorBits = 2469 getLastArgIntValue(Args, options::OPT_msve_vector_bits_EQ, 0, Diags); 2470 2471 // __declspec is enabled by default for the PS4 by the driver, and also 2472 // enabled for Microsoft Extensions or Borland Extensions, here. 2473 // 2474 // FIXME: __declspec is also currently enabled for CUDA, but isn't really a 2475 // CUDA extension. However, it is required for supporting 2476 // __clang_cuda_builtin_vars.h, which uses __declspec(property). Once that has 2477 // been rewritten in terms of something more generic, remove the Opts.CUDA 2478 // term here. 2479 Opts.DeclSpecKeyword = 2480 Args.hasFlag(OPT_fdeclspec, OPT_fno_declspec, 2481 (Opts.MicrosoftExt || Opts.Borland || Opts.CUDA)); 2482 2483 // -mrtd option 2484 if (Arg *A = Args.getLastArg(OPT_mrtd)) { 2485 if (Opts.getDefaultCallingConv() != LangOptions::DCC_None) 2486 Diags.Report(diag::err_drv_argument_not_allowed_with) 2487 << A->getSpelling() << "-fdefault-calling-conv"; 2488 else { 2489 if (T.getArch() != llvm::Triple::x86) 2490 Diags.Report(diag::err_drv_argument_not_allowed_with) 2491 << A->getSpelling() << T.getTriple(); 2492 else 2493 Opts.setDefaultCallingConv(LangOptions::DCC_StdCall); 2494 } 2495 } 2496 2497 // Check if -fopenmp-simd is specified. 2498 bool IsSimdSpecified = 2499 Args.hasFlag(options::OPT_fopenmp_simd, options::OPT_fno_openmp_simd, 2500 /*Default=*/false); 2501 Opts.OpenMPSimd = !Opts.OpenMP && IsSimdSpecified; 2502 Opts.OpenMPUseTLS = 2503 Opts.OpenMP && !Args.hasArg(options::OPT_fnoopenmp_use_tls); 2504 Opts.OpenMPIsDevice = 2505 Opts.OpenMP && Args.hasArg(options::OPT_fopenmp_is_device); 2506 Opts.OpenMPIRBuilder = 2507 Opts.OpenMP && Args.hasArg(options::OPT_fopenmp_enable_irbuilder); 2508 bool IsTargetSpecified = 2509 Opts.OpenMPIsDevice || Args.hasArg(options::OPT_fopenmp_targets_EQ); 2510 2511 if (Opts.OpenMP || Opts.OpenMPSimd) { 2512 if (int Version = getLastArgIntValue( 2513 Args, OPT_fopenmp_version_EQ, 2514 (IsSimdSpecified || IsTargetSpecified) ? 50 : Opts.OpenMP, Diags)) 2515 Opts.OpenMP = Version; 2516 // Provide diagnostic when a given target is not expected to be an OpenMP 2517 // device or host. 2518 if (!Opts.OpenMPIsDevice) { 2519 switch (T.getArch()) { 2520 default: 2521 break; 2522 // Add unsupported host targets here: 2523 case llvm::Triple::nvptx: 2524 case llvm::Triple::nvptx64: 2525 Diags.Report(diag::err_drv_omp_host_target_not_supported) << T.str(); 2526 break; 2527 } 2528 } 2529 } 2530 2531 // Set the flag to prevent the implementation from emitting device exception 2532 // handling code for those requiring so. 2533 if ((Opts.OpenMPIsDevice && (T.isNVPTX() || T.isAMDGCN())) || 2534 Opts.OpenCLCPlusPlus) { 2535 Opts.Exceptions = 0; 2536 Opts.CXXExceptions = 0; 2537 } 2538 if (Opts.OpenMPIsDevice && T.isNVPTX()) { 2539 Opts.OpenMPCUDANumSMs = 2540 getLastArgIntValue(Args, options::OPT_fopenmp_cuda_number_of_sm_EQ, 2541 Opts.OpenMPCUDANumSMs, Diags); 2542 Opts.OpenMPCUDABlocksPerSM = 2543 getLastArgIntValue(Args, options::OPT_fopenmp_cuda_blocks_per_sm_EQ, 2544 Opts.OpenMPCUDABlocksPerSM, Diags); 2545 Opts.OpenMPCUDAReductionBufNum = getLastArgIntValue( 2546 Args, options::OPT_fopenmp_cuda_teams_reduction_recs_num_EQ, 2547 Opts.OpenMPCUDAReductionBufNum, Diags); 2548 } 2549 2550 // Get the OpenMP target triples if any. 2551 if (Arg *A = Args.getLastArg(options::OPT_fopenmp_targets_EQ)) { 2552 enum ArchPtrSize { Arch16Bit, Arch32Bit, Arch64Bit }; 2553 auto getArchPtrSize = [](const llvm::Triple &T) { 2554 if (T.isArch16Bit()) 2555 return Arch16Bit; 2556 if (T.isArch32Bit()) 2557 return Arch32Bit; 2558 assert(T.isArch64Bit() && "Expected 64-bit architecture"); 2559 return Arch64Bit; 2560 }; 2561 2562 for (unsigned i = 0; i < A->getNumValues(); ++i) { 2563 llvm::Triple TT(A->getValue(i)); 2564 2565 if (TT.getArch() == llvm::Triple::UnknownArch || 2566 !(TT.getArch() == llvm::Triple::aarch64 || TT.isPPC() || 2567 TT.getArch() == llvm::Triple::nvptx || 2568 TT.getArch() == llvm::Triple::nvptx64 || 2569 TT.getArch() == llvm::Triple::amdgcn || 2570 TT.getArch() == llvm::Triple::x86 || 2571 TT.getArch() == llvm::Triple::x86_64)) 2572 Diags.Report(diag::err_drv_invalid_omp_target) << A->getValue(i); 2573 else if (getArchPtrSize(T) != getArchPtrSize(TT)) 2574 Diags.Report(diag::err_drv_incompatible_omp_arch) 2575 << A->getValue(i) << T.str(); 2576 else 2577 Opts.OMPTargetTriples.push_back(TT); 2578 } 2579 } 2580 2581 // Get OpenMP host file path if any and report if a non existent file is 2582 // found 2583 if (Arg *A = Args.getLastArg(options::OPT_fopenmp_host_ir_file_path)) { 2584 Opts.OMPHostIRFile = A->getValue(); 2585 if (!llvm::sys::fs::exists(Opts.OMPHostIRFile)) 2586 Diags.Report(diag::err_drv_omp_host_ir_file_not_found) 2587 << Opts.OMPHostIRFile; 2588 } 2589 2590 // Set CUDA mode for OpenMP target NVPTX/AMDGCN if specified in options 2591 Opts.OpenMPCUDAMode = Opts.OpenMPIsDevice && (T.isNVPTX() || T.isAMDGCN()) && 2592 Args.hasArg(options::OPT_fopenmp_cuda_mode); 2593 2594 // Set CUDA support for parallel execution of target regions for OpenMP target 2595 // NVPTX/AMDGCN if specified in options. 2596 Opts.OpenMPCUDATargetParallel = 2597 Opts.OpenMPIsDevice && (T.isNVPTX() || T.isAMDGCN()) && 2598 Args.hasArg(options::OPT_fopenmp_cuda_parallel_target_regions); 2599 2600 // Set CUDA mode for OpenMP target NVPTX/AMDGCN if specified in options 2601 Opts.OpenMPCUDAForceFullRuntime = 2602 Opts.OpenMPIsDevice && (T.isNVPTX() || T.isAMDGCN()) && 2603 Args.hasArg(options::OPT_fopenmp_cuda_force_full_runtime); 2604 2605 // Record whether the __DEPRECATED define was requested. 2606 Opts.Deprecated = Args.hasFlag(OPT_fdeprecated_macro, 2607 OPT_fno_deprecated_macro, 2608 Opts.Deprecated); 2609 2610 // FIXME: Eliminate this dependency. 2611 unsigned Opt = getOptimizationLevel(Args, IK, Diags), 2612 OptSize = getOptimizationLevelSize(Args); 2613 Opts.Optimize = Opt != 0; 2614 Opts.OptimizeSize = OptSize != 0; 2615 2616 // This is the __NO_INLINE__ define, which just depends on things like the 2617 // optimization level and -fno-inline, not actually whether the backend has 2618 // inlining enabled. 2619 Opts.NoInlineDefine = !Opts.Optimize; 2620 if (Arg *InlineArg = Args.getLastArg( 2621 options::OPT_finline_functions, options::OPT_finline_hint_functions, 2622 options::OPT_fno_inline_functions, options::OPT_fno_inline)) 2623 if (InlineArg->getOption().matches(options::OPT_fno_inline)) 2624 Opts.NoInlineDefine = true; 2625 2626 if (Arg *A = Args.getLastArg(OPT_ffp_contract)) { 2627 StringRef Val = A->getValue(); 2628 if (Val == "fast") 2629 Opts.setDefaultFPContractMode(LangOptions::FPM_Fast); 2630 else if (Val == "on") 2631 Opts.setDefaultFPContractMode(LangOptions::FPM_On); 2632 else if (Val == "off") 2633 Opts.setDefaultFPContractMode(LangOptions::FPM_Off); 2634 else if (Val == "fast-honor-pragmas") 2635 Opts.setDefaultFPContractMode(LangOptions::FPM_FastHonorPragmas); 2636 else 2637 Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Val; 2638 } 2639 2640 LangOptions::FPExceptionModeKind FPEB = LangOptions::FPE_Ignore; 2641 if (Arg *A = Args.getLastArg(OPT_ffp_exception_behavior_EQ)) { 2642 StringRef Val = A->getValue(); 2643 if (Val.equals("ignore")) 2644 FPEB = LangOptions::FPE_Ignore; 2645 else if (Val.equals("maytrap")) 2646 FPEB = LangOptions::FPE_MayTrap; 2647 else if (Val.equals("strict")) 2648 FPEB = LangOptions::FPE_Strict; 2649 else 2650 Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Val; 2651 } 2652 Opts.setFPExceptionMode(FPEB); 2653 2654 // Parse -fsanitize= arguments. 2655 parseSanitizerKinds("-fsanitize=", Args.getAllArgValues(OPT_fsanitize_EQ), 2656 Diags, Opts.Sanitize); 2657 std::vector<std::string> systemBlacklists = 2658 Args.getAllArgValues(OPT_fsanitize_system_blacklist); 2659 Opts.SanitizerBlacklistFiles.insert(Opts.SanitizerBlacklistFiles.end(), 2660 systemBlacklists.begin(), 2661 systemBlacklists.end()); 2662 2663 if (Arg *A = Args.getLastArg(OPT_fclang_abi_compat_EQ)) { 2664 Opts.setClangABICompat(LangOptions::ClangABI::Latest); 2665 2666 StringRef Ver = A->getValue(); 2667 std::pair<StringRef, StringRef> VerParts = Ver.split('.'); 2668 unsigned Major, Minor = 0; 2669 2670 // Check the version number is valid: either 3.x (0 <= x <= 9) or 2671 // y or y.0 (4 <= y <= current version). 2672 if (!VerParts.first.startswith("0") && 2673 !VerParts.first.getAsInteger(10, Major) && 2674 3 <= Major && Major <= CLANG_VERSION_MAJOR && 2675 (Major == 3 ? VerParts.second.size() == 1 && 2676 !VerParts.second.getAsInteger(10, Minor) 2677 : VerParts.first.size() == Ver.size() || 2678 VerParts.second == "0")) { 2679 // Got a valid version number. 2680 if (Major == 3 && Minor <= 8) 2681 Opts.setClangABICompat(LangOptions::ClangABI::Ver3_8); 2682 else if (Major <= 4) 2683 Opts.setClangABICompat(LangOptions::ClangABI::Ver4); 2684 else if (Major <= 6) 2685 Opts.setClangABICompat(LangOptions::ClangABI::Ver6); 2686 else if (Major <= 7) 2687 Opts.setClangABICompat(LangOptions::ClangABI::Ver7); 2688 else if (Major <= 9) 2689 Opts.setClangABICompat(LangOptions::ClangABI::Ver9); 2690 else if (Major <= 11) 2691 Opts.setClangABICompat(LangOptions::ClangABI::Ver11); 2692 } else if (Ver != "latest") { 2693 Diags.Report(diag::err_drv_invalid_value) 2694 << A->getAsString(Args) << A->getValue(); 2695 } 2696 } 2697 2698 if (Arg *A = Args.getLastArg(OPT_msign_return_address_EQ)) { 2699 StringRef SignScope = A->getValue(); 2700 2701 if (SignScope.equals_lower("none")) 2702 Opts.setSignReturnAddressScope( 2703 LangOptions::SignReturnAddressScopeKind::None); 2704 else if (SignScope.equals_lower("all")) 2705 Opts.setSignReturnAddressScope( 2706 LangOptions::SignReturnAddressScopeKind::All); 2707 else if (SignScope.equals_lower("non-leaf")) 2708 Opts.setSignReturnAddressScope( 2709 LangOptions::SignReturnAddressScopeKind::NonLeaf); 2710 else 2711 Diags.Report(diag::err_drv_invalid_value) 2712 << A->getAsString(Args) << SignScope; 2713 2714 if (Arg *A = Args.getLastArg(OPT_msign_return_address_key_EQ)) { 2715 StringRef SignKey = A->getValue(); 2716 if (!SignScope.empty() && !SignKey.empty()) { 2717 if (SignKey.equals_lower("a_key")) 2718 Opts.setSignReturnAddressKey( 2719 LangOptions::SignReturnAddressKeyKind::AKey); 2720 else if (SignKey.equals_lower("b_key")) 2721 Opts.setSignReturnAddressKey( 2722 LangOptions::SignReturnAddressKeyKind::BKey); 2723 else 2724 Diags.Report(diag::err_drv_invalid_value) 2725 << A->getAsString(Args) << SignKey; 2726 } 2727 } 2728 } 2729 2730 std::string ThreadModel = 2731 std::string(Args.getLastArgValue(OPT_mthread_model, "posix")); 2732 if (ThreadModel != "posix" && ThreadModel != "single") 2733 Diags.Report(diag::err_drv_invalid_value) 2734 << Args.getLastArg(OPT_mthread_model)->getAsString(Args) << ThreadModel; 2735 Opts.setThreadModel( 2736 llvm::StringSwitch<LangOptions::ThreadModelKind>(ThreadModel) 2737 .Case("posix", LangOptions::ThreadModelKind::POSIX) 2738 .Case("single", LangOptions::ThreadModelKind::Single)); 2739 } 2740 2741 static bool isStrictlyPreprocessorAction(frontend::ActionKind Action) { 2742 switch (Action) { 2743 case frontend::ASTDeclList: 2744 case frontend::ASTDump: 2745 case frontend::ASTPrint: 2746 case frontend::ASTView: 2747 case frontend::EmitAssembly: 2748 case frontend::EmitBC: 2749 case frontend::EmitHTML: 2750 case frontend::EmitLLVM: 2751 case frontend::EmitLLVMOnly: 2752 case frontend::EmitCodeGenOnly: 2753 case frontend::EmitObj: 2754 case frontend::FixIt: 2755 case frontend::GenerateModule: 2756 case frontend::GenerateModuleInterface: 2757 case frontend::GenerateHeaderModule: 2758 case frontend::GeneratePCH: 2759 case frontend::GenerateInterfaceStubs: 2760 case frontend::ParseSyntaxOnly: 2761 case frontend::ModuleFileInfo: 2762 case frontend::VerifyPCH: 2763 case frontend::PluginAction: 2764 case frontend::RewriteObjC: 2765 case frontend::RewriteTest: 2766 case frontend::RunAnalysis: 2767 case frontend::TemplightDump: 2768 case frontend::MigrateSource: 2769 return false; 2770 2771 case frontend::DumpCompilerOptions: 2772 case frontend::DumpRawTokens: 2773 case frontend::DumpTokens: 2774 case frontend::InitOnly: 2775 case frontend::PrintPreamble: 2776 case frontend::PrintPreprocessedInput: 2777 case frontend::RewriteMacros: 2778 case frontend::RunPreprocessorOnly: 2779 case frontend::PrintDependencyDirectivesSourceMinimizerOutput: 2780 return true; 2781 } 2782 llvm_unreachable("invalid frontend action"); 2783 } 2784 2785 static void ParsePreprocessorArgs(PreprocessorOptions &Opts, ArgList &Args, 2786 DiagnosticsEngine &Diags, 2787 frontend::ActionKind Action) { 2788 Opts.PCHWithHdrStop = Args.hasArg(OPT_pch_through_hdrstop_create) || 2789 Args.hasArg(OPT_pch_through_hdrstop_use); 2790 Opts.AllowPCHWithCompilerErrors = 2791 Args.hasArg(OPT_fallow_pch_with_errors, OPT_fallow_pcm_with_errors); 2792 2793 for (const auto *A : Args.filtered(OPT_error_on_deserialized_pch_decl)) 2794 Opts.DeserializedPCHDeclsToErrorOn.insert(A->getValue()); 2795 2796 for (const auto &A : Args.getAllArgValues(OPT_fmacro_prefix_map_EQ)) { 2797 auto Split = StringRef(A).split('='); 2798 Opts.MacroPrefixMap.insert( 2799 {std::string(Split.first), std::string(Split.second)}); 2800 } 2801 2802 if (const Arg *A = Args.getLastArg(OPT_preamble_bytes_EQ)) { 2803 StringRef Value(A->getValue()); 2804 size_t Comma = Value.find(','); 2805 unsigned Bytes = 0; 2806 unsigned EndOfLine = 0; 2807 2808 if (Comma == StringRef::npos || 2809 Value.substr(0, Comma).getAsInteger(10, Bytes) || 2810 Value.substr(Comma + 1).getAsInteger(10, EndOfLine)) 2811 Diags.Report(diag::err_drv_preamble_format); 2812 else { 2813 Opts.PrecompiledPreambleBytes.first = Bytes; 2814 Opts.PrecompiledPreambleBytes.second = (EndOfLine != 0); 2815 } 2816 } 2817 2818 // Add the __CET__ macro if a CFProtection option is set. 2819 if (const Arg *A = Args.getLastArg(OPT_fcf_protection_EQ)) { 2820 StringRef Name = A->getValue(); 2821 if (Name == "branch") 2822 Opts.addMacroDef("__CET__=1"); 2823 else if (Name == "return") 2824 Opts.addMacroDef("__CET__=2"); 2825 else if (Name == "full") 2826 Opts.addMacroDef("__CET__=3"); 2827 } 2828 2829 // Add macros from the command line. 2830 for (const auto *A : Args.filtered(OPT_D, OPT_U)) { 2831 if (A->getOption().matches(OPT_D)) 2832 Opts.addMacroDef(A->getValue()); 2833 else 2834 Opts.addMacroUndef(A->getValue()); 2835 } 2836 2837 // Add the ordered list of -includes. 2838 for (const auto *A : Args.filtered(OPT_include)) 2839 Opts.Includes.emplace_back(A->getValue()); 2840 2841 for (const auto *A : Args.filtered(OPT_chain_include)) 2842 Opts.ChainedIncludes.emplace_back(A->getValue()); 2843 2844 for (const auto *A : Args.filtered(OPT_remap_file)) { 2845 std::pair<StringRef, StringRef> Split = StringRef(A->getValue()).split(';'); 2846 2847 if (Split.second.empty()) { 2848 Diags.Report(diag::err_drv_invalid_remap_file) << A->getAsString(Args); 2849 continue; 2850 } 2851 2852 Opts.addRemappedFile(Split.first, Split.second); 2853 } 2854 2855 // Always avoid lexing editor placeholders when we're just running the 2856 // preprocessor as we never want to emit the 2857 // "editor placeholder in source file" error in PP only mode. 2858 if (isStrictlyPreprocessorAction(Action)) 2859 Opts.LexEditorPlaceholders = false; 2860 } 2861 2862 static void ParsePreprocessorOutputArgs(PreprocessorOutputOptions &Opts, 2863 ArgList &Args, 2864 frontend::ActionKind Action) { 2865 if (isStrictlyPreprocessorAction(Action)) 2866 Opts.ShowCPP = !Args.hasArg(OPT_dM); 2867 else 2868 Opts.ShowCPP = 0; 2869 2870 Opts.ShowMacros = Args.hasArg(OPT_dM) || Args.hasArg(OPT_dD); 2871 } 2872 2873 static void ParseTargetArgs(TargetOptions &Opts, ArgList &Args, 2874 DiagnosticsEngine &Diags) { 2875 Opts.AllowAMDGPUUnsafeFPAtomics = 2876 Args.hasFlag(options::OPT_munsafe_fp_atomics, 2877 options::OPT_mno_unsafe_fp_atomics, false); 2878 if (Arg *A = Args.getLastArg(options::OPT_target_sdk_version_EQ)) { 2879 llvm::VersionTuple Version; 2880 if (Version.tryParse(A->getValue())) 2881 Diags.Report(diag::err_drv_invalid_value) 2882 << A->getAsString(Args) << A->getValue(); 2883 else 2884 Opts.SDKVersion = Version; 2885 } 2886 } 2887 2888 bool CompilerInvocation::CreateFromArgs(CompilerInvocation &Res, 2889 ArrayRef<const char *> CommandLineArgs, 2890 DiagnosticsEngine &Diags, 2891 const char *Argv0) { 2892 bool Success = true; 2893 2894 // Parse the arguments. 2895 const OptTable &Opts = getDriverOptTable(); 2896 const unsigned IncludedFlagsBitmask = options::CC1Option; 2897 unsigned MissingArgIndex, MissingArgCount; 2898 InputArgList Args = Opts.ParseArgs(CommandLineArgs, MissingArgIndex, 2899 MissingArgCount, IncludedFlagsBitmask); 2900 LangOptions &LangOpts = *Res.getLangOpts(); 2901 2902 // Check for missing argument error. 2903 if (MissingArgCount) { 2904 Diags.Report(diag::err_drv_missing_argument) 2905 << Args.getArgString(MissingArgIndex) << MissingArgCount; 2906 Success = false; 2907 } 2908 2909 // Issue errors on unknown arguments. 2910 for (const auto *A : Args.filtered(OPT_UNKNOWN)) { 2911 auto ArgString = A->getAsString(Args); 2912 std::string Nearest; 2913 if (Opts.findNearest(ArgString, Nearest, IncludedFlagsBitmask) > 1) 2914 Diags.Report(diag::err_drv_unknown_argument) << ArgString; 2915 else 2916 Diags.Report(diag::err_drv_unknown_argument_with_suggestion) 2917 << ArgString << Nearest; 2918 Success = false; 2919 } 2920 2921 Success &= Res.parseSimpleArgs(Args, Diags); 2922 2923 Success &= ParseAnalyzerArgs(*Res.getAnalyzerOpts(), Args, Diags); 2924 ParseDependencyOutputArgs(Res.getDependencyOutputOpts(), Args); 2925 if (!Res.getDependencyOutputOpts().OutputFile.empty() && 2926 Res.getDependencyOutputOpts().Targets.empty()) { 2927 Diags.Report(diag::err_fe_dependency_file_requires_MT); 2928 Success = false; 2929 } 2930 Success &= ParseDiagnosticArgs(Res.getDiagnosticOpts(), Args, &Diags, 2931 /*DefaultDiagColor=*/false); 2932 ParseCommentArgs(LangOpts.CommentOpts, Args); 2933 // FIXME: We shouldn't have to pass the DashX option around here 2934 InputKind DashX = ParseFrontendArgs(Res.getFrontendOpts(), Args, Diags, 2935 LangOpts.IsHeaderFile); 2936 ParseTargetArgs(Res.getTargetOpts(), Args, Diags); 2937 llvm::Triple T(Res.getTargetOpts().Triple); 2938 Success &= ParseCodeGenArgs(Res.getCodeGenOpts(), Args, DashX, Diags, T, 2939 Res.getFrontendOpts().OutputFile); 2940 ParseHeaderSearchArgs(Res.getHeaderSearchOpts(), Args, 2941 Res.getFileSystemOpts().WorkingDir); 2942 if (DashX.getFormat() == InputKind::Precompiled || 2943 DashX.getLanguage() == Language::LLVM_IR) { 2944 // ObjCAAutoRefCount and Sanitize LangOpts are used to setup the 2945 // PassManager in BackendUtil.cpp. They need to be initializd no matter 2946 // what the input type is. 2947 if (Args.hasArg(OPT_fobjc_arc)) 2948 LangOpts.ObjCAutoRefCount = 1; 2949 // PIClevel and PIELevel are needed during code generation and this should be 2950 // set regardless of the input type. 2951 LangOpts.PICLevel = getLastArgIntValue(Args, OPT_pic_level, 0, Diags); 2952 parseSanitizerKinds("-fsanitize=", Args.getAllArgValues(OPT_fsanitize_EQ), 2953 Diags, LangOpts.Sanitize); 2954 } else { 2955 // Other LangOpts are only initialized when the input is not AST or LLVM IR. 2956 // FIXME: Should we really be calling this for an Language::Asm input? 2957 ParseLangArgs(LangOpts, Args, DashX, T, Res.getPreprocessorOpts().Includes, 2958 Diags); 2959 if (Res.getFrontendOpts().ProgramAction == frontend::RewriteObjC) 2960 LangOpts.ObjCExceptions = 1; 2961 if (T.isOSDarwin() && DashX.isPreprocessed()) { 2962 // Supress the darwin-specific 'stdlibcxx-not-found' diagnostic for 2963 // preprocessed input as we don't expect it to be used with -std=libc++ 2964 // anyway. 2965 Res.getDiagnosticOpts().Warnings.push_back("no-stdlibcxx-not-found"); 2966 } 2967 } 2968 2969 if (LangOpts.CUDA) { 2970 // During CUDA device-side compilation, the aux triple is the 2971 // triple used for host compilation. 2972 if (LangOpts.CUDAIsDevice) 2973 Res.getTargetOpts().HostTriple = Res.getFrontendOpts().AuxTriple; 2974 } 2975 2976 // Set the triple of the host for OpenMP device compile. 2977 if (LangOpts.OpenMPIsDevice) 2978 Res.getTargetOpts().HostTriple = Res.getFrontendOpts().AuxTriple; 2979 2980 // FIXME: Override value name discarding when asan or msan is used because the 2981 // backend passes depend on the name of the alloca in order to print out 2982 // names. 2983 Res.getCodeGenOpts().DiscardValueNames &= 2984 !LangOpts.Sanitize.has(SanitizerKind::Address) && 2985 !LangOpts.Sanitize.has(SanitizerKind::KernelAddress) && 2986 !LangOpts.Sanitize.has(SanitizerKind::Memory) && 2987 !LangOpts.Sanitize.has(SanitizerKind::KernelMemory); 2988 2989 ParsePreprocessorArgs(Res.getPreprocessorOpts(), Args, Diags, 2990 Res.getFrontendOpts().ProgramAction); 2991 ParsePreprocessorOutputArgs(Res.getPreprocessorOutputOpts(), Args, 2992 Res.getFrontendOpts().ProgramAction); 2993 2994 // Turn on -Wspir-compat for SPIR target. 2995 if (T.isSPIR()) 2996 Res.getDiagnosticOpts().Warnings.push_back("spir-compat"); 2997 2998 // If sanitizer is enabled, disable OPT_ffine_grained_bitfield_accesses. 2999 if (Res.getCodeGenOpts().FineGrainedBitfieldAccesses && 3000 !Res.getLangOpts()->Sanitize.empty()) { 3001 Res.getCodeGenOpts().FineGrainedBitfieldAccesses = false; 3002 Diags.Report(diag::warn_drv_fine_grained_bitfield_accesses_ignored); 3003 } 3004 3005 // Store the command-line for using in the CodeView backend. 3006 Res.getCodeGenOpts().Argv0 = Argv0; 3007 Res.getCodeGenOpts().CommandLineArgs = CommandLineArgs; 3008 3009 FixupInvocation(Res, Diags, Args); 3010 3011 return Success; 3012 } 3013 3014 std::string CompilerInvocation::getModuleHash() const { 3015 // Note: For QoI reasons, the things we use as a hash here should all be 3016 // dumped via the -module-info flag. 3017 using llvm::hash_code; 3018 using llvm::hash_value; 3019 using llvm::hash_combine; 3020 using llvm::hash_combine_range; 3021 3022 // Start the signature with the compiler version. 3023 // FIXME: We'd rather use something more cryptographically sound than 3024 // CityHash, but this will do for now. 3025 hash_code code = hash_value(getClangFullRepositoryVersion()); 3026 3027 // Also include the serialization version, in case LLVM_APPEND_VC_REV is off 3028 // and getClangFullRepositoryVersion() doesn't include git revision. 3029 code = hash_combine(code, serialization::VERSION_MAJOR, 3030 serialization::VERSION_MINOR); 3031 3032 // Extend the signature with the language options 3033 #define LANGOPT(Name, Bits, Default, Description) \ 3034 code = hash_combine(code, LangOpts->Name); 3035 #define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \ 3036 code = hash_combine(code, static_cast<unsigned>(LangOpts->get##Name())); 3037 #define BENIGN_LANGOPT(Name, Bits, Default, Description) 3038 #define BENIGN_ENUM_LANGOPT(Name, Type, Bits, Default, Description) 3039 #include "clang/Basic/LangOptions.def" 3040 3041 for (StringRef Feature : LangOpts->ModuleFeatures) 3042 code = hash_combine(code, Feature); 3043 3044 code = hash_combine(code, LangOpts->ObjCRuntime); 3045 const auto &BCN = LangOpts->CommentOpts.BlockCommandNames; 3046 code = hash_combine(code, hash_combine_range(BCN.begin(), BCN.end())); 3047 3048 // Extend the signature with the target options. 3049 code = hash_combine(code, TargetOpts->Triple, TargetOpts->CPU, 3050 TargetOpts->TuneCPU, TargetOpts->ABI); 3051 for (const auto &FeatureAsWritten : TargetOpts->FeaturesAsWritten) 3052 code = hash_combine(code, FeatureAsWritten); 3053 3054 // Extend the signature with preprocessor options. 3055 const PreprocessorOptions &ppOpts = getPreprocessorOpts(); 3056 const HeaderSearchOptions &hsOpts = getHeaderSearchOpts(); 3057 code = hash_combine(code, ppOpts.UsePredefines, ppOpts.DetailedRecord); 3058 3059 for (const auto &I : getPreprocessorOpts().Macros) { 3060 // If we're supposed to ignore this macro for the purposes of modules, 3061 // don't put it into the hash. 3062 if (!hsOpts.ModulesIgnoreMacros.empty()) { 3063 // Check whether we're ignoring this macro. 3064 StringRef MacroDef = I.first; 3065 if (hsOpts.ModulesIgnoreMacros.count( 3066 llvm::CachedHashString(MacroDef.split('=').first))) 3067 continue; 3068 } 3069 3070 code = hash_combine(code, I.first, I.second); 3071 } 3072 3073 // Extend the signature with the sysroot and other header search options. 3074 code = hash_combine(code, hsOpts.Sysroot, 3075 hsOpts.ModuleFormat, 3076 hsOpts.UseDebugInfo, 3077 hsOpts.UseBuiltinIncludes, 3078 hsOpts.UseStandardSystemIncludes, 3079 hsOpts.UseStandardCXXIncludes, 3080 hsOpts.UseLibcxx, 3081 hsOpts.ModulesValidateDiagnosticOptions); 3082 code = hash_combine(code, hsOpts.ResourceDir); 3083 3084 if (hsOpts.ModulesStrictContextHash) { 3085 hash_code SHPC = hash_combine_range(hsOpts.SystemHeaderPrefixes.begin(), 3086 hsOpts.SystemHeaderPrefixes.end()); 3087 hash_code UEC = hash_combine_range(hsOpts.UserEntries.begin(), 3088 hsOpts.UserEntries.end()); 3089 code = hash_combine(code, hsOpts.SystemHeaderPrefixes.size(), SHPC, 3090 hsOpts.UserEntries.size(), UEC); 3091 3092 const DiagnosticOptions &diagOpts = getDiagnosticOpts(); 3093 #define DIAGOPT(Name, Bits, Default) \ 3094 code = hash_combine(code, diagOpts.Name); 3095 #define ENUM_DIAGOPT(Name, Type, Bits, Default) \ 3096 code = hash_combine(code, diagOpts.get##Name()); 3097 #include "clang/Basic/DiagnosticOptions.def" 3098 #undef DIAGOPT 3099 #undef ENUM_DIAGOPT 3100 } 3101 3102 // Extend the signature with the user build path. 3103 code = hash_combine(code, hsOpts.ModuleUserBuildPath); 3104 3105 // Extend the signature with the module file extensions. 3106 const FrontendOptions &frontendOpts = getFrontendOpts(); 3107 for (const auto &ext : frontendOpts.ModuleFileExtensions) { 3108 code = ext->hashExtension(code); 3109 } 3110 3111 // When compiling with -gmodules, also hash -fdebug-prefix-map as it 3112 // affects the debug info in the PCM. 3113 if (getCodeGenOpts().DebugTypeExtRefs) 3114 for (const auto &KeyValue : getCodeGenOpts().DebugPrefixMap) 3115 code = hash_combine(code, KeyValue.first, KeyValue.second); 3116 3117 // Extend the signature with the enabled sanitizers, if at least one is 3118 // enabled. Sanitizers which cannot affect AST generation aren't hashed. 3119 SanitizerSet SanHash = LangOpts->Sanitize; 3120 SanHash.clear(getPPTransparentSanitizers()); 3121 if (!SanHash.empty()) 3122 code = hash_combine(code, SanHash.Mask); 3123 3124 return llvm::APInt(64, code).toString(36, /*Signed=*/false); 3125 } 3126 3127 void CompilerInvocation::generateCC1CommandLine( 3128 SmallVectorImpl<const char *> &Args, StringAllocator SA) const { 3129 // Capture the extracted value as a lambda argument to avoid potential issues 3130 // with lifetime extension of the reference. 3131 #define GENERATE_OPTION_WITH_MARSHALLING( \ 3132 ARGS, STRING_ALLOCATOR, KIND, FLAGS, SPELLING, ALWAYS_EMIT, KEYPATH, \ 3133 DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, DENORMALIZER, EXTRACTOR, \ 3134 TABLE_INDEX) \ 3135 if ((FLAGS)&options::CC1Option) { \ 3136 [&](const auto &Extracted) { \ 3137 if (ALWAYS_EMIT || \ 3138 (Extracted != \ 3139 static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? (IMPLIED_VALUE) \ 3140 : (DEFAULT_VALUE)))) \ 3141 DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class, \ 3142 TABLE_INDEX, Extracted); \ 3143 }(EXTRACTOR(KEYPATH)); \ 3144 } 3145 3146 #define OPTION_WITH_MARSHALLING( \ 3147 PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM, \ 3148 HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH, \ 3149 DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER, \ 3150 MERGER, EXTRACTOR, TABLE_INDEX) \ 3151 GENERATE_OPTION_WITH_MARSHALLING(Args, SA, KIND, FLAGS, SPELLING, \ 3152 ALWAYS_EMIT, this->KEYPATH, DEFAULT_VALUE, \ 3153 IMPLIED_CHECK, IMPLIED_VALUE, DENORMALIZER, \ 3154 EXTRACTOR, TABLE_INDEX) 3155 3156 #define DIAG_OPTION_WITH_MARSHALLING( \ 3157 PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM, \ 3158 HELPTEXT, METAVAR, VALUES, SPELLING, SHOULD_PARSE, ALWAYS_EMIT, KEYPATH, \ 3159 DEFAULT_VALUE, IMPLIED_CHECK, IMPLIED_VALUE, NORMALIZER, DENORMALIZER, \ 3160 MERGER, EXTRACTOR, TABLE_INDEX) \ 3161 GENERATE_OPTION_WITH_MARSHALLING( \ 3162 Args, SA, KIND, FLAGS, SPELLING, ALWAYS_EMIT, \ 3163 this->DiagnosticOpts->KEYPATH, DEFAULT_VALUE, IMPLIED_CHECK, \ 3164 IMPLIED_VALUE, DENORMALIZER, EXTRACTOR, TABLE_INDEX) 3165 3166 #include "clang/Driver/Options.inc" 3167 3168 #undef DIAG_OPTION_WITH_MARSHALLING 3169 #undef OPTION_WITH_MARSHALLING 3170 #undef GENERATE_OPTION_WITH_MARSHALLING 3171 } 3172 3173 IntrusiveRefCntPtr<llvm::vfs::FileSystem> 3174 clang::createVFSFromCompilerInvocation(const CompilerInvocation &CI, 3175 DiagnosticsEngine &Diags) { 3176 return createVFSFromCompilerInvocation(CI, Diags, 3177 llvm::vfs::getRealFileSystem()); 3178 } 3179 3180 IntrusiveRefCntPtr<llvm::vfs::FileSystem> 3181 clang::createVFSFromCompilerInvocation( 3182 const CompilerInvocation &CI, DiagnosticsEngine &Diags, 3183 IntrusiveRefCntPtr<llvm::vfs::FileSystem> BaseFS) { 3184 if (CI.getHeaderSearchOpts().VFSOverlayFiles.empty()) 3185 return BaseFS; 3186 3187 IntrusiveRefCntPtr<llvm::vfs::FileSystem> Result = BaseFS; 3188 // earlier vfs files are on the bottom 3189 for (const auto &File : CI.getHeaderSearchOpts().VFSOverlayFiles) { 3190 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> Buffer = 3191 Result->getBufferForFile(File); 3192 if (!Buffer) { 3193 Diags.Report(diag::err_missing_vfs_overlay_file) << File; 3194 continue; 3195 } 3196 3197 IntrusiveRefCntPtr<llvm::vfs::FileSystem> FS = llvm::vfs::getVFSFromYAML( 3198 std::move(Buffer.get()), /*DiagHandler*/ nullptr, File, 3199 /*DiagContext*/ nullptr, Result); 3200 if (!FS) { 3201 Diags.Report(diag::err_invalid_vfs_overlay) << File; 3202 continue; 3203 } 3204 3205 Result = FS; 3206 } 3207 return Result; 3208 } 3209