29#include "clang/Config/config.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/STLExtras.h"
54#include "llvm/ADT/SmallString.h"
55#include "llvm/ADT/SmallVector.h"
56#include "llvm/ADT/StringRef.h"
57#include "llvm/ADT/StringSwitch.h"
58#include "llvm/ADT/Twine.h"
59#include "llvm/Config/llvm-config.h"
60#include "llvm/Frontend/Debug/Options.h"
61#include "llvm/IR/DebugInfoMetadata.h"
62#include "llvm/Linker/Linker.h"
63#include "llvm/MC/MCTargetOptions.h"
64#include "llvm/Option/Arg.h"
65#include "llvm/Option/ArgList.h"
66#include "llvm/Option/OptSpecifier.h"
67#include "llvm/Option/OptTable.h"
68#include "llvm/Option/Option.h"
69#include "llvm/ProfileData/InstrProfReader.h"
70#include "llvm/Remarks/HotnessThresholdParser.h"
71#include "llvm/Support/CodeGen.h"
72#include "llvm/Support/Compiler.h"
73#include "llvm/Support/Error.h"
74#include "llvm/Support/ErrorHandling.h"
75#include "llvm/Support/ErrorOr.h"
76#include "llvm/Support/FileSystem.h"
77#include "llvm/Support/HashBuilder.h"
78#include "llvm/Support/MathExtras.h"
79#include "llvm/Support/MemoryBuffer.h"
80#include "llvm/Support/Path.h"
81#include "llvm/Support/Process.h"
82#include "llvm/Support/Regex.h"
83#include "llvm/Support/VersionTuple.h"
84#include "llvm/Support/VirtualFileSystem.h"
85#include "llvm/Support/raw_ostream.h"
86#include "llvm/Target/TargetOptions.h"
87#include "llvm/TargetParser/Host.h"
88#include "llvm/TargetParser/Triple.h"
101#include <type_traits>
105using namespace clang;
106using namespace driver;
107using namespace options;
118 if (Arg.getAsInteger(10, Val))
119 return llvm::createStringError(llvm::inconvertibleErrorCode(),
120 "Not an integer: %s", Arg.data());
129template <
class T> std::shared_ptr<T> make_shared_copy(
const T &
X) {
130 return std::make_shared<T>(
X);
135 return llvm::makeIntrusiveRefCnt<T>(
X);
157 LangOpts = make_shared_copy(
X.getLangOpts());
160 HSOpts = make_shared_copy(
X.getHeaderSearchOpts());
161 PPOpts = make_shared_copy(
X.getPreprocessorOpts());
166 FSOpts = make_shared_copy(
X.getFileSystemOpts());
207T &ensureOwned(std::shared_ptr<T> &Storage) {
208 if (Storage.use_count() > 1)
209 Storage = std::make_shared<T>(*Storage);
215 if (Storage.useCount() > 1)
216 Storage = llvm::makeIntrusiveRefCnt<T>(*Storage);
234 return ensureOwned(
HSOpts);
238 return ensureOwned(
PPOpts);
258 return ensureOwned(
FSOpts);
280#define SIMPLE_ENUM_VALUE_TABLE
281#include "clang/Driver/Options.inc"
282#undef SIMPLE_ENUM_VALUE_TABLE
288 if (Args.hasArg(Opt))
297 if (Args.hasArg(Opt))
307 const Twine &Spelling, Option::OptionClass,
313 return !std::is_same_v<T, uint64_t> && llvm::is_integral_or_enum<T>::value;
317 std::enable_if_t<!is_uint64_t_convertible<T>(),
bool> =
false>
319 return [
Value](OptSpecifier Opt,
unsigned,
const ArgList &Args,
321 if (Args.hasArg(Opt))
328 std::enable_if_t<is_uint64_t_convertible<T>(),
bool> =
false>
334 OptSpecifier OtherOpt) {
335 return [
Value, OtherValue,
336 OtherOpt](OptSpecifier Opt,
unsigned,
const ArgList &Args,
338 if (
const Arg *A = Args.getLastArg(Opt, OtherOpt)) {
339 return A->getOption().matches(Opt) ?
Value : OtherValue;
347 Option::OptionClass,
unsigned,
bool KeyPath) {
348 if (KeyPath ==
Value)
354 const Twine &Spelling,
355 Option::OptionClass OptClass,
unsigned,
356 const Twine &
Value) {
358 case Option::SeparateClass:
359 case Option::JoinedOrSeparateClass:
360 case Option::JoinedAndSeparateClass:
364 case Option::JoinedClass:
365 case Option::CommaJoinedClass:
366 Consumer(Spelling +
Value);
369 llvm_unreachable(
"Cannot denormalize an option with option class "
370 "incompatible with string denormalization.");
376 Option::OptionClass OptClass,
unsigned TableIndex,
381static std::optional<SimpleEnumValue>
383 for (
int I = 0, E = Table.Size; I != E; ++I)
384 if (Name == Table.Table[I].Name)
385 return Table.Table[I];
390static std::optional<SimpleEnumValue>
392 for (
int I = 0, E = Table.Size; I != E; ++I)
394 return Table.Table[I];
403 assert(TableIndex < SimpleEnumValueTablesSize);
404 const SimpleEnumValueTable &Table = SimpleEnumValueTables[TableIndex];
406 auto *Arg = Args.getLastArg(Opt);
410 StringRef ArgValue = Arg->getValue();
412 return MaybeEnumVal->Value;
414 Diags.
Report(diag::err_drv_invalid_value)
415 << Arg->getAsString(Args) << ArgValue;
420 const Twine &Spelling,
421 Option::OptionClass OptClass,
422 unsigned TableIndex,
unsigned Value) {
423 assert(TableIndex < SimpleEnumValueTablesSize);
424 const SimpleEnumValueTable &Table = SimpleEnumValueTables[TableIndex];
429 llvm_unreachable(
"The simple enum value was not correctly defined in "
430 "the tablegen option description");
436 const Twine &Spelling,
437 Option::OptionClass OptClass,
438 unsigned TableIndex,
T Value) {
440 static_cast<unsigned>(
Value));
447 auto *Arg = Args.getLastArg(Opt);
450 return std::string(Arg->getValue());
453template <
typename IntTy>
457 auto *Arg = Args.getLastArg(Opt);
461 if (StringRef(Arg->getValue()).getAsInteger(0, Res)) {
462 Diags.
Report(diag::err_drv_invalid_int_value)
463 << Arg->getAsString(Args) << Arg->getValue();
469static std::optional<std::vector<std::string>>
472 return Args.getAllArgValues(Opt);
476 const Twine &Spelling,
477 Option::OptionClass OptClass,
479 const std::vector<std::string> &Values) {
481 case Option::CommaJoinedClass: {
482 std::string CommaJoinedValue;
483 if (!Values.empty()) {
484 CommaJoinedValue.append(Values.front());
485 for (
const std::string &
Value : llvm::drop_begin(Values, 1)) {
486 CommaJoinedValue.append(
",");
487 CommaJoinedValue.append(
Value);
491 TableIndex, CommaJoinedValue);
494 case Option::JoinedClass:
495 case Option::SeparateClass:
496 case Option::JoinedOrSeparateClass:
497 for (
const std::string &
Value : Values)
501 llvm_unreachable(
"Cannot denormalize an option with option class "
502 "incompatible with string vector denormalization.");
510 auto *Arg = Args.getLastArg(Opt);
513 return llvm::Triple::normalize(Arg->getValue());
516template <
typename T,
typename U>
518 return static_cast<T>(
Value);
522 return KeyPath |
Value;
529template <
typename T,
typename U, U Value>
534#define PARSE_OPTION_WITH_MARSHALLING( \
535 ARGS, DIAGS, PREFIX_TYPE, SPELLING, ID, KIND, GROUP, ALIAS, ALIASARGS, \
536 FLAGS, VISIBILITY, PARAM, HELPTEXT, HELPTEXTSFORVARIANTS, METAVAR, VALUES, \
537 SHOULD_PARSE, ALWAYS_EMIT, KEYPATH, DEFAULT_VALUE, IMPLIED_CHECK, \
538 IMPLIED_VALUE, NORMALIZER, DENORMALIZER, MERGER, EXTRACTOR, TABLE_INDEX) \
539 if ((VISIBILITY) & options::CC1Option) { \
540 KEYPATH = MERGER(KEYPATH, DEFAULT_VALUE); \
542 KEYPATH = MERGER(KEYPATH, IMPLIED_VALUE); \
544 if (auto MaybeValue = NORMALIZER(OPT_##ID, TABLE_INDEX, ARGS, DIAGS)) \
546 MERGER(KEYPATH, static_cast<decltype(KEYPATH)>(*MaybeValue)); \
551#define GENERATE_OPTION_WITH_MARSHALLING( \
552 CONSUMER, PREFIX_TYPE, SPELLING, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, \
553 VISIBILITY, PARAM, HELPTEXT, HELPTEXTSFORVARIANTS, METAVAR, VALUES, \
554 SHOULD_PARSE, ALWAYS_EMIT, KEYPATH, DEFAULT_VALUE, IMPLIED_CHECK, \
555 IMPLIED_VALUE, NORMALIZER, DENORMALIZER, MERGER, EXTRACTOR, TABLE_INDEX) \
556 if ((VISIBILITY) & options::CC1Option) { \
557 [&](const auto &Extracted) { \
560 static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? (IMPLIED_VALUE) \
561 : (DEFAULT_VALUE)))) \
562 DENORMALIZER(CONSUMER, SPELLING, Option::KIND##Class, TABLE_INDEX, \
564 }(EXTRACTOR(KEYPATH)); \
578 CodeGenOpts.XRayInstrumentFunctions = LangOpts.XRayInstrument;
579 CodeGenOpts.XRayAlwaysEmitCustomEvents = LangOpts.XRayAlwaysEmitCustomEvents;
580 CodeGenOpts.XRayAlwaysEmitTypedEvents = LangOpts.XRayAlwaysEmitTypedEvents;
581 CodeGenOpts.DisableFree = FrontendOpts.
DisableFree;
584 CodeGenOpts.ClearASTBeforeBackend =
false;
586 LangOpts.ForceEmitVTables = CodeGenOpts.ForceEmitVTables;
587 LangOpts.SpeculativeLoadHardening = CodeGenOpts.SpeculativeLoadHardening;
590 llvm::Triple
T(TargetOpts.
Triple);
591 llvm::Triple::ArchType Arch =
T.getArch();
596 if (LangOpts.getExceptionHandling() !=
598 T.isWindowsMSVCEnvironment())
599 Diags.
Report(diag::err_fe_invalid_exception_model)
600 <<
static_cast<unsigned>(LangOpts.getExceptionHandling()) <<
T.str();
602 if (LangOpts.AppleKext && !LangOpts.CPlusPlus)
603 Diags.
Report(diag::warn_c_kext);
605 if (LangOpts.NewAlignOverride &&
606 !llvm::isPowerOf2_32(LangOpts.NewAlignOverride)) {
607 Arg *A = Args.getLastArg(OPT_fnew_alignment_EQ);
608 Diags.
Report(diag::err_fe_invalid_alignment)
609 << A->getAsString(Args) << A->getValue();
610 LangOpts.NewAlignOverride = 0;
614 if (LangOpts.SYCLIsDevice && LangOpts.SYCLIsHost)
615 Diags.
Report(diag::err_drv_argument_not_allowed_with) <<
"-fsycl-is-device"
618 if (Args.hasArg(OPT_fgnu89_inline) && LangOpts.CPlusPlus)
619 Diags.
Report(diag::err_drv_argument_not_allowed_with)
622 if (Args.hasArg(OPT_hlsl_entrypoint) && !LangOpts.HLSL)
623 Diags.
Report(diag::err_drv_argument_not_allowed_with)
626 if (Args.hasArg(OPT_fgpu_allow_device_init) && !LangOpts.HIP)
627 Diags.
Report(diag::warn_ignored_hip_only_option)
628 << Args.getLastArg(OPT_fgpu_allow_device_init)->getAsString(Args);
630 if (Args.hasArg(OPT_gpu_max_threads_per_block_EQ) && !LangOpts.HIP)
631 Diags.
Report(diag::warn_ignored_hip_only_option)
632 << Args.getLastArg(OPT_gpu_max_threads_per_block_EQ)->getAsString(Args);
641 if (Args.hasArg(OPT_ffp_eval_method_EQ)) {
642 if (LangOpts.ApproxFunc)
643 Diags.
Report(diag::err_incompatible_fp_eval_method_options) << 0;
644 if (LangOpts.AllowFPReassoc)
645 Diags.
Report(diag::err_incompatible_fp_eval_method_options) << 1;
646 if (LangOpts.AllowRecip)
647 Diags.
Report(diag::err_incompatible_fp_eval_method_options) << 2;
653 if (Args.getLastArg(OPT_cl_strict_aliasing) &&
655 Diags.
Report(diag::warn_option_invalid_ocl_version)
657 << Args.getLastArg(OPT_cl_strict_aliasing)->getAsString(Args);
659 if (Arg *A = Args.getLastArg(OPT_fdefault_calling_conv_EQ)) {
660 auto DefaultCC = LangOpts.getDefaultCallingConv();
664 Arch != llvm::Triple::x86;
670 Diags.
Report(diag::err_drv_argument_not_allowed_with)
671 << A->getSpelling() <<
T.getTriple();
683 unsigned DefaultOpt = 0;
686 !Args.hasArg(OPT_cl_opt_disable))
689 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
690 if (A->getOption().matches(options::OPT_O0))
693 if (A->getOption().matches(options::OPT_Ofast))
696 assert(A->getOption().matches(options::OPT_O));
698 StringRef S(A->getValue());
699 if (S ==
"s" || S ==
"z")
712 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
713 if (A->getOption().matches(options::OPT_O)) {
714 switch (A->getValue()[0]) {
728 llvm::opt::OptSpecifier OptSpecifier) {
731 Option::OptionClass::FlagClass, 0);
735 llvm::opt::OptSpecifier OptSpecifier,
736 const Twine &
Value) {
774 bool CheckAgainstOriginalInvocation =
false,
775 bool ForceRoundTrip =
false) {
777 bool DoRoundTripDefault =
true;
779 bool DoRoundTripDefault =
false;
782 bool DoRoundTrip = DoRoundTripDefault;
783 if (ForceRoundTrip) {
786 for (
const auto *Arg : CommandLineArgs) {
787 if (Arg == StringRef(
"-round-trip-args"))
789 if (Arg == StringRef(
"-no-round-trip-args"))
797 return Parse(RealInvocation, CommandLineArgs, Diags, Argv0);
802 llvm::raw_string_ostream OS(Buffer);
803 for (
const char *Arg : Args) {
804 llvm::sys::printArg(OS, Arg,
true);
817 if (!Parse(DummyInvocation, CommandLineArgs, DummyDiags, Argv0) ||
824 auto Success = Parse(RealInvocation, CommandLineArgs, Diags, Argv0);
830 Diags.
Report(diag::err_cc1_round_trip_fail_then_ok);
831 Diags.
Report(diag::note_cc1_round_trip_original)
832 << SerializeArgs(CommandLineArgs);
837 llvm::BumpPtrAllocator Alloc;
838 llvm::StringSaver StringPool(Alloc);
839 auto SA = [&StringPool](
const Twine &Arg) {
840 return StringPool.save(Arg).data();
847 Generate(DummyInvocation, GeneratedArgs, SA);
853 bool Success2 = Parse(RealInvocation, GeneratedArgs, Diags, Argv0);
858 Diags.
Report(diag::err_cc1_round_trip_ok_then_fail);
859 Diags.
Report(diag::note_cc1_round_trip_generated)
860 << 1 << SerializeArgs(GeneratedArgs);
865 if (CheckAgainstOriginalInvocation)
867 ComparisonArgs.assign(CommandLineArgs.begin(), CommandLineArgs.end());
871 Generate(RealInvocation, ComparisonArgs, SA);
876 return std::equal(A.begin(), A.end(), B.begin(), B.end(),
877 [](
const char *AElem,
const char *BElem) {
878 return StringRef(AElem) == StringRef(BElem);
885 if (!
Equal(GeneratedArgs, ComparisonArgs)) {
886 Diags.
Report(diag::err_cc1_round_trip_mismatch);
887 Diags.
Report(diag::note_cc1_round_trip_generated)
888 << 1 << SerializeArgs(GeneratedArgs);
889 Diags.
Report(diag::note_cc1_round_trip_generated)
890 << 2 << SerializeArgs(ComparisonArgs);
894 Diags.
Report(diag::remark_cc1_round_trip_generated)
895 << 1 << SerializeArgs(GeneratedArgs);
896 Diags.
Report(diag::remark_cc1_round_trip_generated)
897 << 2 << SerializeArgs(ComparisonArgs);
909 return CreateFromArgsImpl(Invocation, CommandLineArgs, Diags, Argv0);
913 Args.push_back(
"-cc1");
916 DummyInvocation1, DummyInvocation2, Args, Diags, Argv0,
921 OptSpecifier GroupWithValue,
922 std::vector<std::string> &Diagnostics) {
923 for (
auto *A : Args.filtered(Group)) {
924 if (A->getOption().getKind() == Option::FlagClass) {
927 Diagnostics.push_back(
928 std::string(A->getOption().getName().drop_front(1)));
929 }
else if (A->getOption().matches(GroupWithValue)) {
932 Diagnostics.push_back(
933 std::string(A->getOption().getName().drop_front(1).rtrim(
"=-")));
936 Diagnostics.push_back(A->getValue());
947 std::vector<std::string> &Funcs) {
948 std::vector<std::string> Values = Args.getAllArgValues(OPT_fno_builtin_);
950 Funcs.insert(Funcs.end(), Values.begin(), BuiltinEnd);
957#define ANALYZER_OPTION_WITH_MARSHALLING(...) \
958 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
959#include "clang/Driver/Options.inc"
960#undef ANALYZER_OPTION_WITH_MARSHALLING
964#define ANALYSIS_CONSTRAINTS(NAME, CMDFLAG, DESC, CREATFN) \
966 GenerateArg(Consumer, OPT_analyzer_constraints, CMDFLAG); \
968#include "clang/StaticAnalyzer/Core/Analyses.def"
970 llvm_unreachable(
"Tried to generate unknown analysis constraint.");
976#define ANALYSIS_DIAGNOSTICS(NAME, CMDFLAG, DESC, CREATFN) \
978 GenerateArg(Consumer, OPT_analyzer_output, CMDFLAG); \
980#include "clang/StaticAnalyzer/Core/Analyses.def"
982 llvm_unreachable(
"Tried to generate unknown analysis diagnostic client.");
988#define ANALYSIS_PURGE(NAME, CMDFLAG, DESC) \
990 GenerateArg(Consumer, OPT_analyzer_purge, CMDFLAG); \
992#include "clang/StaticAnalyzer/Core/Analyses.def"
994 llvm_unreachable(
"Tried to generate unknown analysis purge mode.");
1000#define ANALYSIS_INLINING_MODE(NAME, CMDFLAG, DESC) \
1002 GenerateArg(Consumer, OPT_analyzer_inlining_mode, CMDFLAG); \
1004#include "clang/StaticAnalyzer/Core/Analyses.def"
1006 llvm_unreachable(
"Tried to generate unknown analysis inlining mode.");
1012 CP.second ? OPT_analyzer_checker : OPT_analyzer_disable_checker;
1021 for (
const auto &
C : Opts.
Config)
1022 SortedConfigOpts.emplace_back(
C.getKey(),
C.getValue());
1023 llvm::sort(SortedConfigOpts, llvm::less_first());
1025 for (
const auto &[Key,
Value] : SortedConfigOpts) {
1028 auto Entry = ConfigOpts.
Config.find(Key);
1029 if (Entry != ConfigOpts.
Config.end() && Entry->getValue() ==
Value)
1044#define ANALYZER_OPTION_WITH_MARSHALLING(...) \
1045 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
1046#include "clang/Driver/Options.inc"
1047#undef ANALYZER_OPTION_WITH_MARSHALLING
1049 if (Arg *A = Args.getLastArg(OPT_analyzer_constraints)) {
1050 StringRef Name = A->getValue();
1052#define ANALYSIS_CONSTRAINTS(NAME, CMDFLAG, DESC, CREATFN) \
1053 .Case(CMDFLAG, NAME##Model)
1054#include "clang/StaticAnalyzer/Core/Analyses.def"
1057 Diags.
Report(diag::err_drv_invalid_value)
1058 << A->getAsString(Args) << Name;
1061 if (
Value == AnalysisConstraints::Z3ConstraintsModel) {
1062 Diags.
Report(diag::err_analyzer_not_built_with_z3);
1069 if (Arg *A = Args.getLastArg(OPT_analyzer_output)) {
1070 StringRef Name = A->getValue();
1072#define ANALYSIS_DIAGNOSTICS(NAME, CMDFLAG, DESC, CREATFN) \
1073 .Case(CMDFLAG, PD_##NAME)
1074#include "clang/StaticAnalyzer/Core/Analyses.def"
1077 Diags.
Report(diag::err_drv_invalid_value)
1078 << A->getAsString(Args) << Name;
1084 if (Arg *A = Args.getLastArg(OPT_analyzer_purge)) {
1085 StringRef Name = A->getValue();
1087#define ANALYSIS_PURGE(NAME, CMDFLAG, DESC) \
1088 .Case(CMDFLAG, NAME)
1089#include "clang/StaticAnalyzer/Core/Analyses.def"
1092 Diags.
Report(diag::err_drv_invalid_value)
1093 << A->getAsString(Args) << Name;
1099 if (Arg *A = Args.getLastArg(OPT_analyzer_inlining_mode)) {
1100 StringRef Name = A->getValue();
1102#define ANALYSIS_INLINING_MODE(NAME, CMDFLAG, DESC) \
1103 .Case(CMDFLAG, NAME)
1104#include "clang/StaticAnalyzer/Core/Analyses.def"
1107 Diags.
Report(diag::err_drv_invalid_value)
1108 << A->getAsString(Args) << Name;
1116 Args.filtered(OPT_analyzer_checker, OPT_analyzer_disable_checker)) {
1118 bool IsEnabled = A->getOption().getID() == OPT_analyzer_checker;
1121 StringRef CheckerAndPackageList = A->getValue();
1123 CheckerAndPackageList.split(CheckersAndPackages,
",");
1124 for (
const StringRef &CheckerOrPackage : CheckersAndPackages)
1130 for (
const auto *A : Args.filtered(OPT_analyzer_config)) {
1134 StringRef configList = A->getValue();
1136 configList.split(configVals,
",");
1137 for (
const auto &configVal : configVals) {
1139 std::tie(key, val) = configVal.split(
"=");
1142 diag::err_analyzer_config_no_value) << configVal;
1145 if (val.contains(
'=')) {
1147 diag::err_analyzer_config_multiple_values)
1156 Diags.
Report(diag::err_analyzer_config_unknown) << key;
1161 Opts.
Config[key] = std::string(val);
1171 for (
unsigned i = 0; i < Args.getNumInputArgStrings(); ++i) {
1174 os << Args.getArgString(i);
1182 StringRef OptionName, StringRef DefaultVal) {
1183 return Config.insert({OptionName, std::string(DefaultVal)}).first->second;
1188 StringRef &OptionField, StringRef Name,
1189 StringRef DefaultVal) {
1198 bool &OptionField, StringRef Name,
bool DefaultVal) {
1199 auto PossiblyInvalidVal =
1200 llvm::StringSwitch<std::optional<bool>>(
1203 .Case(
"false",
false)
1204 .Default(std::nullopt);
1206 if (!PossiblyInvalidVal) {
1208 Diags->
Report(diag::err_analyzer_config_invalid_input)
1209 << Name <<
"a boolean";
1211 OptionField = DefaultVal;
1213 OptionField = *PossiblyInvalidVal;
1218 unsigned &OptionField, StringRef Name,
1219 unsigned DefaultVal) {
1221 OptionField = DefaultVal;
1222 bool HasFailed =
getStringOption(Config, Name, std::to_string(DefaultVal))
1223 .getAsInteger(0, OptionField);
1224 if (Diags && HasFailed)
1225 Diags->
Report(diag::err_analyzer_config_invalid_input)
1226 << Name <<
"an unsigned";
1234#define ANALYZER_OPTION(TYPE, NAME, CMDFLAG, DESC, DEFAULT_VAL) \
1235 initOption(AnOpts.Config, Diags, AnOpts.NAME, CMDFLAG, DEFAULT_VAL);
1236#define ANALYZER_OPTION_DEPENDS_ON_USER_MODE(...)
1237#include "clang/StaticAnalyzer/Core/AnalyzerOptions.def"
1239 assert(AnOpts.UserMode ==
"shallow" || AnOpts.UserMode ==
"deep");
1240 const bool InShallowMode = AnOpts.UserMode ==
"shallow";
1242#define ANALYZER_OPTION(...)
1243#define ANALYZER_OPTION_DEPENDS_ON_USER_MODE(TYPE, NAME, CMDFLAG, DESC, \
1244 SHALLOW_VAL, DEEP_VAL) \
1245 initOption(AnOpts.Config, Diags, AnOpts.NAME, CMDFLAG, \
1246 InShallowMode ? SHALLOW_VAL : DEEP_VAL);
1247#include "clang/StaticAnalyzer/Core/AnalyzerOptions.def"
1254 if (!AnOpts.RawSilencedCheckersAndPackages.empty()) {
1255 std::vector<StringRef> Checkers =
1257 std::vector<StringRef> Packages =
1261 AnOpts.RawSilencedCheckersAndPackages.split(CheckersAndPackages,
";");
1263 for (
const StringRef &CheckerOrPackage : CheckersAndPackages) {
1265 bool IsChecker = CheckerOrPackage.contains(
'.');
1266 bool IsValidName = IsChecker
1267 ? llvm::is_contained(Checkers, CheckerOrPackage)
1268 : llvm::is_contained(Packages, CheckerOrPackage);
1271 Diags->
Report(diag::err_unknown_analyzer_checker_or_package)
1272 << CheckerOrPackage;
1282 if (AnOpts.ShouldTrackConditionsDebug && !AnOpts.ShouldTrackConditions)
1283 Diags->
Report(diag::err_analyzer_config_invalid_input)
1284 <<
"track-conditions-debug" <<
"'track-conditions' to also be enabled";
1286 if (!AnOpts.CTUDir.empty() && !llvm::sys::fs::is_directory(AnOpts.CTUDir))
1287 Diags->
Report(diag::err_analyzer_config_invalid_input) <<
"ctu-dir"
1290 if (!AnOpts.ModelPath.empty() &&
1291 !llvm::sys::fs::is_directory(AnOpts.ModelPath))
1292 Diags->
Report(diag::err_analyzer_config_invalid_input) <<
"model-path"
1301 if (
Remark.hasValidPattern()) {
1306 GenerateArg(Consumer, OPT_R_Joined, StringRef(
"no-") + Name);
1315 OptSpecifier OptEQ, StringRef Name) {
1318 auto InitializeResultPattern = [&Diags, &Args, &
Result](
const Arg *A,
1319 StringRef Pattern) {
1320 Result.Pattern = Pattern.str();
1322 std::string RegexError;
1323 Result.Regex = std::make_shared<llvm::Regex>(
Result.Pattern);
1324 if (!
Result.Regex->isValid(RegexError)) {
1325 Diags.
Report(diag::err_drv_optimization_remark_pattern)
1326 << RegexError << A->getAsString(Args);
1333 for (Arg *A : Args) {
1334 if (A->getOption().matches(OPT_R_Joined)) {
1335 StringRef
Value = A->getValue();
1339 else if (
Value ==
"everything")
1341 else if (
Value.split(
'-') == std::make_pair(StringRef(
"no"), Name))
1343 else if (
Value ==
"no-everything")
1353 InitializeResultPattern(A,
".*");
1355 }
else if (A->getOption().matches(OptEQ)) {
1357 if (!InitializeResultPattern(A, A->getValue()))
1366 const std::vector<std::string> &Levels,
1370 for (
const auto &Level : Levels) {
1372 llvm::StringSwitch<DiagnosticLevelMask>(Level)
1380 Diags.
Report(diag::err_drv_invalid_value) << FlagName << Level;
1388 const std::vector<std::string> &Sanitizers,
1390 for (
const auto &Sanitizer : Sanitizers) {
1393 Diags.
Report(diag::err_drv_invalid_value) << FlagName << Sanitizer;
1409 llvm::SplitString(Bundle, BundleParts,
",");
1410 for (
const auto &B : BundleParts) {
1414 D.
Report(diag::err_drv_invalid_value) << FlagName << Bundle;
1428 llvm::raw_string_ostream OS(Buffer);
1429 llvm::interleave(BundleParts, OS, [&OS](StringRef Part) { OS << Part; },
",");
1435 const Twine &ProfileName,
1436 llvm::vfs::FileSystem &FS,
1438 auto ReaderOrErr = llvm::IndexedInstrProfReader::create(ProfileName, FS);
1439 if (
auto E = ReaderOrErr.takeError()) {
1441 "Error in reading profile %0: %1");
1442 llvm::handleAllErrors(std::move(E), [&](
const llvm::ErrorInfoBase &EI) {
1443 Diags.
Report(DiagID) << ProfileName.str() << EI.message();
1447 std::unique_ptr<llvm::IndexedInstrProfReader> PGOReader =
1448 std::move(ReaderOrErr.get());
1452 if (PGOReader->isIRLevelProfile() || PGOReader->hasMemoryProfile()) {
1453 if (PGOReader->hasCSIRLevelProfile())
1461void CompilerInvocationBase::GenerateCodeGenArgs(
const CodeGenOptions &Opts,
1463 const llvm::Triple &
T,
1464 const std::string &OutputFile,
1468 if (Opts.OptimizationLevel == 0)
1471 GenerateArg(Consumer, OPT_O, Twine(Opts.OptimizationLevel));
1473#define CODEGEN_OPTION_WITH_MARSHALLING(...) \
1474 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
1475#include "clang/Driver/Options.inc"
1476#undef CODEGEN_OPTION_WITH_MARSHALLING
1478 if (Opts.OptimizationLevel > 0) {
1482 GenerateArg(Consumer, OPT_finline_hint_functions);
1487 if (Opts.DirectAccessExternalData &&
LangOpts->PICLevel != 0)
1488 GenerateArg(Consumer, OPT_fdirect_access_external_data);
1489 else if (!Opts.DirectAccessExternalData &&
LangOpts->PICLevel == 0)
1490 GenerateArg(Consumer, OPT_fno_direct_access_external_data);
1492 std::optional<StringRef> DebugInfoVal;
1493 switch (Opts.DebugInfo) {
1494 case llvm::codegenoptions::DebugLineTablesOnly:
1495 DebugInfoVal =
"line-tables-only";
1497 case llvm::codegenoptions::DebugDirectivesOnly:
1498 DebugInfoVal =
"line-directives-only";
1500 case llvm::codegenoptions::DebugInfoConstructor:
1501 DebugInfoVal =
"constructor";
1503 case llvm::codegenoptions::LimitedDebugInfo:
1504 DebugInfoVal =
"limited";
1506 case llvm::codegenoptions::FullDebugInfo:
1507 DebugInfoVal =
"standalone";
1509 case llvm::codegenoptions::UnusedTypeInfo:
1510 DebugInfoVal =
"unused-types";
1512 case llvm::codegenoptions::NoDebugInfo:
1513 DebugInfoVal = std::nullopt;
1515 case llvm::codegenoptions::LocTrackingOnly:
1516 DebugInfoVal = std::nullopt;
1520 GenerateArg(Consumer, OPT_debug_info_kind_EQ, *DebugInfoVal);
1524 Prefix.first +
"=" + Prefix.second);
1527 GenerateArg(Consumer, OPT_fcoverage_prefix_map_EQ,
1528 Prefix.first +
"=" + Prefix.second);
1530 if (Opts.NewStructPathTBAA)
1533 if (Opts.OptimizeSize == 1)
1535 else if (Opts.OptimizeSize == 2)
1543 if (Opts.UnrollLoops && Opts.OptimizationLevel <= 1)
1545 else if (!Opts.UnrollLoops && Opts.OptimizationLevel > 1)
1551 if (Opts.DebugNameTable ==
1552 static_cast<unsigned>(llvm::DICompileUnit::DebugNameTableKind::GNU))
1554 else if (Opts.DebugNameTable ==
1555 static_cast<unsigned>(
1556 llvm::DICompileUnit::DebugNameTableKind::Default))
1559 if (Opts.DebugTemplateAlias)
1562 auto TNK = Opts.getDebugSimpleTemplateNames();
1563 if (TNK != llvm::codegenoptions::DebugTemplateNamesKind::Full) {
1564 if (TNK == llvm::codegenoptions::DebugTemplateNamesKind::Simple)
1565 GenerateArg(Consumer, OPT_gsimple_template_names_EQ,
"simple");
1566 else if (TNK == llvm::codegenoptions::DebugTemplateNamesKind::Mangled)
1567 GenerateArg(Consumer, OPT_gsimple_template_names_EQ,
"mangled");
1572 if (Opts.TimePasses) {
1573 if (Opts.TimePassesPerRun)
1574 GenerateArg(Consumer, OPT_ftime_report_EQ,
"per-pass-run");
1579 if (Opts.PrepareForLTO && !Opts.PrepareForThinLTO)
1582 if (Opts.PrepareForThinLTO)
1591 StringRef MemProfileBasename(
"memprof.profraw");
1612 std::string InstrBundle =
1614 if (!InstrBundle.empty())
1615 GenerateArg(Consumer, OPT_fxray_instrumentation_bundle, InstrBundle);
1618 if (Opts.CFProtectionReturn && Opts.CFProtectionBranch)
1619 GenerateArg(Consumer, OPT_fcf_protection_EQ,
"full");
1620 else if (Opts.CFProtectionReturn)
1621 GenerateArg(Consumer, OPT_fcf_protection_EQ,
"return");
1622 else if (Opts.CFProtectionBranch)
1623 GenerateArg(Consumer, OPT_fcf_protection_EQ,
"branch");
1625 if (Opts.FunctionReturnThunks)
1626 GenerateArg(Consumer, OPT_mfunction_return_EQ,
"thunk-extern");
1629 bool Builtint = F.LinkFlags == llvm::Linker::Flags::LinkOnlyNeeded &&
1630 F.PropagateAttrs && F.Internalize;
1632 Builtint ? OPT_mlink_builtin_bitcode : OPT_mlink_bitcode_file,
1636 if (Opts.EmulatedTLS)
1644 GenerateArg(Consumer, OPT_fdenormal_fp_math_f32_EQ,
1649 T.isPPC32() ? OPT_maix_struct_return : OPT_fpcc_struct_return;
1653 T.isPPC32() ? OPT_msvr4_struct_return : OPT_freg_struct_return;
1657 if (Opts.EnableAIXExtendedAltivecABI)
1660 if (Opts.XCOFFReadOnlyPointers)
1678 GenerateArg(Consumer, OPT_fdiagnostics_hotness_threshold_EQ,
1683 GenerateArg(Consumer, OPT_fdiagnostics_misexpect_tolerance_EQ,
1687 GenerateArg(Consumer, OPT_fsanitize_recover_EQ, Sanitizer);
1690 GenerateArg(Consumer, OPT_fsanitize_trap_EQ, Sanitizer);
1692 if (!Opts.EmitVersionIdentMetadata)
1695 switch (Opts.FiniteLoops) {
1707bool CompilerInvocation::ParseCodeGenArgs(
CodeGenOptions &Opts, ArgList &Args,
1710 const llvm::Triple &
T,
1711 const std::string &OutputFile,
1717 unsigned MaxOptLevel = 3;
1718 if (OptimizationLevel > MaxOptLevel) {
1721 Diags.
Report(diag::warn_drv_optimization_value)
1722 << Args.getLastArg(OPT_O)->getAsString(Args) <<
"-O" << MaxOptLevel;
1723 OptimizationLevel = MaxOptLevel;
1725 Opts.OptimizationLevel = OptimizationLevel;
1734#define CODEGEN_OPTION_WITH_MARSHALLING(...) \
1735 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
1736#include "clang/Driver/Options.inc"
1737#undef CODEGEN_OPTION_WITH_MARSHALLING
1741 if (Opts.OptimizationLevel == 0) {
1743 }
else if (
const Arg *A = Args.getLastArg(options::OPT_finline_functions,
1744 options::OPT_finline_hint_functions,
1745 options::OPT_fno_inline_functions,
1746 options::OPT_fno_inline)) {
1749 if (A->getOption().matches(options::OPT_finline_functions))
1751 else if (A->getOption().matches(options::OPT_finline_hint_functions))
1761 Opts.DirectAccessExternalData =
1762 Args.hasArg(OPT_fdirect_access_external_data) ||
1763 (!Args.hasArg(OPT_fno_direct_access_external_data) &&
1766 if (Arg *A = Args.getLastArg(OPT_debug_info_kind_EQ)) {
1768 llvm::StringSwitch<unsigned>(A->getValue())
1769 .Case(
"line-tables-only", llvm::codegenoptions::DebugLineTablesOnly)
1770 .Case(
"line-directives-only",
1771 llvm::codegenoptions::DebugDirectivesOnly)
1772 .Case(
"constructor", llvm::codegenoptions::DebugInfoConstructor)
1773 .Case(
"limited", llvm::codegenoptions::LimitedDebugInfo)
1774 .Case(
"standalone", llvm::codegenoptions::FullDebugInfo)
1775 .Case(
"unused-types", llvm::codegenoptions::UnusedTypeInfo)
1778 Diags.
Report(diag::err_drv_invalid_value) << A->getAsString(Args)
1781 Opts.setDebugInfo(
static_cast<llvm::codegenoptions::DebugInfoKind
>(Val));
1787 Args.getLastArg(OPT_fuse_ctor_homing, OPT_fno_use_ctor_homing)) {
1788 if (A->getOption().matches(OPT_fuse_ctor_homing) &&
1789 Opts.getDebugInfo() == llvm::codegenoptions::LimitedDebugInfo)
1790 Opts.setDebugInfo(llvm::codegenoptions::DebugInfoConstructor);
1791 if (A->getOption().matches(OPT_fno_use_ctor_homing) &&
1792 Opts.getDebugInfo() == llvm::codegenoptions::DebugInfoConstructor)
1793 Opts.setDebugInfo(llvm::codegenoptions::LimitedDebugInfo);
1796 for (
const auto &Arg : Args.getAllArgValues(OPT_fdebug_prefix_map_EQ)) {
1797 auto Split = StringRef(Arg).split(
'=');
1801 for (
const auto &Arg : Args.getAllArgValues(OPT_fcoverage_prefix_map_EQ)) {
1802 auto Split = StringRef(Arg).split(
'=');
1806 const llvm::Triple::ArchType DebugEntryValueArchs[] = {
1807 llvm::Triple::x86, llvm::Triple::x86_64, llvm::Triple::aarch64,
1808 llvm::Triple::arm, llvm::Triple::armeb, llvm::Triple::mips,
1809 llvm::Triple::mipsel, llvm::Triple::mips64, llvm::Triple::mips64el};
1812 llvm::is_contained(DebugEntryValueArchs,
T.getArch()))
1813 Opts.EmitCallSiteInfo =
true;
1816 Diags.
Report(diag::warn_ignoring_verify_debuginfo_preserve_export)
1821 Opts.NewStructPathTBAA = !Args.hasArg(OPT_no_struct_path_tbaa) &&
1822 Args.hasArg(OPT_new_struct_path_tbaa);
1824 Opts.SimplifyLibCalls = !
LangOpts->NoBuiltin;
1825 if (Opts.SimplifyLibCalls)
1828 Args.hasFlag(OPT_funroll_loops, OPT_fno_unroll_loops,
1829 (Opts.OptimizationLevel > 1));
1831 std::string(Args.getLastArgValue(OPT_fbinutils_version_EQ));
1833 Opts.DebugTemplateAlias = Args.hasArg(OPT_gtemplate_alias);
1835 Opts.DebugNameTable =
static_cast<unsigned>(
1836 Args.hasArg(OPT_ggnu_pubnames)
1837 ? llvm::DICompileUnit::DebugNameTableKind::GNU
1838 : Args.hasArg(OPT_gpubnames)
1839 ? llvm::DICompileUnit::DebugNameTableKind::Default
1840 : llvm::DICompileUnit::DebugNameTableKind::None);
1841 if (
const Arg *A = Args.getLastArg(OPT_gsimple_template_names_EQ)) {
1842 StringRef
Value = A->getValue();
1844 Diags.
Report(diag::err_drv_unsupported_option_argument)
1845 << A->getSpelling() << A->getValue();
1846 Opts.setDebugSimpleTemplateNames(
1847 StringRef(A->getValue()) ==
"simple"
1848 ? llvm::codegenoptions::DebugTemplateNamesKind::Simple
1849 : llvm::codegenoptions::DebugTemplateNamesKind::Mangled);
1852 if (
const Arg *A = Args.getLastArg(OPT_ftime_report, OPT_ftime_report_EQ)) {
1853 Opts.TimePasses =
true;
1856 if (A->getOption().getID() == OPT_ftime_report_EQ) {
1857 StringRef Val = A->getValue();
1858 if (Val ==
"per-pass")
1859 Opts.TimePassesPerRun =
false;
1860 else if (Val ==
"per-pass-run")
1861 Opts.TimePassesPerRun =
true;
1863 Diags.
Report(diag::err_drv_invalid_value)
1864 << A->getAsString(Args) << A->getValue();
1868 Opts.PrepareForLTO =
false;
1869 Opts.PrepareForThinLTO =
false;
1870 if (Arg *A = Args.getLastArg(OPT_flto_EQ)) {
1871 Opts.PrepareForLTO =
true;
1872 StringRef S = A->getValue();
1874 Opts.PrepareForThinLTO =
true;
1875 else if (S !=
"full")
1876 Diags.
Report(diag::err_drv_invalid_value) << A->getAsString(Args) << S;
1877 if (Args.hasArg(OPT_funified_lto))
1878 Opts.PrepareForThinLTO =
true;
1880 if (Arg *A = Args.getLastArg(OPT_fthinlto_index_EQ)) {
1882 Diags.
Report(diag::err_drv_argument_only_allowed_with)
1883 << A->getAsString(Args) <<
"-x ir";
1885 std::string(Args.getLastArgValue(OPT_fthinlto_index_EQ));
1887 if (Arg *A = Args.getLastArg(OPT_save_temps_EQ))
1889 llvm::StringSwitch<std::string>(A->getValue())
1890 .Case(
"obj", OutputFile)
1891 .Default(llvm::sys::path::filename(OutputFile).str());
1894 const char *MemProfileBasename =
"memprof.profraw";
1895 if (Args.hasArg(OPT_fmemory_profile_EQ)) {
1897 std::string(Args.getLastArgValue(OPT_fmemory_profile_EQ)));
1898 llvm::sys::path::append(Path, MemProfileBasename);
1900 }
else if (Args.hasArg(OPT_fmemory_profile))
1905 if (Args.hasArg(OPT_coverage_version_EQ)) {
1906 StringRef CoverageVersion = Args.getLastArgValue(OPT_coverage_version_EQ);
1907 if (CoverageVersion.size() != 4) {
1908 Diags.
Report(diag::err_drv_invalid_value)
1909 << Args.getLastArg(OPT_coverage_version_EQ)->getAsString(Args)
1919 for (
const auto &A : Args) {
1921 if (A->getOption().getID() == options::OPT_o ||
1922 A->getOption().getID() == options::OPT_INPUT ||
1923 A->getOption().getID() == options::OPT_x ||
1924 A->getOption().getID() == options::OPT_fembed_bitcode ||
1925 A->getOption().matches(options::OPT_W_Group))
1928 A->render(Args, ASL);
1929 for (
const auto &arg : ASL) {
1930 StringRef ArgStr(arg);
1931 Opts.
CmdArgs.insert(Opts.
CmdArgs.end(), ArgStr.begin(), ArgStr.end());
1937 auto XRayInstrBundles =
1938 Args.getAllArgValues(OPT_fxray_instrumentation_bundle);
1939 if (XRayInstrBundles.empty())
1942 for (
const auto &A : XRayInstrBundles)
1946 if (
const Arg *A = Args.getLastArg(OPT_fcf_protection_EQ)) {
1947 StringRef Name = A->getValue();
1948 if (Name ==
"full") {
1949 Opts.CFProtectionReturn = 1;
1950 Opts.CFProtectionBranch = 1;
1951 }
else if (Name ==
"return")
1952 Opts.CFProtectionReturn = 1;
1953 else if (Name ==
"branch")
1954 Opts.CFProtectionBranch = 1;
1955 else if (Name !=
"none")
1956 Diags.
Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Name;
1959 if (
const Arg *A = Args.getLastArg(OPT_mfunction_return_EQ)) {
1960 auto Val = llvm::StringSwitch<llvm::FunctionReturnThunksKind>(A->getValue())
1961 .Case(
"keep", llvm::FunctionReturnThunksKind::Keep)
1962 .Case(
"thunk-extern", llvm::FunctionReturnThunksKind::Extern)
1963 .Default(llvm::FunctionReturnThunksKind::Invalid);
1966 Diags.
Report(diag::err_drv_argument_not_allowed_with)
1967 << A->getSpelling() <<
T.getTriple();
1968 else if (Val == llvm::FunctionReturnThunksKind::Invalid)
1969 Diags.
Report(diag::err_drv_invalid_value)
1970 << A->getAsString(Args) << A->getValue();
1971 else if (Val == llvm::FunctionReturnThunksKind::Extern &&
1972 Args.getLastArgValue(OPT_mcmodel_EQ).equals(
"large"))
1973 Diags.
Report(diag::err_drv_argument_not_allowed_with)
1974 << A->getAsString(Args)
1975 << Args.getLastArg(OPT_mcmodel_EQ)->getAsString(Args);
1977 Opts.FunctionReturnThunks =
static_cast<unsigned>(Val);
1981 Args.filtered(OPT_mlink_bitcode_file, OPT_mlink_builtin_bitcode)) {
1984 if (A->getOption().matches(OPT_mlink_builtin_bitcode)) {
1985 F.
LinkFlags = llvm::Linker::Flags::LinkOnlyNeeded;
1994 if (Arg *A = Args.getLastArg(OPT_fdenormal_fp_math_EQ)) {
1995 StringRef Val = A->getValue();
1999 Diags.
Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Val;
2002 if (Arg *A = Args.getLastArg(OPT_fdenormal_fp_math_f32_EQ)) {
2003 StringRef Val = A->getValue();
2006 Diags.
Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Val;
2012 Args.getLastArg(OPT_fpcc_struct_return, OPT_freg_struct_return,
2013 OPT_maix_struct_return, OPT_msvr4_struct_return)) {
2017 Diags.
Report(diag::err_drv_unsupported_opt_for_target)
2018 << A->getSpelling() <<
T.str();
2020 const Option &O = A->getOption();
2021 if (O.matches(OPT_fpcc_struct_return) ||
2022 O.matches(OPT_maix_struct_return)) {
2025 assert(O.matches(OPT_freg_struct_return) ||
2026 O.matches(OPT_msvr4_struct_return));
2031 if (Arg *A = Args.getLastArg(OPT_mxcoff_roptr)) {
2033 Diags.
Report(diag::err_drv_unsupported_opt_for_target)
2034 << A->getSpelling() <<
T.str();
2044 if (!Args.hasFlag(OPT_fdata_sections, OPT_fno_data_sections,
false))
2045 Diags.
Report(diag::err_roptr_requires_data_sections);
2047 Opts.XCOFFReadOnlyPointers =
true;
2050 if (Arg *A = Args.getLastArg(OPT_mabi_EQ_quadword_atomics)) {
2051 if (!
T.isOSAIX() ||
T.isPPC32())
2052 Diags.
Report(diag::err_drv_unsupported_opt_for_target)
2053 << A->getSpelling() <<
T.str();
2056 bool NeedLocTracking =
false;
2059 NeedLocTracking =
true;
2061 if (Arg *A = Args.getLastArg(OPT_opt_record_passes)) {
2063 NeedLocTracking =
true;
2066 if (Arg *A = Args.getLastArg(OPT_opt_record_format)) {
2068 NeedLocTracking =
true;
2078 Diags, Args, OPT_Rpass_analysis_EQ,
"pass-analysis");
2088 if (Opts.DiagnosticsWithHotness && !UsingProfile &&
2091 Diags.
Report(diag::warn_drv_diagnostics_hotness_requires_pgo)
2092 <<
"-fdiagnostics-show-hotness";
2096 Args.getLastArg(options::OPT_fdiagnostics_hotness_threshold_EQ)) {
2098 llvm::remarks::parseHotnessThresholdOption(
arg->getValue());
2101 Diags.
Report(diag::err_drv_invalid_diagnotics_hotness_threshold)
2102 <<
"-fdiagnostics-hotness-threshold=";
2108 Diags.
Report(diag::warn_drv_diagnostics_hotness_requires_pgo)
2109 <<
"-fdiagnostics-hotness-threshold=";
2114 Args.getLastArg(options::OPT_fdiagnostics_misexpect_tolerance_EQ)) {
2118 Diags.
Report(diag::err_drv_invalid_diagnotics_misexpect_tolerance)
2119 <<
"-fdiagnostics-misexpect-tolerance=";
2125 Diags.
Report(diag::warn_drv_diagnostics_misexpect_requires_pgo)
2126 <<
"-fdiagnostics-misexpect-tolerance=";
2133 if (UsingSampleProfile)
2134 NeedLocTracking =
true;
2137 NeedLocTracking =
true;
2141 if (NeedLocTracking &&
2142 Opts.getDebugInfo() == llvm::codegenoptions::NoDebugInfo)
2143 Opts.setDebugInfo(llvm::codegenoptions::LocTrackingOnly);
2148 Args.getAllArgValues(OPT_fsanitize_recover_EQ), Diags,
2151 Args.getAllArgValues(OPT_fsanitize_trap_EQ), Diags,
2154 Opts.EmitVersionIdentMetadata = Args.hasFlag(OPT_Qy, OPT_Qn,
true);
2156 if (Args.hasArg(options::OPT_ffinite_loops))
2158 else if (Args.hasArg(options::OPT_fno_finite_loops))
2161 Opts.EmitIEEENaNCompliantInsts = Args.hasFlag(
2162 options::OPT_mamdgpu_ieee, options::OPT_mno_amdgpu_ieee,
true);
2163 if (!Opts.EmitIEEENaNCompliantInsts && !LangOptsRef.NoHonorNaNs)
2164 Diags.
Report(diag::err_drv_amdgpu_ieee_without_no_honor_nans);
2172#define DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING(...) \
2173 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
2174#include "clang/Driver/Options.inc"
2175#undef DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING
2180 for (
const auto &Dep : Opts.
ExtraDeps) {
2181 switch (Dep.second) {
2194 GenerateArg(Consumer, OPT_fdepfile_entry, Dep.first);
2203 bool ShowLineMarkers) {
2207#define DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING(...) \
2208 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
2209#include "clang/Driver/Options.inc"
2210#undef DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING
2212 if (Args.hasArg(OPT_show_includes)) {
2227 if (!Args.hasArg(OPT_fno_sanitize_ignorelist)) {
2228 for (
const auto *A : Args.filtered(OPT_fsanitize_ignorelist_EQ)) {
2229 StringRef Val = A->getValue();
2230 if (!Val.contains(
'='))
2234 for (
const auto *A : Args.filtered(OPT_fsanitize_system_ignorelist_EQ)) {
2235 StringRef Val = A->getValue();
2236 if (!Val.contains(
'='))
2243 for (
const auto &
Filename : Args.getAllArgValues(OPT_fprofile_list_EQ))
2247 for (
const auto *A : Args.filtered(OPT_fdepfile_entry))
2251 for (
const auto *A : Args.filtered(OPT_fmodule_file)) {
2252 StringRef Val = A->getValue();
2253 if (!Val.contains(
'='))
2263 Diags.
Report(diag::err_drv_print_header_env_var_combination_cc1)
2264 << Args.getLastArg(OPT_header_include_format_EQ)->getValue()
2265 << Args.getLastArg(OPT_header_include_filtering_EQ)->getValue();
2279 }
ShowColors = DefaultColor ? Colors_Auto : Colors_Off;
2280 for (
auto *A : Args) {
2281 const Option &O = A->getOption();
2282 if (O.matches(options::OPT_fcolor_diagnostics)) {
2284 }
else if (O.matches(options::OPT_fno_color_diagnostics)) {
2286 }
else if (O.matches(options::OPT_fdiagnostics_color_EQ)) {
2287 StringRef
Value(A->getValue());
2288 if (
Value ==
"always")
2290 else if (
Value ==
"never")
2292 else if (
Value ==
"auto")
2298 llvm::sys::Process::StandardErrHasColors());
2304 for (
const auto &Prefix : VerifyPrefixes) {
2307 auto BadChar = llvm::find_if(Prefix, [](
char C) {
2310 if (BadChar != Prefix.end() || !
isLetter(Prefix[0])) {
2312 Diags.
Report(diag::err_drv_invalid_value) <<
"-verify=" << Prefix;
2313 Diags.
Report(diag::note_drv_verify_prefix_spelling);
2323#define FILE_SYSTEM_OPTION_WITH_MARSHALLING(...) \
2324 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
2325#include "clang/Driver/Options.inc"
2326#undef FILE_SYSTEM_OPTION_WITH_MARSHALLING
2335#define FILE_SYSTEM_OPTION_WITH_MARSHALLING(...) \
2336 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
2337#include "clang/Driver/Options.inc"
2338#undef FILE_SYSTEM_OPTION_WITH_MARSHALLING
2346#define MIGRATOR_OPTION_WITH_MARSHALLING(...) \
2347 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
2348#include "clang/Driver/Options.inc"
2349#undef MIGRATOR_OPTION_WITH_MARSHALLING
2358#define MIGRATOR_OPTION_WITH_MARSHALLING(...) \
2359 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
2360#include "clang/Driver/Options.inc"
2361#undef MIGRATOR_OPTION_WITH_MARSHALLING
2366void CompilerInvocationBase::GenerateDiagnosticArgs(
2368 bool DefaultDiagColor) {
2370#define DIAG_OPTION_WITH_MARSHALLING(...) \
2371 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
2372#include "clang/Driver/Options.inc"
2373#undef DIAG_OPTION_WITH_MARSHALLING
2376 GenerateArg(Consumer, OPT_diagnostic_serialized_file,
2379 if (Opts.ShowColors)
2382 if (Opts.VerifyDiagnostics &&
2387 if (Prefix !=
"expected")
2394 GenerateArg(Consumer, OPT_verify_ignore_unexpected);
2397 GenerateArg(Consumer, OPT_verify_ignore_unexpected_EQ,
"note");
2399 GenerateArg(Consumer, OPT_verify_ignore_unexpected_EQ,
"remark");
2401 GenerateArg(Consumer, OPT_verify_ignore_unexpected_EQ,
"warning");
2403 GenerateArg(Consumer, OPT_verify_ignore_unexpected_EQ,
"error");
2408 if (
Warning ==
"undef-prefix")
2410 Consumer(StringRef(
"-W") +
Warning);
2416 StringRef IgnoredRemarks[] = {
"pass",
"no-pass",
2417 "pass-analysis",
"no-pass-analysis",
2418 "pass-missed",
"no-pass-missed"};
2419 if (llvm::is_contained(IgnoredRemarks,
Remark))
2422 Consumer(StringRef(
"-R") +
Remark);
2426std::unique_ptr<DiagnosticOptions>
2428 auto DiagOpts = std::make_unique<DiagnosticOptions>();
2429 unsigned MissingArgIndex, MissingArgCount;
2431 Argv.slice(1), MissingArgIndex, MissingArgCount);
2434 if (std::optional<std::string> NoColor =
2435 llvm::sys::Process::GetEnv(
"NO_COLOR");
2436 NoColor && !NoColor->empty()) {
2451 bool DefaultDiagColor) {
2452 std::optional<DiagnosticsEngine> IgnoringDiags;
2456 Diags = &*IgnoringDiags;
2465#define DIAG_OPTION_WITH_MARSHALLING(...) \
2466 PARSE_OPTION_WITH_MARSHALLING(Args, *Diags, __VA_ARGS__)
2467#include "clang/Driver/Options.inc"
2468#undef DIAG_OPTION_WITH_MARSHALLING
2470 llvm::sys::Process::UseANSIEscapeCodes(Opts.UseANSIEscapeCodes);
2473 Args.getLastArg(OPT_diagnostic_serialized_file, OPT__serialize_diags))
2477 Opts.VerifyDiagnostics = Args.hasArg(OPT_verify) || Args.hasArg(OPT_verify_EQ);
2479 if (Args.hasArg(OPT_verify))
2484 Opts.VerifyDiagnostics =
false;
2489 "-verify-ignore-unexpected=",
2490 Args.getAllArgValues(OPT_verify_ignore_unexpected_EQ), *Diags, DiagMask);
2491 if (Args.hasArg(OPT_verify_ignore_unexpected))
2493 Opts.setVerifyIgnoreUnexpected(DiagMask);
2495 Diags->
Report(diag::warn_ignoring_ftabstop_value)
2511 std::string &BlockName,
2512 unsigned &MajorVersion,
2513 unsigned &MinorVersion,
2515 std::string &UserInfo) {
2517 Arg.split(Args,
':', 5);
2518 if (Args.size() < 5)
2521 BlockName = std::string(Args[0]);
2522 if (Args[1].getAsInteger(10, MajorVersion))
return true;
2523 if (Args[2].getAsInteger(10, MinorVersion))
return true;
2524 if (Args[3].getAsInteger(2, Hashed))
return true;
2525 if (Args.size() > 4)
2526 UserInfo = std::string(Args[4]);
2535 static const std::pair<frontend::ActionKind, unsigned> Table[] = {
2565 OPT_emit_reduced_module_interface},
2583 OPT_print_dependency_directives_minimized_source},
2590static std::optional<frontend::ActionKind>
2593 if (ActionOpt.second == Opt.getID())
2594 return ActionOpt.first;
2596 return std::nullopt;
2600static std::optional<OptSpecifier>
2603 if (ActionOpt.first == ProgramAction)
2604 return OptSpecifier(ActionOpt.second);
2606 return std::nullopt;
2612#define FRONTEND_OPTION_WITH_MARSHALLING(...) \
2613 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
2614#include "clang/Driver/Options.inc"
2615#undef FRONTEND_OPTION_WITH_MARSHALLING
2617 std::optional<OptSpecifier> ProgramActionOpt =
2621 std::function<void()> GenerateProgramAction = [&]() {
2625 if (!ProgramActionOpt) {
2628 "Frontend action without option.");
2629 GenerateProgramAction = [&]() {
2636 GenerateProgramAction = [&]() {
2644 llvm_unreachable(
"Default AST dump format.");
2651 GenerateArg(Consumer, OPT_ast_dump_all_EQ, Format);
2664 GenerateProgramAction = [&]() {
2669 GenerateProgramAction();
2671 for (
const auto &PluginArgs : Opts.
PluginArgs) {
2673 for (
const auto &PluginArg : PluginArgs.second)
2675 Opt.getPrefix() + Opt.getName() + PluginArgs.first,
2676 Opt.getKind(), 0, PluginArg);
2680 if (
auto *TestExt = dyn_cast_or_null<TestModuleFileExtension>(Ext.get()))
2681 GenerateArg(Consumer, OPT_ftest_module_file_extension_EQ, TestExt->str());
2687 for (
const auto &Plugin : Opts.
Plugins)
2693 GenerateArg(Consumer, OPT_fmodule_file, ModuleFile);
2700 GenerateArg(Consumer, OPT_aux_target_feature, Feature);
2706 StringRef HeaderUnit =
"";
2711 HeaderUnit =
"-user";
2714 HeaderUnit =
"-system";
2717 HeaderUnit =
"-header-unit";
2720 StringRef Header = IsHeader ?
"-header" :
"";
2743 Lang =
"objective-c";
2746 Lang =
"objective-c++";
2749 Lang =
"renderscript";
2752 Lang =
"assembler-with-cpp";
2756 "Generating -x argument for unknown language (not precompiled).");
2771 Lang + HeaderUnit + Header +
ModuleMap + Preprocessed);
2775 for (
const auto &Input : Opts.
Inputs)
2776 Consumer(Input.getFile());
2785#define FRONTEND_OPTION_WITH_MARSHALLING(...) \
2786 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
2787#include "clang/Driver/Options.inc"
2788#undef FRONTEND_OPTION_WITH_MARSHALLING
2791 if (
const Arg *A = Args.getLastArg(OPT_Action_Group)) {
2792 OptSpecifier Opt = OptSpecifier(A->getOption().getID());
2794 assert(ProgramAction &&
"Option specifier not in Action_Group.");
2797 (Opt == OPT_ast_dump_all_EQ || Opt == OPT_ast_dump_EQ)) {
2798 unsigned Val = llvm::StringSwitch<unsigned>(A->getValue())
2801 .Default(std::numeric_limits<unsigned>::max());
2803 if (Val != std::numeric_limits<unsigned>::max())
2806 Diags.
Report(diag::err_drv_invalid_value)
2807 << A->getAsString(Args) << A->getValue();
2817 Args.hasArg(OPT_interface_stub_version_EQ)
2818 ? Args.getLastArgValue(OPT_interface_stub_version_EQ)
2820 if (ArgStr ==
"experimental-yaml-elf-v1" ||
2821 ArgStr ==
"experimental-ifs-v1" || ArgStr ==
"experimental-ifs-v2" ||
2822 ArgStr ==
"experimental-tapi-elf-v1") {
2823 std::string ErrorMessage =
2824 "Invalid interface stub format: " + ArgStr.str() +
2826 Diags.
Report(diag::err_drv_invalid_value)
2827 <<
"Must specify a valid interface stub format type, ie: "
2828 "-interface-stub-version=ifs-v1"
2831 }
else if (!ArgStr.starts_with(
"ifs-")) {
2832 std::string ErrorMessage =
2833 "Invalid interface stub format: " + ArgStr.str() +
".";
2834 Diags.
Report(diag::err_drv_invalid_value)
2835 <<
"Must specify a valid interface stub format type, ie: "
2836 "-interface-stub-version=ifs-v1"
2845 if (
const Arg* A = Args.getLastArg(OPT_plugin)) {
2846 Opts.
Plugins.emplace_back(A->getValue(0));
2850 for (
const auto *AA : Args.filtered(OPT_plugin_arg))
2851 Opts.
PluginArgs[AA->getValue(0)].emplace_back(AA->getValue(1));
2853 for (
const std::string &Arg :
2854 Args.getAllArgValues(OPT_ftest_module_file_extension_EQ)) {
2855 std::string BlockName;
2856 unsigned MajorVersion;
2857 unsigned MinorVersion;
2859 std::string UserInfo;
2861 MinorVersion, Hashed, UserInfo)) {
2862 Diags.
Report(diag::err_test_module_file_extension_format) << Arg;
2869 std::make_shared<TestModuleFileExtension>(
2870 BlockName, MajorVersion, MinorVersion, Hashed, UserInfo));
2873 if (
const Arg *A = Args.getLastArg(OPT_code_completion_at)) {
2877 Diags.
Report(diag::err_drv_invalid_value)
2878 << A->getAsString(Args) << A->getValue();
2881 Opts.
Plugins = Args.getAllArgValues(OPT_load);
2882 Opts.
ASTDumpDecls = Args.hasArg(OPT_ast_dump, OPT_ast_dump_EQ);
2883 Opts.
ASTDumpAll = Args.hasArg(OPT_ast_dump_all, OPT_ast_dump_all_EQ);
2885 for (
const auto *A : Args.filtered(OPT_fmodule_file)) {
2886 StringRef Val = A->getValue();
2887 if (!Val.contains(
'='))
2892 Diags.
Report(diag::err_drv_argument_only_allowed_with) <<
"-fsystem-module"
2895 if (Args.hasArg(OPT_aux_target_cpu))
2896 Opts.
AuxTargetCPU = std::string(Args.getLastArgValue(OPT_aux_target_cpu));
2897 if (Args.hasArg(OPT_aux_target_feature))
2902 Diags.
Report(diag::err_drv_argument_not_allowed_with)
2903 <<
"ARC migration" <<
"ObjC migration";
2907 if (
const Arg *A = Args.getLastArg(OPT_x)) {
2908 StringRef XValue = A->getValue();
2913 bool Preprocessed = XValue.consume_back(
"-cpp-output");
2914 bool ModuleMap = XValue.consume_back(
"-module-map");
2917 XValue !=
"precompiled-header" && XValue.consume_back(
"-header");
2923 if (IsHeader || Preprocessed) {
2924 if (XValue.consume_back(
"-header-unit"))
2926 else if (XValue.consume_back(
"-system"))
2928 else if (XValue.consume_back(
"-user"))
2934 IsHeaderFile = IsHeader && !Preprocessed && !
ModuleMap &&
2938 DashX = llvm::StringSwitch<InputKind>(XValue)
2955 DashX = llvm::StringSwitch<InputKind>(XValue)
2963 DashX = llvm::StringSwitch<InputKind>(XValue)
2966 .Cases(
"ast",
"pcm",
"precompiled-header",
2973 Diags.
Report(diag::err_drv_invalid_value)
2974 << A->getAsString(Args) << A->getValue();
2981 IsHeaderFile =
true;
2982 }
else if (IsHeaderFile)
2989 std::vector<std::string> Inputs = Args.getAllArgValues(OPT_INPUT);
2992 Inputs.push_back(
"-");
2996 Diags.
Report(diag::err_drv_header_unit_extra_inputs) << Inputs[1];
2998 for (
unsigned i = 0, e = Inputs.size(); i != e; ++i) {
3002 StringRef(Inputs[i]).rsplit(
'.').second);
3011 bool IsSystem =
false;
3020 Opts.
Inputs.emplace_back(std::move(Inputs[i]), IK, IsSystem);
3030 std::string ClangExecutable =
3031 llvm::sys::fs::getMainExecutable(Argv0, MainAddr);
3038#define HEADER_SEARCH_OPTION_WITH_MARSHALLING(...) \
3039 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
3040#include "clang/Driver/Options.inc"
3041#undef HEADER_SEARCH_OPTION_WITH_MARSHALLING
3053 GenerateArg(Consumer, OPT_fprebuilt_module_path, Path);
3056 GenerateArg(Consumer, OPT_fmodules_ignore_macro, Macro.val());
3060 std::optional<bool> IsFramework,
3061 std::optional<bool> IgnoreSysRoot) {
3062 return llvm::is_contained(Groups, Entry.
Group) &&
3063 (!IsFramework || (Entry.
IsFramework == *IsFramework)) &&
3064 (!IgnoreSysRoot || (Entry.
IgnoreSysRoot == *IgnoreSysRoot));
3072 std::nullopt,
true);
3074 OptSpecifier Opt = [It, Matches]() {
3083 llvm_unreachable(
"Unexpected HeaderSearchOptions::Entry.");
3099 It->Group ==
frontend::After ? OPT_iwithprefix : OPT_iwithprefixbefore;
3106 for (; It < End && Matches(*It, {
frontend::After},
false,
true); ++It)
3112 GenerateArg(Consumer, It->IgnoreSysRoot ? OPT_isystem : OPT_iwithsysroot,
3117 GenerateArg(Consumer, OPT_iframeworkwithsysroot, It->Path);
3125 GenerateArg(Consumer, OPT_objc_isystem, It->Path);
3127 GenerateArg(Consumer, OPT_objcxx_isystem, It->Path);
3137 ? OPT_internal_isystem
3138 : OPT_internal_externc_isystem;
3142 assert(It == End &&
"Unhandled HeaderSearchOption::Entry.");
3146 OptSpecifier Opt =
P.IsSystemHeader ? OPT_system_header_prefix
3147 : OPT_no_system_header_prefix;
3157 const std::string &WorkingDir) {
3162#define HEADER_SEARCH_OPTION_WITH_MARSHALLING(...) \
3163 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
3164#include "clang/Driver/Options.inc"
3165#undef HEADER_SEARCH_OPTION_WITH_MARSHALLING
3167 if (
const Arg *A = Args.getLastArg(OPT_stdlib_EQ))
3168 Opts.
UseLibcxx = (strcmp(A->getValue(),
"libc++") == 0);
3172 if (!(
P.empty() || llvm::sys::path::is_absolute(
P))) {
3173 if (WorkingDir.empty())
3174 llvm::sys::fs::make_absolute(
P);
3176 llvm::sys::fs::make_absolute(WorkingDir,
P);
3178 llvm::sys::path::remove_dots(
P);
3182 for (
const auto *A : Args.filtered(OPT_fmodule_file)) {
3183 StringRef Val = A->getValue();
3184 if (Val.contains(
'=')) {
3185 auto Split = Val.split(
'=');
3187 std::string(Split.first), std::string(Split.second));
3190 for (
const auto *A : Args.filtered(OPT_fprebuilt_module_path))
3193 for (
const auto *A : Args.filtered(OPT_fmodules_ignore_macro)) {
3194 StringRef MacroDef = A->getValue();
3196 llvm::CachedHashString(MacroDef.split(
'=').first));
3200 bool IsIndexHeaderMap =
false;
3201 bool IsSysrootSpecified =
3202 Args.hasArg(OPT__sysroot_EQ) || Args.hasArg(OPT_isysroot);
3206 auto PrefixHeaderPath = [IsSysrootSpecified,
3207 &Opts](
const llvm::opt::Arg *A,
3208 bool IsFramework =
false) -> std::string {
3209 assert(A->getNumValues() &&
"Unexpected empty search path flag!");
3210 if (IsSysrootSpecified && !IsFramework && A->getValue()[0] ==
'=') {
3212 llvm::sys::path::append(Buffer, Opts.
Sysroot,
3213 llvm::StringRef(A->getValue()).substr(1));
3214 return std::string(Buffer);
3216 return A->getValue();
3219 for (
const auto *A : Args.filtered(OPT_I, OPT_F, OPT_index_header_map)) {
3220 if (A->getOption().matches(OPT_index_header_map)) {
3222 IsIndexHeaderMap =
true;
3229 bool IsFramework = A->getOption().matches(OPT_F);
3230 Opts.
AddPath(PrefixHeaderPath(A, IsFramework), Group, IsFramework,
3232 IsIndexHeaderMap =
false;
3236 StringRef Prefix =
"";
3237 for (
const auto *A :
3238 Args.filtered(OPT_iprefix, OPT_iwithprefix, OPT_iwithprefixbefore)) {
3239 if (A->getOption().matches(OPT_iprefix))
3240 Prefix = A->getValue();
3241 else if (A->getOption().matches(OPT_iwithprefix))
3247 for (
const auto *A : Args.filtered(OPT_idirafter))
3249 for (
const auto *A : Args.filtered(OPT_iquote))
3252 for (
const auto *A : Args.filtered(OPT_isystem, OPT_iwithsysroot)) {
3253 if (A->getOption().matches(OPT_iwithsysroot)) {
3260 for (
const auto *A : Args.filtered(OPT_iframework))
3262 for (
const auto *A : Args.filtered(OPT_iframeworkwithsysroot))
3267 for (
const auto *A : Args.filtered(OPT_c_isystem))
3269 for (
const auto *A : Args.filtered(OPT_cxx_isystem))
3271 for (
const auto *A : Args.filtered(OPT_objc_isystem))
3273 for (
const auto *A : Args.filtered(OPT_objcxx_isystem))
3277 for (
const auto *A :
3278 Args.filtered(OPT_internal_isystem, OPT_internal_externc_isystem)) {
3280 if (A->getOption().matches(OPT_internal_externc_isystem))
3282 Opts.
AddPath(A->getValue(), Group,
false,
true);
3286 for (
const auto *A :
3287 Args.filtered(OPT_system_header_prefix, OPT_no_system_header_prefix))
3289 A->getValue(), A->getOption().matches(OPT_system_header_prefix));
3291 for (
const auto *A : Args.filtered(OPT_ivfsoverlay, OPT_vfsoverlay))
3300 GenerateArg(Consumer, OPT_fapinotes_swift_version,
3304 GenerateArg(Consumer, OPT_iapinotes_modules, Path);
3309 if (
const Arg *A = Args.getLastArg(OPT_fapinotes_swift_version)) {
3311 diags.
Report(diag::err_drv_invalid_value)
3312 << A->getAsString(Args) << A->getValue();
3314 for (
const Arg *A : Args.filtered(OPT_iapinotes_modules))
3320 if (Opts.PointerAuthIntrinsics)
3326 Opts.PointerAuthIntrinsics = Args.hasArg(OPT_fptrauth_intrinsics);
3336 llvm_unreachable(
"should not parse language flags for this input");
3372 llvm_unreachable(
"unexpected input language");
3381 return "Objective-C";
3385 return "Objective-C++";
3389 return "C++ for OpenCL";
3393 return "RenderScript";
3410 llvm_unreachable(
"unknown input language");
3413void CompilerInvocationBase::GenerateLangArgs(
const LangOptions &Opts,
3415 const llvm::Triple &
T,
3420 if (Opts.ObjCAutoRefCount)
3422 if (Opts.PICLevel != 0)
3423 GenerateArg(Consumer, OPT_pic_level, Twine(Opts.PICLevel));
3427 GenerateArg(Consumer, OPT_fsanitize_EQ, Sanitizer);
3432 OptSpecifier StdOpt;
3434 case LangStandard::lang_opencl10:
3435 case LangStandard::lang_opencl11:
3436 case LangStandard::lang_opencl12:
3437 case LangStandard::lang_opencl20:
3438 case LangStandard::lang_opencl30:
3439 case LangStandard::lang_openclcpp10:
3440 case LangStandard::lang_openclcpp2021:
3441 StdOpt = OPT_cl_std_EQ;
3444 StdOpt = OPT_std_EQ;
3451 if (Opts.IncludeDefaultHeader)
3452 GenerateArg(Consumer, OPT_finclude_default_header);
3453 if (Opts.DeclareOpenCLBuiltins)
3454 GenerateArg(Consumer, OPT_fdeclare_opencl_builtins);
3458#define LANG_OPTION_WITH_MARSHALLING(...) \
3459 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
3460#include "clang/Driver/Options.inc"
3461#undef LANG_OPTION_WITH_MARSHALLING
3472 else if (Opts.ObjCAutoRefCount == 1)
3475 if (Opts.ObjCWeakRuntime)
3476 GenerateArg(Consumer, OPT_fobjc_runtime_has_weak);
3481 if (Opts.ObjCSubscriptingLegacyRuntime)
3482 GenerateArg(Consumer, OPT_fobjc_subscripting_legacy_runtime);
3485 if (Opts.GNUCVersion != 0) {
3486 unsigned Major = Opts.GNUCVersion / 100 / 100;
3487 unsigned Minor = (Opts.GNUCVersion / 100) % 100;
3488 unsigned Patch = Opts.GNUCVersion % 100;
3490 Twine(Major) +
"." + Twine(Minor) +
"." + Twine(Patch));
3493 if (Opts.IgnoreXCOFFVisibility)
3494 GenerateArg(Consumer, OPT_mignore_xcoff_visibility);
3503 if (Opts.MSCompatibilityVersion != 0) {
3504 unsigned Major = Opts.MSCompatibilityVersion / 10000000;
3505 unsigned Minor = (Opts.MSCompatibilityVersion / 100000) % 100;
3506 unsigned Subminor = Opts.MSCompatibilityVersion % 100000;
3507 GenerateArg(Consumer, OPT_fms_compatibility_version,
3508 Twine(Major) +
"." + Twine(Minor) +
"." + Twine(Subminor));
3511 if ((!Opts.GNUMode && !Opts.MSVCCompat && !Opts.CPlusPlus17 && !Opts.C23) ||
3513 if (!Opts.Trigraphs)
3520 if (Opts.Blocks && !(Opts.OpenCL && Opts.OpenCLVersion == 200))
3523 if (Opts.ConvergentFunctions &&
3524 !(Opts.OpenCL || (Opts.CUDA && Opts.CUDAIsDevice) || Opts.SYCLIsDevice ||
3528 if (Opts.NoBuiltin && !Opts.Freestanding)
3531 if (!Opts.NoBuiltin)
3535 if (Opts.LongDoubleSize == 128)
3537 else if (Opts.LongDoubleSize == 64)
3539 else if (Opts.LongDoubleSize == 80)
3546 if (Opts.OpenMP && !Opts.OpenMPSimd) {
3549 if (Opts.OpenMP != 51)
3550 GenerateArg(Consumer, OPT_fopenmp_version_EQ, Twine(Opts.OpenMP));
3552 if (!Opts.OpenMPUseTLS)
3555 if (Opts.OpenMPIsTargetDevice)
3556 GenerateArg(Consumer, OPT_fopenmp_is_target_device);
3558 if (Opts.OpenMPIRBuilder)
3559 GenerateArg(Consumer, OPT_fopenmp_enable_irbuilder);
3562 if (Opts.OpenMPSimd) {
3565 if (Opts.OpenMP != 51)
3566 GenerateArg(Consumer, OPT_fopenmp_version_EQ, Twine(Opts.OpenMP));
3569 if (Opts.OpenMPThreadSubscription)
3570 GenerateArg(Consumer, OPT_fopenmp_assume_threads_oversubscription);
3572 if (Opts.OpenMPTeamSubscription)
3573 GenerateArg(Consumer, OPT_fopenmp_assume_teams_oversubscription);
3575 if (Opts.OpenMPTargetDebug != 0)
3576 GenerateArg(Consumer, OPT_fopenmp_target_debug_EQ,
3577 Twine(Opts.OpenMPTargetDebug));
3579 if (Opts.OpenMPCUDANumSMs != 0)
3580 GenerateArg(Consumer, OPT_fopenmp_cuda_number_of_sm_EQ,
3581 Twine(Opts.OpenMPCUDANumSMs));
3583 if (Opts.OpenMPCUDABlocksPerSM != 0)
3584 GenerateArg(Consumer, OPT_fopenmp_cuda_blocks_per_sm_EQ,
3585 Twine(Opts.OpenMPCUDABlocksPerSM));
3587 if (Opts.OpenMPCUDAReductionBufNum != 1024)
3588 GenerateArg(Consumer, OPT_fopenmp_cuda_teams_reduction_recs_num_EQ,
3589 Twine(Opts.OpenMPCUDAReductionBufNum));
3592 std::string Targets;
3593 llvm::raw_string_ostream OS(Targets);
3596 [&OS](
const llvm::Triple &
T) { OS << T.str(); },
",");
3597 GenerateArg(Consumer, OPT_fopenmp_targets_EQ, OS.str());
3603 if (Opts.OpenMPCUDAMode)
3623 GenerateArg(Consumer, OPT_ffp_contract,
"fast-honor-pragmas");
3626 GenerateArg(Consumer, OPT_fsanitize_EQ, Sanitizer);
3630 GenerateArg(Consumer, OPT_fsanitize_ignorelist_EQ, F);
3632 switch (Opts.getClangABICompat()) {
3634 GenerateArg(Consumer, OPT_fclang_abi_compat_EQ,
"3.8");
3637 GenerateArg(Consumer, OPT_fclang_abi_compat_EQ,
"4.0");
3640 GenerateArg(Consumer, OPT_fclang_abi_compat_EQ,
"6.0");
3643 GenerateArg(Consumer, OPT_fclang_abi_compat_EQ,
"7.0");
3646 GenerateArg(Consumer, OPT_fclang_abi_compat_EQ,
"9.0");
3649 GenerateArg(Consumer, OPT_fclang_abi_compat_EQ,
"11.0");
3652 GenerateArg(Consumer, OPT_fclang_abi_compat_EQ,
"12.0");
3655 GenerateArg(Consumer, OPT_fclang_abi_compat_EQ,
"14.0");
3658 GenerateArg(Consumer, OPT_fclang_abi_compat_EQ,
"15.0");
3661 GenerateArg(Consumer, OPT_fclang_abi_compat_EQ,
"17.0");
3664 GenerateArg(Consumer, OPT_fclang_abi_compat_EQ,
"18.0");
3670 if (Opts.getSignReturnAddressScope() ==
3672 GenerateArg(Consumer, OPT_msign_return_address_EQ,
"all");
3673 else if (Opts.getSignReturnAddressScope() ==
3675 GenerateArg(Consumer, OPT_msign_return_address_EQ,
"non-leaf");
3677 if (Opts.getSignReturnAddressKey() ==
3679 GenerateArg(Consumer, OPT_msign_return_address_key_EQ,
"b_key");
3685 if (Opts.RelativeCXXABIVTables)
3686 GenerateArg(Consumer, OPT_fexperimental_relative_cxx_abi_vtables);
3688 GenerateArg(Consumer, OPT_fno_experimental_relative_cxx_abi_vtables);
3696 GenerateArg(Consumer, OPT_fmacro_prefix_map_EQ, MP.first +
"=" + MP.second);
3702bool CompilerInvocation::ParseLangArgs(
LangOptions &Opts, ArgList &Args,
3704 std::vector<std::string> &Includes,
3714 if (Args.hasArg(OPT_fobjc_arc))
3715 Opts.ObjCAutoRefCount = 1;
3719 Opts.PIE = Args.hasArg(OPT_pic_is_pie);
3731 if (
const Arg *A = Args.getLastArg(OPT_std_EQ)) {
3734 Diags.
Report(diag::err_drv_invalid_value)
3735 << A->getAsString(Args) << A->getValue();
3737 for (
unsigned KindValue = 0;
3743 auto Diag = Diags.
Report(diag::note_drv_use_standard);
3744 Diag <<
Std.getName() <<
Std.getDescription();
3745 unsigned NumAliases = 0;
3746#define LANGSTANDARD(id, name, lang, desc, features)
3747#define LANGSTANDARD_ALIAS(id, alias) \
3748 if (KindValue == LangStandard::lang_##id) ++NumAliases;
3749#define LANGSTANDARD_ALIAS_DEPR(id, alias)
3750#include "clang/Basic/LangStandards.def"
3752#define LANGSTANDARD(id, name, lang, desc, features)
3753#define LANGSTANDARD_ALIAS(id, alias) \
3754 if (KindValue == LangStandard::lang_##id) Diag << alias;
3755#define LANGSTANDARD_ALIAS_DEPR(id, alias)
3756#include "clang/Basic/LangStandards.def"
3764 Diags.
Report(diag::err_drv_argument_not_allowed_with)
3772 if (
const Arg *A = Args.getLastArg(OPT_cl_std_EQ)) {
3774 = llvm::StringSwitch<LangStandard::Kind>(A->getValue())
3775 .Cases(
"cl",
"CL", LangStandard::lang_opencl10)
3776 .Cases(
"cl1.0",
"CL1.0", LangStandard::lang_opencl10)
3777 .Cases(
"cl1.1",
"CL1.1", LangStandard::lang_opencl11)
3778 .Cases(
"cl1.2",
"CL1.2", LangStandard::lang_opencl12)
3779 .Cases(
"cl2.0",
"CL2.0", LangStandard::lang_opencl20)
3780 .Cases(
"cl3.0",
"CL3.0", LangStandard::lang_opencl30)
3781 .Cases(
"clc++",
"CLC++", LangStandard::lang_openclcpp10)
3782 .Cases(
"clc++1.0",
"CLC++1.0", LangStandard::lang_openclcpp10)
3783 .Cases(
"clc++2021",
"CLC++2021", LangStandard::lang_openclcpp2021)
3787 Diags.
Report(diag::err_drv_invalid_value)
3788 << A->getAsString(Args) << A->getValue();
3791 LangStd = OpenCLLangStd;
3795 Opts.IncludeDefaultHeader = Args.hasArg(OPT_finclude_default_header);
3796 Opts.DeclareOpenCLBuiltins = Args.hasArg(OPT_fdeclare_opencl_builtins);
3804#define LANG_OPTION_WITH_MARSHALLING(...) \
3805 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
3806#include "clang/Driver/Options.inc"
3807#undef LANG_OPTION_WITH_MARSHALLING
3809 if (
const Arg *A = Args.getLastArg(OPT_fcf_protection_EQ)) {
3810 StringRef Name = A->getValue();
3811 if (Name ==
"full" || Name ==
"branch") {
3812 Opts.CFProtectionBranch = 1;
3816 if ((Args.hasArg(OPT_fsycl_is_device) || Args.hasArg(OPT_fsycl_is_host)) &&
3817 !Args.hasArg(OPT_sycl_std_EQ)) {
3827 if (Arg *arg = Args.getLastArg(OPT_fobjc_runtime_EQ)) {
3828 StringRef value =
arg->getValue();
3830 Diags.
Report(diag::err_drv_unknown_objc_runtime) << value;
3833 if (Args.hasArg(OPT_fobjc_gc_only))
3835 else if (Args.hasArg(OPT_fobjc_gc))
3837 else if (Args.hasArg(OPT_fobjc_arc)) {
3838 Opts.ObjCAutoRefCount = 1;
3840 Diags.
Report(diag::err_arc_unsupported_on_runtime);
3847 if (Args.hasArg(OPT_fobjc_runtime_has_weak))
3848 Opts.ObjCWeakRuntime = 1;
3854 if (
auto weakArg = Args.getLastArg(OPT_fobjc_weak, OPT_fno_objc_weak)) {
3855 if (!weakArg->getOption().matches(OPT_fobjc_weak)) {
3856 assert(!Opts.ObjCWeak);
3858 Diags.
Report(diag::err_objc_weak_with_gc);
3859 }
else if (!Opts.ObjCWeakRuntime) {
3860 Diags.
Report(diag::err_objc_weak_unsupported);
3864 }
else if (Opts.ObjCAutoRefCount) {
3865 Opts.ObjCWeak = Opts.ObjCWeakRuntime;
3868 if (Args.hasArg(OPT_fobjc_subscripting_legacy_runtime))
3869 Opts.ObjCSubscriptingLegacyRuntime =
3873 if (Arg *A = Args.getLastArg(options::OPT_fgnuc_version_EQ)) {
3876 VersionTuple GNUCVer;
3877 bool Invalid = GNUCVer.tryParse(A->getValue());
3878 unsigned Major = GNUCVer.getMajor();
3879 unsigned Minor = GNUCVer.getMinor().value_or(0);
3880 unsigned Patch = GNUCVer.getSubminor().value_or(0);
3881 if (
Invalid || GNUCVer.getBuild() || Minor >= 100 || Patch >= 100) {
3882 Diags.
Report(diag::err_drv_invalid_value)
3883 << A->getAsString(Args) << A->getValue();
3885 Opts.GNUCVersion = Major * 100 * 100 + Minor * 100 + Patch;
3888 if (
T.isOSAIX() && (Args.hasArg(OPT_mignore_xcoff_visibility)))
3889 Opts.IgnoreXCOFFVisibility = 1;
3891 if (Args.hasArg(OPT_ftrapv)) {
3895 std::string(Args.getLastArgValue(OPT_ftrapv_handler));
3897 else if (Args.hasArg(OPT_fwrapv))
3900 Opts.MSCompatibilityVersion = 0;
3901 if (
const Arg *A = Args.getLastArg(OPT_fms_compatibility_version)) {
3903 if (VT.tryParse(A->getValue()))
3904 Diags.
Report(diag::err_drv_invalid_value) << A->getAsString(Args)
3906 Opts.MSCompatibilityVersion = VT.getMajor() * 10000000 +
3907 VT.getMinor().value_or(0) * 100000 +
3908 VT.getSubminor().value_or(0);
3916 (!Opts.GNUMode && !Opts.MSVCCompat && !Opts.CPlusPlus17 && !Opts.C23) ||
3919 Args.hasFlag(OPT_ftrigraphs, OPT_fno_trigraphs, Opts.Trigraphs);
3921 Opts.Blocks = Args.hasArg(OPT_fblocks) || (Opts.OpenCL
3922 && Opts.OpenCLVersion == 200);
3924 Opts.ConvergentFunctions = Args.hasArg(OPT_fconvergent_functions) ||
3925 Opts.OpenCL || (Opts.CUDA && Opts.CUDAIsDevice) ||
3926 Opts.SYCLIsDevice || Opts.HLSL;
3928 Opts.NoBuiltin = Args.hasArg(OPT_fno_builtin) || Opts.Freestanding;
3929 if (!Opts.NoBuiltin)
3931 if (Arg *A = Args.getLastArg(options::OPT_LongDouble_Group)) {
3932 if (A->getOption().matches(options::OPT_mlong_double_64))
3933 Opts.LongDoubleSize = 64;
3934 else if (A->getOption().matches(options::OPT_mlong_double_80))
3935 Opts.LongDoubleSize = 80;
3936 else if (A->getOption().matches(options::OPT_mlong_double_128))
3937 Opts.LongDoubleSize = 128;
3939 Opts.LongDoubleSize = 0;
3941 if (Opts.FastRelaxedMath || Opts.CLUnsafeMath)
3947 if (Arg *A = Args.getLastArg(OPT_mrtd)) {
3949 Diags.
Report(diag::err_drv_argument_not_allowed_with)
3950 << A->getSpelling() <<
"-fdefault-calling-conv";
3952 switch (
T.getArch()) {
3953 case llvm::Triple::x86:
3956 case llvm::Triple::m68k:
3960 Diags.
Report(diag::err_drv_argument_not_allowed_with)
3961 << A->getSpelling() <<
T.getTriple();
3967 Opts.OpenMP = Args.hasArg(OPT_fopenmp) ? 51 : 0;
3969 bool IsSimdSpecified =
3970 Args.hasFlag(options::OPT_fopenmp_simd, options::OPT_fno_openmp_simd,
3972 Opts.OpenMPSimd = !Opts.OpenMP && IsSimdSpecified;
3974 Opts.OpenMP && !Args.hasArg(options::OPT_fnoopenmp_use_tls);
3975 Opts.OpenMPIsTargetDevice =
3976 Opts.OpenMP && Args.hasArg(options::OPT_fopenmp_is_target_device);
3977 Opts.OpenMPIRBuilder =
3978 Opts.OpenMP && Args.hasArg(options::OPT_fopenmp_enable_irbuilder);
3979 bool IsTargetSpecified =
3980 Opts.OpenMPIsTargetDevice || Args.hasArg(options::OPT_fopenmp_targets_EQ);
3982 Opts.ConvergentFunctions =
3983 Opts.ConvergentFunctions || Opts.OpenMPIsTargetDevice;
3985 if (Opts.OpenMP || Opts.OpenMPSimd) {
3987 Args, OPT_fopenmp_version_EQ,
3988 (IsSimdSpecified || IsTargetSpecified) ? 51 : Opts.OpenMP, Diags))
3989 Opts.OpenMP = Version;
3992 if (!Opts.OpenMPIsTargetDevice) {
3993 switch (
T.getArch()) {
3997 case llvm::Triple::nvptx:
3998 case llvm::Triple::nvptx64:
3999 Diags.
Report(diag::err_drv_omp_host_target_not_supported) <<
T.str();
4007 if ((Opts.OpenMPIsTargetDevice && (
T.isNVPTX() ||
T.isAMDGCN())) ||
4008 Opts.OpenCLCPlusPlus) {
4010 Opts.Exceptions = 0;
4011 Opts.CXXExceptions = 0;
4013 if (Opts.OpenMPIsTargetDevice &&
T.isNVPTX()) {
4014 Opts.OpenMPCUDANumSMs =
4016 Opts.OpenMPCUDANumSMs, Diags);
4017 Opts.OpenMPCUDABlocksPerSM =
4019 Opts.OpenMPCUDABlocksPerSM, Diags);
4021 Args, options::OPT_fopenmp_cuda_teams_reduction_recs_num_EQ,
4022 Opts.OpenMPCUDAReductionBufNum, Diags);
4027 if (Opts.OpenMPIsTargetDevice && (Args.hasArg(OPT_fopenmp_target_debug) ||
4028 Args.hasArg(OPT_fopenmp_target_debug_EQ))) {
4030 Args, OPT_fopenmp_target_debug_EQ, Opts.OpenMPTargetDebug, Diags);
4031 if (!Opts.OpenMPTargetDebug && Args.hasArg(OPT_fopenmp_target_debug))
4032 Opts.OpenMPTargetDebug = 1;
4035 if (Opts.OpenMPIsTargetDevice) {
4036 if (Args.hasArg(OPT_fopenmp_assume_teams_oversubscription))
4037 Opts.OpenMPTeamSubscription =
true;
4038 if (Args.hasArg(OPT_fopenmp_assume_threads_oversubscription))
4039 Opts.OpenMPThreadSubscription =
true;
4043 if (Arg *A = Args.getLastArg(options::OPT_fopenmp_targets_EQ)) {
4044 enum ArchPtrSize { Arch16Bit, Arch32Bit, Arch64Bit };
4045 auto getArchPtrSize = [](
const llvm::Triple &
T) {
4046 if (
T.isArch16Bit())
4048 if (
T.isArch32Bit())
4050 assert(
T.isArch64Bit() &&
"Expected 64-bit architecture");
4054 for (
unsigned i = 0; i < A->getNumValues(); ++i) {
4055 llvm::Triple TT(A->getValue(i));
4057 if (TT.getArch() == llvm::Triple::UnknownArch ||
4058 !(TT.getArch() == llvm::Triple::aarch64 || TT.isPPC() ||
4059 TT.getArch() == llvm::Triple::systemz ||
4060 TT.getArch() == llvm::Triple::nvptx ||
4061 TT.getArch() == llvm::Triple::nvptx64 ||
4062 TT.getArch() == llvm::Triple::amdgcn ||
4063 TT.getArch() == llvm::Triple::x86 ||
4064 TT.getArch() == llvm::Triple::x86_64))
4065 Diags.
Report(diag::err_drv_invalid_omp_target) << A->getValue(i);
4066 else if (getArchPtrSize(
T) != getArchPtrSize(TT))
4067 Diags.
Report(diag::err_drv_incompatible_omp_arch)
4068 << A->getValue(i) <<
T.str();
4076 if (Arg *A = Args.getLastArg(options::OPT_fopenmp_host_ir_file_path)) {
4079 Diags.
Report(diag::err_drv_omp_host_ir_file_not_found)
4084 Opts.OpenMPCUDAMode = Opts.OpenMPIsTargetDevice &&
4085 (
T.isNVPTX() ||
T.isAMDGCN()) &&
4086 Args.hasArg(options::OPT_fopenmp_cuda_mode);
4089 if (Args.hasArg(options::OPT_fopenacc)) {
4090 Opts.OpenACC =
true;
4092 if (Arg *A = Args.getLastArg(options::OPT_openacc_macro_override))
4099 Opts.Optimize = Opt != 0;
4100 Opts.OptimizeSize = OptSize != 0;
4105 Opts.NoInlineDefine = !Opts.Optimize;
4106 if (Arg *InlineArg = Args.getLastArg(
4107 options::OPT_finline_functions, options::OPT_finline_hint_functions,
4108 options::OPT_fno_inline_functions, options::OPT_fno_inline))
4109 if (InlineArg->getOption().matches(options::OPT_fno_inline))
4110 Opts.NoInlineDefine =
true;
4112 if (Arg *A = Args.getLastArg(OPT_ffp_contract)) {
4113 StringRef Val = A->getValue();
4116 else if (Val ==
"on")
4118 else if (Val ==
"off")
4120 else if (Val ==
"fast-honor-pragmas")
4123 Diags.
Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Val;
4129 Opts.
NoSanitizeFiles = Args.getAllArgValues(OPT_fsanitize_ignorelist_EQ);
4130 std::vector<std::string> systemIgnorelists =
4131 Args.getAllArgValues(OPT_fsanitize_system_ignorelist_EQ);
4133 systemIgnorelists.begin(),
4134 systemIgnorelists.end());
4136 if (Arg *A = Args.getLastArg(OPT_fclang_abi_compat_EQ)) {
4139 StringRef Ver = A->getValue();
4140 std::pair<StringRef, StringRef> VerParts = Ver.split(
'.');
4141 unsigned Major, Minor = 0;
4145 if (!VerParts.first.starts_with(
"0") &&
4146 !VerParts.first.getAsInteger(10, Major) && 3 <= Major &&
4147 Major <= CLANG_VERSION_MAJOR &&
4149 ? VerParts.second.size() == 1 &&
4150 !VerParts.second.getAsInteger(10, Minor)
4151 : VerParts.first.size() == Ver.size() || VerParts.second ==
"0")) {
4153 if (Major == 3 && Minor <= 8)
4155 else if (Major <= 4)
4157 else if (Major <= 6)
4159 else if (Major <= 7)
4161 else if (Major <= 9)
4163 else if (Major <= 11)
4165 else if (Major <= 12)
4167 else if (Major <= 14)
4169 else if (Major <= 15)
4171 else if (Major <= 17)
4173 else if (Major <= 18)
4175 }
else if (Ver !=
"latest") {
4176 Diags.
Report(diag::err_drv_invalid_value)
4177 << A->getAsString(Args) << A->getValue();
4181 if (Arg *A = Args.getLastArg(OPT_msign_return_address_EQ)) {
4182 StringRef SignScope = A->getValue();
4184 if (SignScope.equals_insensitive(
"none"))
4185 Opts.setSignReturnAddressScope(
4187 else if (SignScope.equals_insensitive(
"all"))
4188 Opts.setSignReturnAddressScope(
4190 else if (SignScope.equals_insensitive(
"non-leaf"))
4191 Opts.setSignReturnAddressScope(
4194 Diags.
Report(diag::err_drv_invalid_value)
4195 << A->getAsString(Args) << SignScope;
4197 if (Arg *A = Args.getLastArg(OPT_msign_return_address_key_EQ)) {
4198 StringRef SignKey = A->getValue();
4199 if (!SignScope.empty() && !SignKey.empty()) {
4200 if (SignKey ==
"a_key")
4201 Opts.setSignReturnAddressKey(
4203 else if (SignKey ==
"b_key")
4204 Opts.setSignReturnAddressKey(
4207 Diags.
Report(diag::err_drv_invalid_value)
4208 << A->getAsString(Args) << SignKey;
4214 StringRef
CXXABI = Args.getLastArgValue(OPT_fcxx_abi_EQ);
4221 Diags.
Report(diag::err_unsupported_cxx_abi) <<
CXXABI <<
T.str();
4227 Opts.RelativeCXXABIVTables =
4228 Args.hasFlag(options::OPT_fexperimental_relative_cxx_abi_vtables,
4229 options::OPT_fno_experimental_relative_cxx_abi_vtables,
4233 bool HasRTTI = !Args.hasArg(options::OPT_fno_rtti);
4234 Opts.OmitVTableRTTI =
4235 Args.hasFlag(options::OPT_fexperimental_omit_vtable_rtti,
4236 options::OPT_fno_experimental_omit_vtable_rtti,
false);
4237 if (Opts.OmitVTableRTTI && HasRTTI)
4238 Diags.
Report(diag::err_drv_using_omit_rtti_component_without_no_rtti);
4240 for (
const auto &A : Args.getAllArgValues(OPT_fmacro_prefix_map_EQ)) {
4241 auto Split = StringRef(A).split(
'=');
4243 {std::string(
Split.first), std::string(
Split.second)});
4247 !Args.getLastArg(OPT_fno_file_reproducible) &&
4248 (Args.getLastArg(OPT_ffile_compilation_dir_EQ) ||
4249 Args.getLastArg(OPT_fmacro_prefix_map_EQ) ||
4250 Args.getLastArg(OPT_ffile_reproducible));
4253 if (Arg *A = Args.getLastArg(options::OPT_mvscale_min_EQ)) {
4255 if (StringRef(A->getValue()).getAsInteger(10, VScaleMin) || VScaleMin == 0)
4256 Diags.
Report(diag::err_cc1_unbounded_vscale_min);
4259 if (
const Arg *A = Args.getLastArg(OPT_frandomize_layout_seed_file_EQ)) {
4260 std::ifstream SeedFile(A->getValue(0));
4262 if (!SeedFile.is_open())
4263 Diags.
Report(diag::err_drv_cannot_open_randomize_layout_seed_file)
4269 if (
const Arg *A = Args.getLastArg(OPT_frandomize_layout_seed_EQ))
4276 if (
T.isDXIL() ||
T.isSPIRVLogical()) {
4278 enum { OS, Environment };
4280 int ExpectedOS =
T.isSPIRVLogical() ? VulkanEnv : ShaderModel;
4282 if (
T.getOSName().empty()) {
4283 Diags.
Report(diag::err_drv_hlsl_bad_shader_required_in_target)
4284 << ExpectedOS << OS <<
T.str();
4285 }
else if (
T.getEnvironmentName().empty()) {
4286 Diags.
Report(diag::err_drv_hlsl_bad_shader_required_in_target)
4288 }
else if (!
T.isShaderStageEnvironment()) {
4289 Diags.
Report(diag::err_drv_hlsl_bad_shader_unsupported)
4294 if (!
T.isShaderModelOS() ||
T.getOSVersion() == VersionTuple(0)) {
4295 Diags.
Report(diag::err_drv_hlsl_bad_shader_unsupported)
4296 << ShaderModel <<
T.getOSName() <<
T.str();
4301 if (Args.getLastArg(OPT_fnative_half_type)) {
4304 if (!(Opts.
LangStd >= LangStandard::lang_hlsl2018 &&
4305 T.getOSVersion() >= VersionTuple(6, 2)))
4306 Diags.
Report(diag::err_drv_hlsl_16bit_types_unsupported)
4307 <<
"-enable-16bit-types" <<
true <<
Std.getName()
4308 <<
T.getOSVersion().getAsString();
4310 }
else if (
T.isSPIRVLogical()) {
4311 if (!
T.isVulkanOS() ||
T.getVulkanVersion() == VersionTuple(0)) {
4312 Diags.
Report(diag::err_drv_hlsl_bad_shader_unsupported)
4313 << VulkanEnv <<
T.getOSName() <<
T.str();
4315 if (Args.getLastArg(OPT_fnative_half_type)) {
4318 if (!(Opts.
LangStd >= LangStandard::lang_hlsl2018))
4319 Diags.
Report(diag::err_drv_hlsl_16bit_types_unsupported)
4320 <<
"-fnative-half-type" <<
false <<
Std.getName();
4323 llvm_unreachable(
"expected DXIL or SPIR-V target");
4326 Diags.
Report(diag::err_drv_hlsl_unsupported_target) <<
T.str();
4375 llvm_unreachable(
"invalid frontend action");
4385#define PREPROCESSOR_OPTION_WITH_MARSHALLING(...) \
4386 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
4387#include "clang/Driver/Options.inc"
4388#undef PREPROCESSOR_OPTION_WITH_MARSHALLING
4391 GenerateArg(Consumer, OPT_pch_through_hdrstop_use);
4394 GenerateArg(Consumer, OPT_error_on_deserialized_pch_decl, D);
4401 for (
const auto &M : Opts.
Macros) {
4404 if (M.first ==
"__CET__=1" && !M.second &&
4405 !CodeGenOpts.CFProtectionReturn && CodeGenOpts.CFProtectionBranch)
4407 if (M.first ==
"__CET__=2" && !M.second && CodeGenOpts.CFProtectionReturn &&
4408 !CodeGenOpts.CFProtectionBranch)
4410 if (M.first ==
"__CET__=3" && !M.second && CodeGenOpts.CFProtectionReturn &&
4411 CodeGenOpts.CFProtectionBranch)
4414 GenerateArg(Consumer, M.second ? OPT_U : OPT_D, M.first);
4417 for (
const auto &I : Opts.
Includes) {
4420 if (LangOpts.OpenCL && LangOpts.IncludeDefaultHeader &&
4421 ((LangOpts.DeclareOpenCLBuiltins && I ==
"opencl-c-base.h") ||
4426 if (LangOpts.HLSL && I ==
"hlsl.h")
4436 GenerateArg(Consumer, OPT_remap_file, RF.first +
";" + RF.second);
4442 GenerateArg(Consumer, OPT_fdefine_target_os_macros);
4456#define PREPROCESSOR_OPTION_WITH_MARSHALLING(...) \
4457 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
4458#include "clang/Driver/Options.inc"
4459#undef PREPROCESSOR_OPTION_WITH_MARSHALLING
4461 Opts.
PCHWithHdrStop = Args.hasArg(OPT_pch_through_hdrstop_create) ||
4462 Args.hasArg(OPT_pch_through_hdrstop_use);
4464 for (
const auto *A : Args.filtered(OPT_error_on_deserialized_pch_decl))
4467 if (
const Arg *A = Args.getLastArg(OPT_preamble_bytes_EQ)) {
4468 StringRef
Value(A->getValue());
4469 size_t Comma =
Value.find(
',');
4471 unsigned EndOfLine = 0;
4473 if (Comma == StringRef::npos ||
4474 Value.substr(0, Comma).getAsInteger(10, Bytes) ||
4475 Value.substr(Comma + 1).getAsInteger(10, EndOfLine))
4476 Diags.
Report(diag::err_drv_preamble_format);
4484 if (
const Arg *A = Args.getLastArg(OPT_fcf_protection_EQ)) {
4485 StringRef Name = A->getValue();
4486 if (Name ==
"branch")
4488 else if (Name ==
"return")
4490 else if (Name ==
"full")
4495 for (
const auto *A : Args.filtered(OPT_D, OPT_U)) {
4496 if (A->getOption().matches(OPT_D))
4503 for (
const auto *A : Args.filtered(OPT_include))
4504 Opts.
Includes.emplace_back(A->getValue());
4506 for (
const auto *A : Args.filtered(OPT_chain_include))
4509 for (
const auto *A : Args.filtered(OPT_remap_file)) {
4510 std::pair<StringRef, StringRef> Split = StringRef(A->getValue()).split(
';');
4512 if (Split.second.empty()) {
4513 Diags.
Report(diag::err_drv_invalid_remap_file) << A->getAsString(Args);
4520 if (
const Arg *A = Args.getLastArg(OPT_source_date_epoch)) {
4521 StringRef Epoch = A->getValue();
4525 const uint64_t MaxTimestamp =
4526 std::min<uint64_t>(std::numeric_limits<time_t>::max(), 253402300799);
4528 if (Epoch.getAsInteger(10,
V) ||
V > MaxTimestamp) {
4529 Diags.
Report(diag::err_fe_invalid_source_date_epoch)
4530 << Epoch << MaxTimestamp;
4543 Args.hasFlag(OPT_fdefine_target_os_macros,
4555#define PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING(...) \
4556 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
4557#include "clang/Driver/Options.inc"
4558#undef PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING
4576#define PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING(...) \
4577 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
4578#include "clang/Driver/Options.inc"
4579#undef PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING
4582 Opts.
ShowMacros = Args.hasArg(OPT_dM) || Args.hasArg(OPT_dD);
4591#define TARGET_OPTION_WITH_MARSHALLING(...) \
4592 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
4593#include "clang/Driver/Options.inc"
4594#undef TARGET_OPTION_WITH_MARSHALLING
4600 GenerateArg(Consumer, OPT_darwin_target_variant_sdk_version_EQ,
4610#define TARGET_OPTION_WITH_MARSHALLING(...) \
4611 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
4612#include "clang/Driver/Options.inc"
4613#undef TARGET_OPTION_WITH_MARSHALLING
4615 if (Arg *A = Args.getLastArg(options::OPT_target_sdk_version_EQ)) {
4616 llvm::VersionTuple Version;
4617 if (Version.tryParse(A->getValue()))
4618 Diags.
Report(diag::err_drv_invalid_value)
4619 << A->getAsString(Args) << A->getValue();
4624 Args.getLastArg(options::OPT_darwin_target_variant_sdk_version_EQ)) {
4625 llvm::VersionTuple Version;
4626 if (Version.tryParse(A->getValue()))
4627 Diags.
Report(diag::err_drv_invalid_value)
4628 << A->getAsString(Args) << A->getValue();
4636bool CompilerInvocation::CreateFromArgsImpl(
4644 unsigned MissingArgIndex, MissingArgCount;
4645 InputArgList Args = Opts.ParseArgs(CommandLineArgs, MissingArgIndex,
4646 MissingArgCount, VisibilityMask);
4650 if (MissingArgCount)
4651 Diags.
Report(diag::err_drv_missing_argument)
4652 << Args.getArgString(MissingArgIndex) << MissingArgCount;
4655 for (
const auto *A : Args.filtered(OPT_UNKNOWN)) {
4656 auto ArgString = A->getAsString(Args);
4657 std::string Nearest;
4658 if (Opts.findNearest(ArgString, Nearest, VisibilityMask) > 1)
4659 Diags.
Report(diag::err_drv_unknown_argument) << ArgString;
4661 Diags.
Report(diag::err_drv_unknown_argument_with_suggestion)
4662 << ArgString << Nearest;
4711 !
LangOpts.Sanitize.has(SanitizerKind::Address) &&
4712 !
LangOpts.Sanitize.has(SanitizerKind::KernelAddress) &&
4713 !
LangOpts.Sanitize.has(SanitizerKind::Memory) &&
4714 !
LangOpts.Sanitize.has(SanitizerKind::KernelMemory);
4727 Diags.
Report(diag::err_fe_dependency_file_requires_MT);
4733 Diags.
Report(diag::warn_drv_fine_grained_bitfield_accesses_ignored);
4747 Diags, llvm::vfs::getRealFileSystem());
4761 const char *Argv0) {
4767 return CreateFromArgsImpl(Invocation, CommandLineArgs, Diags, Argv0);
4771 Args.push_back(
"-cc1");
4774 Invocation, DummyInvocation, CommandLineArgs, Diags, Argv0);
4779 llvm::HashBuilder<llvm::MD5, llvm::endianness::native> HBuilder;
4792#define LANGOPT(Name, Bits, Default, Description) HBuilder.add(LangOpts->Name);
4793#define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
4794 HBuilder.add(static_cast<unsigned>(LangOpts->get##Name()));
4795#define BENIGN_LANGOPT(Name, Bits, Default, Description)
4796#define BENIGN_ENUM_LANGOPT(Name, Type, Bits, Default, Description)
4797#include "clang/Basic/LangOptions.def"
4802 HBuilder.addRange(
getLangOpts().CommentOpts.BlockCommandNames);
4819 StringRef MacroDef = Macro.first;
4821 llvm::CachedHashString(MacroDef.split(
'=').first)))
4825 HBuilder.add(Macro);
4841#define DIAGOPT(Name, Bits, Default) HBuilder.add(diagOpts.Name);
4842#define ENUM_DIAGOPT(Name, Type, Bits, Default) \
4843 HBuilder.add(diagOpts.get##Name());
4844#include "clang/Basic/DiagnosticOptions.def"
4854 ext->hashExtension(HBuilder);
4861 HBuilder.add(*Minor);
4862 if (
auto Subminor =
APINotesOpts.SwiftVersion.getSubminor())
4863 HBuilder.add(*Subminor);
4865 HBuilder.add(*Build);
4875#define DEBUGOPT(Name, Bits, Default) HBuilder.add(CodeGenOpts->Name);
4876#define VALUE_DEBUGOPT(Name, Bits, Default) HBuilder.add(CodeGenOpts->Name);
4877#define ENUM_DEBUGOPT(Name, Type, Bits, Default) \
4878 HBuilder.add(static_cast<unsigned>(CodeGenOpts->get##Name()));
4879#define BENIGN_DEBUGOPT(Name, Bits, Default)
4880#define BENIGN_VALUE_DEBUGOPT(Name, Bits, Default)
4881#define BENIGN_ENUM_DEBUGOPT(Name, Type, Bits, Default)
4882#include "clang/Basic/DebugOptions.def"
4889 if (!SanHash.
empty())
4890 HBuilder.add(SanHash.
Mask);
4892 llvm::MD5::MD5Result
Result;
4893 HBuilder.getHasher().final(
Result);
4895 return toString(llvm::APInt(64, Hash), 36,
false);
4923 std::vector<std::string> Args{
"-cc1"};
4925 [&Args](
const Twine &Arg) { Args.push_back(Arg.str()); });
4951 llvm::vfs::getRealFileSystem());
4959 Diags, std::move(BaseFS));
4965 if (VFSOverlayFiles.empty())
4970 for (
const auto &
File : VFSOverlayFiles) {
4971 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> Buffer =
4974 Diags.
Report(diag::err_missing_vfs_overlay_file) <<
File;
4979 std::move(Buffer.get()),
nullptr,
File,
4982 Diags.
Report(diag::err_invalid_vfs_overlay) <<
File;
Defines the Diagnostic-related interfaces.
Defines enum values for all the target-independent builtin functions.
static void getAllNoBuiltinFuncValues(ArgList &Args, std::vector< std::string > &Funcs)
static T extractMaskValue(T KeyPath)
static std::optional< IntTy > normalizeStringIntegral(OptSpecifier Opt, int, const ArgList &Args, DiagnosticsEngine &Diags)
static T mergeMaskValue(T KeyPath, U Value)
static std::optional< std::string > normalizeString(OptSpecifier Opt, int TableIndex, const ArgList &Args, DiagnosticsEngine &Diags)
static auto makeBooleanOptionNormalizer(bool Value, bool OtherValue, OptSpecifier OtherOpt)
static SmallVector< StringRef, 4 > serializeSanitizerKinds(SanitizerSet S)
static void parseXRayInstrumentationBundle(StringRef FlagName, StringRef Bundle, ArgList &Args, DiagnosticsEngine &D, XRayInstrSet &S)
static unsigned getOptimizationLevelSize(ArgList &Args)
static void GenerateFrontendArgs(const FrontendOptions &Opts, ArgumentConsumer Consumer, bool IsHeader)
static std::optional< SimpleEnumValue > findValueTableByValue(const SimpleEnumValueTable &Table, unsigned Value)
static bool ParseTargetArgs(TargetOptions &Opts, ArgList &Args, DiagnosticsEngine &Diags)
static auto makeFlagToValueNormalizer(T Value)
static void denormalizeStringVector(ArgumentConsumer Consumer, const Twine &Spelling, Option::OptionClass OptClass, unsigned TableIndex, const std::vector< std::string > &Values)
static CodeGenOptions::OptRemark ParseOptimizationRemark(DiagnosticsEngine &Diags, ArgList &Args, OptSpecifier OptEQ, StringRef Name)
Parse a remark command line argument.
static bool ParseFileSystemArgs(FileSystemOptions &Opts, const ArgList &Args, DiagnosticsEngine &Diags)
static constexpr bool is_uint64_t_convertible()
static void GeneratePointerAuthArgs(const LangOptions &Opts, ArgumentConsumer Consumer)
static std::optional< SimpleEnumValue > findValueTableByName(const SimpleEnumValueTable &Table, StringRef Name)
static std::optional< OptSpecifier > getProgramActionOpt(frontend::ActionKind ProgramAction)
Maps frontend action to command line option.
static bool parseDiagnosticLevelMask(StringRef FlagName, const std::vector< std::string > &Levels, DiagnosticsEngine &Diags, DiagnosticLevelMask &M)
static std::optional< bool > normalizeSimpleFlag(OptSpecifier Opt, unsigned TableIndex, const ArgList &Args, DiagnosticsEngine &Diags)
CompilerInvocation::ArgumentConsumer ArgumentConsumer
static void GenerateArg(ArgumentConsumer Consumer, llvm::opt::OptSpecifier OptSpecifier)
static void addDiagnosticArgs(ArgList &Args, OptSpecifier Group, OptSpecifier GroupWithValue, std::vector< std::string > &Diagnostics)
static bool ParseAnalyzerArgs(AnalyzerOptions &Opts, ArgList &Args, DiagnosticsEngine &Diags)
static void ParsePointerAuthArgs(LangOptions &Opts, ArgList &Args, DiagnosticsEngine &Diags)
static void parseAnalyzerConfigs(AnalyzerOptions &AnOpts, DiagnosticsEngine *Diags)
static void denormalizeSimpleEnum(ArgumentConsumer Consumer, const Twine &Spelling, Option::OptionClass OptClass, unsigned TableIndex, T Value)
static bool ParsePreprocessorArgs(PreprocessorOptions &Opts, ArgList &Args, DiagnosticsEngine &Diags, frontend::ActionKind Action, const FrontendOptions &FrontendOpts)
static std::optional< unsigned > normalizeSimpleEnum(OptSpecifier Opt, unsigned TableIndex, const ArgList &Args, DiagnosticsEngine &Diags)
static StringRef GetInputKindName(InputKind IK)
Get language name for given input kind.
static void initOption(AnalyzerOptions::ConfigTable &Config, DiagnosticsEngine *Diags, StringRef &OptionField, StringRef Name, StringRef DefaultVal)
static void denormalizeString(ArgumentConsumer Consumer, const Twine &Spelling, Option::OptionClass OptClass, unsigned TableIndex, T Value)
static std::optional< std::string > normalizeTriple(OptSpecifier Opt, int TableIndex, const ArgList &Args, DiagnosticsEngine &Diags)
llvm::function_ref< bool(CompilerInvocation &, ArrayRef< const char * >, DiagnosticsEngine &, const char *)> ParseFn
llvm::function_ref< void(CompilerInvocation &, SmallVectorImpl< const char * > &, CompilerInvocation::StringAllocator)> GenerateFn
static void GenerateMigratorArgs(const MigratorOptions &Opts, ArgumentConsumer Consumer)
static const auto & getFrontendActionTable()
Return a table that associates command line option specifiers with the frontend action.
static void GenerateTargetArgs(const TargetOptions &Opts, ArgumentConsumer Consumer)
static std::optional< frontend::ActionKind > getFrontendAction(OptSpecifier &Opt)
Maps command line option to frontend action.
static bool checkVerifyPrefixes(const std::vector< std::string > &VerifyPrefixes, DiagnosticsEngine &Diags)
static void denormalizeSimpleFlag(ArgumentConsumer Consumer, const Twine &Spelling, Option::OptionClass, unsigned,...)
The tblgen-erated code passes in a fifth parameter of an arbitrary type, but denormalizeSimpleFlags n...
static void GenerateAPINotesArgs(const APINotesOptions &Opts, ArgumentConsumer Consumer)
static std::optional< bool > normalizeSimpleNegativeFlag(OptSpecifier Opt, unsigned, const ArgList &Args, DiagnosticsEngine &)
static void GenerateFileSystemArgs(const FileSystemOptions &Opts, ArgumentConsumer Consumer)
static bool IsInputCompatibleWithStandard(InputKind IK, const LangStandard &S)
Check if input file kind and language standard are compatible.
static void denormalizeStringImpl(ArgumentConsumer Consumer, const Twine &Spelling, Option::OptionClass OptClass, unsigned, const Twine &Value)
static void setPGOUseInstrumentor(CodeGenOptions &Opts, const Twine &ProfileName, llvm::vfs::FileSystem &FS, DiagnosticsEngine &Diags)
static void denormalizeSimpleEnumImpl(ArgumentConsumer Consumer, const Twine &Spelling, Option::OptionClass OptClass, unsigned TableIndex, unsigned Value)
static void GeneratePreprocessorArgs(const PreprocessorOptions &Opts, ArgumentConsumer Consumer, const LangOptions &LangOpts, const FrontendOptions &FrontendOpts, const CodeGenOptions &CodeGenOpts)
static bool ParseHeaderSearchArgs(HeaderSearchOptions &Opts, ArgList &Args, DiagnosticsEngine &Diags, const std::string &WorkingDir)
static bool ParseFrontendArgs(FrontendOptions &Opts, ArgList &Args, DiagnosticsEngine &Diags, bool &IsHeaderFile)
static auto makeBooleanOptionDenormalizer(bool Value)
static void GeneratePreprocessorOutputArgs(const PreprocessorOutputOptions &Opts, ArgumentConsumer Consumer, frontend::ActionKind Action)
static bool isStrictlyPreprocessorAction(frontend::ActionKind Action)
static std::string serializeXRayInstrumentationBundle(const XRayInstrSet &S)
static bool ParseMigratorArgs(MigratorOptions &Opts, const ArgList &Args, DiagnosticsEngine &Diags)
static bool parseShowColorsArgs(const ArgList &Args, bool DefaultColor)
static T mergeForwardValue(T KeyPath, U Value)
static void ParseAPINotesArgs(APINotesOptions &Opts, ArgList &Args, DiagnosticsEngine &diags)
static bool ParseDependencyOutputArgs(DependencyOutputOptions &Opts, ArgList &Args, DiagnosticsEngine &Diags, frontend::ActionKind Action, bool ShowLineMarkers)
static Expected< std::optional< uint32_t > > parseToleranceOption(StringRef Arg)
static std::optional< std::vector< std::string > > normalizeStringVector(OptSpecifier Opt, int, const ArgList &Args, DiagnosticsEngine &)
static void GenerateAnalyzerArgs(const AnalyzerOptions &Opts, ArgumentConsumer Consumer)
static void GenerateOptimizationRemark(ArgumentConsumer Consumer, OptSpecifier OptEQ, StringRef Name, const CodeGenOptions::OptRemark &Remark)
Generate a remark argument. This is an inverse of ParseOptimizationRemark.
static bool ParsePreprocessorOutputArgs(PreprocessorOutputOptions &Opts, ArgList &Args, DiagnosticsEngine &Diags, frontend::ActionKind Action)
static bool RoundTrip(ParseFn Parse, GenerateFn Generate, CompilerInvocation &RealInvocation, CompilerInvocation &DummyInvocation, ArrayRef< const char * > CommandLineArgs, DiagnosticsEngine &Diags, const char *Argv0, bool CheckAgainstOriginalInvocation=false, bool ForceRoundTrip=false)
May perform round-trip of command line arguments.
static T extractForwardValue(T KeyPath)
static unsigned getOptimizationLevel(ArgList &Args, InputKind IK, DiagnosticsEngine &Diags)
static bool parseTestModuleFileExtensionArg(StringRef Arg, std::string &BlockName, unsigned &MajorVersion, unsigned &MinorVersion, bool &Hashed, std::string &UserInfo)
Parse the argument to the -ftest-module-file-extension command-line argument.
static void GenerateDependencyOutputArgs(const DependencyOutputOptions &Opts, ArgumentConsumer Consumer)
static StringRef getStringOption(AnalyzerOptions::ConfigTable &Config, StringRef OptionName, StringRef DefaultVal)
static bool FixupInvocation(CompilerInvocation &Invocation, DiagnosticsEngine &Diags, const ArgList &Args, InputKind IK)
static void parseSanitizerKinds(StringRef FlagName, const std::vector< std::string > &Sanitizers, DiagnosticsEngine &Diags, SanitizerSet &S)
static void GenerateHeaderSearchArgs(const HeaderSearchOptions &Opts, ArgumentConsumer Consumer)
Defines the clang::FileSystemOptions interface.
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified.
Defines the clang::LangOptions interface.
static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)
Produce a diagnostic highlighting some portion of a literal.
Defines types useful for describing an Objective-C runtime.
static std::string toString(const clang::SanitizerSet &Sanitizers)
Produce a string containing comma-separated names of sanitizers in Sanitizers set.
Defines the clang::SanitizerKind enum.
Defines the clang::SourceLocation class and associated facilities.
Defines the clang::TargetOptions class.
Defines version macros and version-related utility functions for Clang.
Defines the clang::Visibility enumeration and various utility functions.
Defines the clang::XRayInstrKind enum.
__DEVICE__ void * memcpy(void *__a, const void *__b, size_t __c)
Tracks various options which control how API notes are found and handled.
llvm::VersionTuple SwiftVersion
The Swift version which should be used for API notes.
std::vector< std::string > ModuleSearchPaths
The set of search paths where we API notes can be found for particular modules.
Stores options for the analyzer from the command line.
static std::vector< StringRef > getRegisteredPackages(bool IncludeExperimental=false)
Retrieves the list of packages generated from Checkers.td.
std::vector< std::pair< std::string, bool > > CheckersAndPackages
Pairs of checker/package name and enable/disable.
std::vector< std::string > SilencedCheckersAndPackages
Vector of checker/package names which will not emit warnings.
AnalysisDiagClients AnalysisDiagOpt
AnalysisConstraints AnalysisConstraintsOpt
ConfigTable Config
A key-value table of use-specified configuration values.
unsigned ShouldEmitErrorsOnInvalidConfigValue
AnalysisPurgeMode AnalysisPurgeOpt
bool isUnknownAnalyzerConfig(llvm::StringRef Name)
static std::vector< StringRef > getRegisteredCheckers(bool IncludeExperimental=false)
Retrieves the list of checkers generated from Checkers.td.
llvm::StringMap< std::string > ConfigTable
std::string FullCompilerInvocation
Store full compiler invocation for reproducible instructions in the generated report.
AnalysisInliningMode InliningMode
The mode of function selection used during inlining.
static bool isBuiltinFunc(llvm::StringRef Name)
Returns true if this is a libc/libm function without the '__builtin_' prefix.
Implements C++ ABI-specific semantic analysis functions.
CodeGenOptions - Track various options which control how the code is optimized and passed to the back...
llvm::SmallVector< std::pair< std::string, std::string >, 0 > CoveragePrefixMap
Prefix replacement map for source-based code coverage to remap source file paths in coverage mapping.
llvm::SmallVector< std::pair< std::string, std::string >, 0 > DebugPrefixMap
std::string OptRecordFile
The name of the file to which the backend should save YAML optimization records.
std::string BinutilsVersion
std::vector< BitcodeFileToLink > LinkBitcodeFiles
The files specified here are linked in to the module before optimizations.
std::optional< uint64_t > DiagnosticsHotnessThreshold
The minimum hotness value a diagnostic needs in order to be included in optimization diagnostics.
char CoverageVersion[4]
The version string to put into coverage files.
llvm::DenormalMode FPDenormalMode
The floating-point denormal mode to use.
std::string CoverageNotesFile
The filename with path we use for coverage notes files.
std::string ProfileInstrumentUsePath
Name of the profile file to use as input for -fprofile-instr-use.
std::string SampleProfileFile
Name of the profile file to use with -fprofile-sample-use.
uint64_t LargeDataThreshold
The code model-specific large data threshold to use (-mlarge-data-threshold).
std::string MemoryProfileOutput
Name of the profile file to use as output for with -fmemory-profile.
std::string CodeModel
The code model to use (-mcmodel).
std::string CoverageDataFile
The filename with path we use for coverage data files.
std::optional< uint32_t > DiagnosticsMisExpectTolerance
The maximum percentage profiling weights can deviate from the expected values in order to be included...
std::string StackUsageOutput
Name of the stack usage file (i.e., .su file) if user passes -fstack-usage.
std::string OptRecordPasses
The regex that filters the passes that should be saved to the optimization records.
std::string SaveTempsFilePrefix
Prefix to use for -save-temps output.
XRayInstrSet XRayInstrumentationBundle
Set of XRay instrumentation kinds to emit.
bool hasSanitizeCoverage() const
llvm::DenormalMode FP32DenormalMode
The floating-point denormal mode to use, for float.
SanitizerSet SanitizeTrap
Set of sanitizer checks that trap rather than diagnose.
SanitizerSet SanitizeRecover
Set of sanitizer checks that are non-fatal (i.e.
bool hasReducedDebugInfo() const
Check if type and variable info should be emitted.
OptRemark OptimizationRemark
Selected optimizations for which we should enable optimization remarks.
std::string ThinLTOIndexFile
Name of the function summary index file to use for ThinLTO function importing.
const char * Argv0
Executable and command-line used to create a given CompilerInvocation.
std::vector< std::string > NoBuiltinFuncs
A list of all -fno-builtin-* function names (e.g., memset).
std::vector< uint8_t > CmdArgs
List of backend command-line options for -fembed-bitcode.
OptRemark OptimizationRemarkAnalysis
Selected optimizations for which we should enable optimization analyses.
std::vector< std::string > CommandLineArgs
void resetNonModularOptions(StringRef ModuleFormat)
Reset all of the options that are not considered when building a module.
std::string OptRecordFormat
The format used for serializing remarks (default: YAML)
std::string DIBugsReportFilePath
The file to use for dumping bug report by Debugify for original debug info.
OptRemark OptimizationRemarkMissed
Selected optimizations for which we should enable missed optimization remarks.
The base class of CompilerInvocation.
std::shared_ptr< MigratorOptions > MigratorOpts
std::shared_ptr< PreprocessorOutputOptions > PreprocessorOutputOpts
Options controlling preprocessed output.
std::shared_ptr< APINotesOptions > APINotesOpts
Options controlling API notes.
std::shared_ptr< TargetOptions > TargetOpts
Options controlling the target.
const FrontendOptions & getFrontendOpts() const
const CodeGenOptions & getCodeGenOpts() const
llvm::function_ref< const char *(const Twine &)> StringAllocator
Command line generation.
const FileSystemOptions & getFileSystemOpts() const
std::shared_ptr< PreprocessorOptions > PPOpts
Options controlling the preprocessor (aside from #include handling).
const PreprocessorOutputOptions & getPreprocessorOutputOpts() const
std::vector< std::string > getCC1CommandLine() const
Generate cc1-compatible command line arguments from this instance, wrapping the result as a std::vect...
std::shared_ptr< FileSystemOptions > FSOpts
Options controlling file system operations.
const AnalyzerOptions & getAnalyzerOpts() const
const MigratorOptions & getMigratorOpts() const
void generateCC1CommandLine(llvm::SmallVectorImpl< const char * > &Args, StringAllocator SA) const
Generate cc1-compatible command line arguments from this instance.
CompilerInvocationBase & deep_copy_assign(const CompilerInvocationBase &X)
const DependencyOutputOptions & getDependencyOutputOpts() const
AnalyzerOptionsRef AnalyzerOpts
Options controlling the static analyzer.
IntrusiveRefCntPtr< DiagnosticOptions > DiagnosticOpts
Options controlling the diagnostic engine.
CompilerInvocationBase & shallow_copy_assign(const CompilerInvocationBase &X)
const TargetOptions & getTargetOpts() const
std::shared_ptr< CodeGenOptions > CodeGenOpts
Options controlling IRgen and the backend.
std::shared_ptr< LangOptions > LangOpts
Options controlling the language variant.
const APINotesOptions & getAPINotesOpts() const
const HeaderSearchOptions & getHeaderSearchOpts() const
std::shared_ptr< HeaderSearchOptions > HSOpts
Options controlling the #include directive.
const PreprocessorOptions & getPreprocessorOpts() const
const DiagnosticOptions & getDiagnosticOpts() const
const LangOptions & getLangOpts() const
Const getters.
std::shared_ptr< FrontendOptions > FrontendOpts
Options controlling the frontend itself.
llvm::function_ref< void(const Twine &)> ArgumentConsumer
std::shared_ptr< DependencyOutputOptions > DependencyOutputOpts
Options controlling dependency output.
Helper class for holding the data necessary to invoke the compiler.
PreprocessorOptions & getPreprocessorOpts()
void clearImplicitModuleBuildOptions()
Disable implicit modules and canonicalize options that are only used by implicit modules.
MigratorOptions & getMigratorOpts()
AnalyzerOptions & getAnalyzerOpts()
APINotesOptions & getAPINotesOpts()
static std::string GetResourcesPath(const char *Argv0, void *MainAddr)
Get the directory where the compiler headers reside, relative to the compiler binary (found by the pa...
static bool CreateFromArgs(CompilerInvocation &Res, ArrayRef< const char * > CommandLineArgs, DiagnosticsEngine &Diags, const char *Argv0=nullptr)
Create a compiler invocation from a list of input options.
LangOptions & getLangOpts()
Mutable getters.
static bool checkCC1RoundTrip(ArrayRef< const char * > Args, DiagnosticsEngine &Diags, const char *Argv0=nullptr)
Check that Args can be parsed and re-serialized without change, emiting diagnostics for any differenc...
DependencyOutputOptions & getDependencyOutputOpts()
CompilerInvocation()=default
void resetNonModularOptions()
Reset all of the options that are not considered when building a module.
FrontendOptions & getFrontendOpts()
std::string getModuleHash() const
Retrieve a module hash string that is suitable for uniquely identifying the conditions under which th...
FileSystemOptions & getFileSystemOpts()
CompilerInvocation & operator=(const CompilerInvocation &X)
CodeGenOptions & getCodeGenOpts()
std::shared_ptr< LangOptions > LangOpts
Base class internals.
TargetOptions & getTargetOpts()
HeaderSearchOptions & getHeaderSearchOpts()
DiagnosticOptions & getDiagnosticOpts()
PreprocessorOutputOptions & getPreprocessorOutputOpts()
Same as CompilerInvocation, but with copy-on-write optimization.
FrontendOptions & getMutFrontendOpts()
LangOptions & getMutLangOpts()
Mutable getters.
HeaderSearchOptions & getMutHeaderSearchOpts()
MigratorOptions & getMutMigratorOpts()
PreprocessorOptions & getMutPreprocessorOpts()
APINotesOptions & getMutAPINotesOpts()
PreprocessorOutputOptions & getMutPreprocessorOutputOpts()
CodeGenOptions & getMutCodeGenOpts()
TargetOptions & getMutTargetOpts()
FileSystemOptions & getMutFileSystemOpts()
AnalyzerOptions & getMutAnalyzerOpts()
DiagnosticOptions & getMutDiagnosticOpts()
DependencyOutputOptions & getMutDependencyOutputOpts()
DependencyOutputOptions - Options for controlling the compiler dependency file generation.
ShowIncludesDestination ShowIncludesDest
Destination of cl.exe style /showIncludes info.
HeaderIncludeFormatKind HeaderIncludeFormat
The format of header information.
std::string OutputFile
The file to write dependency output to.
HeaderIncludeFilteringKind HeaderIncludeFiltering
Determine whether header information should be filtered.
std::vector< std::string > Targets
A list of names to use as the targets in the dependency file; this list must contain at least one ent...
std::vector< std::pair< std::string, ExtraDepKind > > ExtraDeps
A list of extra dependencies (filename and kind) to be used for every target.
unsigned IncludeSystemHeaders
Include system header dependencies.
Used for handling and querying diagnostic IDs.
Options for controlling the compiler diagnostics engine.
std::vector< std::string > Remarks
The list of -R... options used to alter the diagnostic mappings, with the prefixes removed.
std::vector< std::string > Warnings
The list of -W... options used to alter the diagnostic mappings, with the prefixes removed.
std::vector< std::string > VerifyPrefixes
The prefixes for comment directives sought by -verify ("expected" by default).
std::string DiagnosticSerializationFile
The file to serialize diagnostics to (non-appending).
Concrete class used by the front-end to report problems and issues.
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
unsigned getCustomDiagID(Level L, const char(&FormatString)[N])
Return an ID for a diagnostic with the specified format string and level.
void setClient(DiagnosticConsumer *client, bool ShouldOwnClient=true)
Set the diagnostic client associated with this diagnostic object.
unsigned getNumErrors() const
bool isIgnored(unsigned DiagID, SourceLocation Loc) const
Determine whether the diagnostic is known to be ignored.
unsigned getNumWarnings() const
Keeps track of options that affect how file operations are performed.
std::string WorkingDir
If set, paths are resolved as if the working directory was set to the value of WorkingDir.
FrontendOptions - Options for controlling the behavior of the frontend.
InputKind DashX
The input kind, either specified via -x argument or deduced from the input file name.
std::vector< std::string > ModuleFiles
The list of additional prebuilt module files to load before processing the input.
std::map< std::string, std::vector< std::string > > PluginArgs
Args to pass to the plugins.
unsigned IsSystemModule
When using -emit-module, treat the modulemap as a system module.
ASTDumpOutputFormat ASTDumpFormat
Specifies the output format of the AST.
std::optional< std::string > AuxTargetCPU
Auxiliary target CPU for CUDA/HIP compilation.
std::string OutputFile
The output file, if any.
unsigned ShowStats
Show frontend performance metrics and statistics.
std::string ActionName
The name of the action to run when using a plugin action.
enum clang::FrontendOptions::@198 ARCMTAction
std::vector< std::shared_ptr< ModuleFileExtension > > ModuleFileExtensions
The list of module file extensions.
ParsedSourceLocation CodeCompletionAt
If given, enable code completion at the provided location.
std::string FixItSuffix
If given, the new suffix for fix-it rewritten files.
static InputKind getInputKindForExtension(StringRef Extension)
getInputKindForExtension - Return the appropriate input kind for a file extension.
std::vector< std::string > Plugins
The list of plugins to load.
unsigned ASTDumpAll
Whether we deserialize all decls when forming AST dumps.
unsigned GenerateGlobalModuleIndex
Whether we can generate the global module index if needed.
unsigned DisableFree
Disable memory freeing on exit.
SmallVector< FrontendInputFile, 0 > Inputs
The input files and their types.
frontend::ActionKind ProgramAction
The frontend action to perform.
std::optional< std::vector< std::string > > AuxTargetFeatures
Auxiliary target features for CUDA/HIP compilation.
std::string AuxTriple
Auxiliary triple for CUDA/HIP compilation.
unsigned UseGlobalModuleIndex
Whether we can use the global module index if available.
unsigned ASTDumpDecls
Whether we include declaration dumps in AST dumps.
A diagnostic client that ignores all diagnostics.
@ None
No signing for any function.
@ NonLeaf
Sign the return address of functions that spill LR.
@ All
Sign the return address of all functions,.
@ BKey
Return address signing uses APIB key.
@ AKey
Return address signing uses APIA key.
@ Ver6
Attempt to be ABI-compatible with code generated by Clang 6.0.x (SVN r321711).
@ Ver18
Attempt to be ABI-compatible with code generated by Clang 18.0.x.
@ Ver4
Attempt to be ABI-compatible with code generated by Clang 4.0.x (SVN r291814).
@ Ver14
Attempt to be ABI-compatible with code generated by Clang 14.0.x.
@ Ver11
Attempt to be ABI-compatible with code generated by Clang 11.0.x (git 2e10b7a39b93).
@ Ver15
Attempt to be ABI-compatible with code generated by Clang 15.0.x.
@ Ver17
Attempt to be ABI-compatible with code generated by Clang 17.0.x.
@ Ver7
Attempt to be ABI-compatible with code generated by Clang 7.0.x (SVN r338536).
@ Latest
Conform to the underlying platform's C and C++ ABIs as closely as we can.
@ Ver3_8
Attempt to be ABI-compatible with code generated by Clang 3.8.x (SVN r257626).
@ Ver12
Attempt to be ABI-compatible with code generated by Clang 12.0.x (git 8e464dd76bef).
@ Ver9
Attempt to be ABI-compatible with code generated by Clang 9.0.x (SVN r351319).
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
void resetNonModularOptions()
Reset all of the options that are not considered when building a module.
std::optional< TargetCXXABI::Kind > CXXABI
C++ ABI to compile with, if specified by the frontend through -fc++-abi=.
std::vector< std::string > NoBuiltinFuncs
A list of all -fno-builtin-* function names (e.g., memset).
std::string ModuleName
The module currently being compiled as specified by -fmodule-name.
clang::ObjCRuntime ObjCRuntime
std::string getOpenCLVersionString() const
Return the OpenCL C or C++ for OpenCL language name and version as a string.
SanitizerSet Sanitize
Set of enabled sanitizers.
bool UseTargetPathSeparator
Indicates whether to use target's platform-specific file separator when FILE macro is used and when c...
static void setLangDefaults(LangOptions &Opts, Language Lang, const llvm::Triple &T, std::vector< std::string > &Includes, LangStandard::Kind LangStd=LangStandard::lang_unspecified)
Set language defaults for the given input language and language standard in the given LangOptions obj...
std::string OMPHostIRFile
Name of the IR file that contains the result of the OpenMP target host code generation.
std::string OverflowHandler
The name of the handler function to be called when -ftrapv is specified.
std::string RandstructSeed
The seed used by the randomize structure layout feature.
std::map< std::string, std::string, std::greater< std::string > > MacroPrefixMap
A prefix map for FILE, BASE_FILE and __builtin_FILE().
LangStandard::Kind LangStd
The used language standard.
std::string OpenACCMacroOverride
unsigned getOpenCLCompatibleVersion() const
Return the OpenCL version that kernel language is compatible with.
bool SanitizeCoverage
Is at least one coverage instrumentation type enabled.
std::vector< llvm::Triple > OMPTargetTriples
Triples of the OpenMP targets that the host code codegen should take into account in order to generat...
std::vector< std::string > NoSanitizeFiles
Paths to files specifying which objects (files, functions, variables) should not be instrumented.
std::string CurrentModule
The name of the current module, of which the main source file is a part.
std::vector< std::string > ModuleFeatures
The names of any features to enable in module 'requires' decls in addition to the hard-coded list in ...
The basic abstraction for the target Objective-C runtime.
bool allowsWeak() const
Does this runtime allow the use of __weak?
bool tryParse(StringRef input)
Try to parse an Objective-C runtime specification from the given string.
std::string getAsString() const
bool allowsARC() const
Does this runtime allow ARC at all?
@ FragileMacOSX
'macosx-fragile' is the Apple-provided NeXT-derived runtime on Mac OS X platforms that use the fragil...
PreprocessorOptions - This class is used for passing the various options used in preprocessor initial...
std::vector< std::pair< std::string, std::string > > RemappedFiles
The set of file remappings, which take existing files on the system (the first part of each pair) and...
bool PCHWithHdrStopCreate
When true, we are creating a PCH or creating the PCH object while expecting a #pragma hdrstop to sepa...
std::vector< std::string > Includes
std::pair< unsigned, bool > PrecompiledPreambleBytes
If non-zero, the implicit PCH include is actually a precompiled preamble that covers this number of b...
bool LexEditorPlaceholders
When enabled, the preprocessor will construct editor placeholder tokens.
void resetNonModularOptions()
Reset any options that are not considered when building a module.
void addMacroUndef(StringRef Name)
std::set< std::string > DeserializedPCHDeclsToErrorOn
This is a set of names for decls that we do not want to be deserialized, and we emit an error if they...
void addMacroDef(StringRef Name)
bool DefineTargetOSMacros
Indicates whether to predefine target OS macros.
bool DetailedRecord
Whether we should maintain a detailed record of all macro definitions and expansions.
std::vector< std::string > ChainedIncludes
Headers that will be converted to chained PCHs in memory.
bool PCHWithHdrStop
When true, we are creating or using a PCH where a #pragma hdrstop is expected to indicate the beginni...
std::optional< uint64_t > SourceDateEpoch
If set, the UNIX timestamp specified by SOURCE_DATE_EPOCH.
bool UsePredefines
Initialize the preprocessor with the compiler and target specific predefines.
void addRemappedFile(StringRef From, StringRef To)
std::vector< std::pair< std::string, bool > > Macros
PreprocessorOutputOptions - Options for controlling the C preprocessor output (e.g....
unsigned ShowMacros
Print macro definitions.
unsigned ShowCPP
Print normal preprocessed output.
unsigned ShowLineMarkers
Show #line markers.
unsigned DirectivesOnly
Process directives but do not expand macros.
Encodes a location in the source.
static bool isSupportedCXXABI(const llvm::Triple &T, Kind Kind)
static const auto & getSpelling(Kind ABIKind)
static bool usesRelativeVTables(const llvm::Triple &T)
static bool isABI(StringRef Name)
Options for controlling the target.
std::string Triple
The name of the target triple to compile for.
llvm::VersionTuple SDKVersion
The version of the SDK which was used during the compilation.
uint64_t LargeDataThreshold
llvm::VersionTuple DarwinTargetVariantSDKVersion
The version of the darwin target variant SDK which was used during the compilation.
std::string HostTriple
When compiling for the device side, contains the triple used to compile for the host.
Action - Represent an abstract compilation step to perform.
static std::string GetResourcesPath(StringRef BinaryPath, StringRef CustomResourceDir="")
Takes the path to a binary that's either in bin/ or lib/ and returns the path to clang's resource dir...
constexpr XRayInstrMask None
constexpr XRayInstrMask All
const llvm::opt::OptTable & getDriverOptTable()
IncludeDirGroup
IncludeDirGroup - Identifies the group an include Entry belongs to, representing its relative positiv...
@ CXXSystem
Like System, but only used for C++.
@ Angled
Paths for '#include <>' added by '-I'.
@ CSystem
Like System, but only used for C.
@ System
Like Angled, but marks system directories.
@ Quoted
'#include ""' paths, added by 'gcc -iquote'.
@ ExternCSystem
Like System, but headers are implicitly wrapped in extern "C".
@ ObjCSystem
Like System, but only used for ObjC.
@ IndexHeaderMap
Like Angled, but marks header maps used when building frameworks.
@ ObjCXXSystem
Like System, but only used for ObjC++.
@ After
Like System, but searched after the system directories.
@ GenerateHeaderUnit
Generate a C++20 header unit module from a header file.
@ VerifyPCH
Load and verify that a PCH file is usable.
@ PrintPreprocessedInput
-E mode.
@ RewriteTest
Rewriter playground.
@ ParseSyntaxOnly
Parse and perform semantic analysis.
@ TemplightDump
Dump template instantiations.
@ GenerateModuleInterface
Generate pre-compiled module from a standard C++ module interface unit.
@ EmitLLVM
Emit a .ll file.
@ PrintPreamble
Print the "preamble" of the input file.
@ MigrateSource
Run migrator.
@ InitOnly
Only execute frontend initialization.
@ ASTView
Parse ASTs and view them in Graphviz.
@ PluginAction
Run a plugin action,.
@ DumpRawTokens
Dump out raw tokens.
@ PrintDependencyDirectivesSourceMinimizerOutput
Print the output of the dependency directives source minimizer.
@ RewriteObjC
ObjC->C Rewriter.
@ RunPreprocessorOnly
Just lex, no output.
@ ModuleFileInfo
Dump information about a module file.
@ DumpCompilerOptions
Dump the compiler configuration.
@ RunAnalysis
Run one or more source code analyses.
@ ASTPrint
Parse ASTs and print them.
@ GenerateReducedModuleInterface
Generate reduced module interface for a standard C++ module interface unit.
@ GenerateInterfaceStubs
Generate Interface Stub Files.
@ ASTDump
Parse ASTs and dump them.
@ DumpTokens
Dump out preprocessed tokens.
@ FixIt
Parse and apply any fixits to the source.
@ EmitAssembly
Emit a .s file.
@ EmitCodeGenOnly
Generate machine code, but don't emit anything.
@ RewriteMacros
Expand macros but not #includes.
@ EmitHTML
Translate input source into HTML.
@ GeneratePCH
Generate pre-compiled header.
@ EmitLLVMOnly
Generate LLVM IR, but do not emit anything.
@ GenerateModule
Generate pre-compiled module from a module map.
@ ASTDeclList
Parse ASTs and list Decl nodes.
const unsigned VERSION_MINOR
AST file minor version number supported by this version of Clang.
const unsigned VERSION_MAJOR
AST file major version number supported by this version of Clang.
The JSON file list parser is used to communicate input to InstallAPI.
ASTDumpOutputFormat
Used to specify the format for printing AST dump information.
SanitizerMask getPPTransparentSanitizers()
Return the sanitizers which do not affect preprocessing.
IntrusiveRefCntPtr< llvm::vfs::FileSystem > createVFSFromOverlayFiles(ArrayRef< std::string > VFSOverlayFiles, DiagnosticsEngine &Diags, IntrusiveRefCntPtr< llvm::vfs::FileSystem > BaseFS)
DiagnosticLevelMask
A bitmask representing the diagnostic levels used by VerifyDiagnosticConsumer.
std::unique_ptr< DiagnosticOptions > CreateAndPopulateDiagOpts(ArrayRef< const char * > Argv)
AnalysisConstraints
AnalysisConstraints - Set of available constraint models.
@ HIFIL_Only_Direct_System
void serializeSanitizerSet(SanitizerSet Set, SmallVectorImpl< StringRef > &Values)
Serialize a SanitizerSet into values for -fsanitize= or -fno-sanitize=.
LLVM_READONLY bool isLetter(unsigned char c)
Return true if this character is an ASCII letter: [a-zA-Z].
LLVM_READONLY bool isAlphanumeric(unsigned char c)
Return true if this character is an ASCII letter or digit: [a-zA-Z0-9].
@ C
Languages that the frontend can parse and compile.
@ CIR
LLVM IR & CIR: we accept these so that we can run the optimizer on them, and compile them to assembly...
@ Asm
Assembly: we accept this only so that we can preprocess it.
@ Result
The result type of a method or function.
XRayInstrMask parseXRayInstrValue(StringRef Value)
Parses a command line argument into a mask.
IntrusiveRefCntPtr< llvm::vfs::FileSystem > createVFSFromCompilerInvocation(const CompilerInvocation &CI, DiagnosticsEngine &Diags)
void serializeXRayInstrValue(XRayInstrSet Set, SmallVectorImpl< StringRef > &Values)
Serializes a set into a list of command line arguments.
AnalysisPurgeMode
AnalysisPurgeModes - Set of available strategies for dead symbol removal.
ShaderStage
Shader programs run in specific pipeline stages.
SanitizerMask parseSanitizerValue(StringRef Value, bool AllowGroups)
Parse a single value from a -fsanitize= or -fno-sanitize= value list.
const FunctionProtoType * T
AnalysisDiagClients
AnalysisDiagClients - Set of available diagnostic clients for rendering analysis results.
@ NUM_ANALYSIS_DIAG_CLIENTS
std::string getClangFullRepositoryVersion()
Retrieves the full repository version that is an amalgamation of the information in getClangRepositor...
int getLastArgIntValue(const llvm::opt::ArgList &Args, llvm::opt::OptSpecifier Id, int Default, DiagnosticsEngine *Diags=nullptr, unsigned Base=0)
Return the value of the last argument as an integer, or a default.
bool ParseDiagnosticArgs(DiagnosticOptions &Opts, llvm::opt::ArgList &Args, DiagnosticsEngine *Diags=nullptr, bool DefaultDiagColor=true)
Fill out Opts based on the options given in Args.
@ Success
Template argument deduction was successful.
AnalysisInliningMode
AnalysisInlineFunctionSelection - Set of inlining function selection heuristics.
Diagnostic wrappers for TextAPI types for error reporting.
__DEVICE__ _Tp arg(const std::complex< _Tp > &__c)
bool Internalize
If true, we use LLVM module internalizer.
bool PropagateAttrs
If true, we set attributes functions in the bitcode library according to our CodeGenOptions,...
std::string Filename
The filename of the bitcode file to link in.
unsigned LinkFlags
Bitwise combination of llvm::Linker::Flags, passed to the LLVM linker.
Dummy tag type whose instance can be passed into the constructor to prevent creation of the reference...
LangStandard - Information about the properties of a particular language standard.
static const LangStandard & getLangStandardForKind(Kind K)
const char * getName() const
getName - Get the name of this standard.
static Kind getLangKind(StringRef Name)
static ParsedSourceLocation FromString(StringRef Str)
Construct a parsed source location from a string; the Filename is empty on error.
std::string ToString() const
Serialize ParsedSourceLocation back to a string.
void clear(SanitizerMask K=SanitizerKind::All)
Disable the sanitizers specified in K.
bool empty() const
Returns true if no sanitizers are enabled.
SanitizerMask Mask
Bitmask of enabled sanitizers.