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;
615 if (LangOpts.CPlusPlus11) {
616 if (Args.hasArg(OPT_fraw_string_literals, OPT_fno_raw_string_literals)) {
617 Args.claimAllArgs(OPT_fraw_string_literals, OPT_fno_raw_string_literals);
618 Diags.
Report(diag::warn_drv_fraw_string_literals_in_cxx11)
619 <<
bool(LangOpts.RawStringLiterals);
623 LangOpts.RawStringLiterals =
true;
627 if (LangOpts.SYCLIsDevice && LangOpts.SYCLIsHost)
628 Diags.
Report(diag::err_drv_argument_not_allowed_with) <<
"-fsycl-is-device"
631 if (Args.hasArg(OPT_fgnu89_inline) && LangOpts.CPlusPlus)
632 Diags.
Report(diag::err_drv_argument_not_allowed_with)
635 if (Args.hasArg(OPT_hlsl_entrypoint) && !LangOpts.HLSL)
636 Diags.
Report(diag::err_drv_argument_not_allowed_with)
639 if (Args.hasArg(OPT_fgpu_allow_device_init) && !LangOpts.HIP)
640 Diags.
Report(diag::warn_ignored_hip_only_option)
641 << Args.getLastArg(OPT_fgpu_allow_device_init)->getAsString(Args);
643 if (Args.hasArg(OPT_gpu_max_threads_per_block_EQ) && !LangOpts.HIP)
644 Diags.
Report(diag::warn_ignored_hip_only_option)
645 << Args.getLastArg(OPT_gpu_max_threads_per_block_EQ)->getAsString(Args);
654 if (Args.hasArg(OPT_ffp_eval_method_EQ)) {
655 if (LangOpts.ApproxFunc)
656 Diags.
Report(diag::err_incompatible_fp_eval_method_options) << 0;
657 if (LangOpts.AllowFPReassoc)
658 Diags.
Report(diag::err_incompatible_fp_eval_method_options) << 1;
659 if (LangOpts.AllowRecip)
660 Diags.
Report(diag::err_incompatible_fp_eval_method_options) << 2;
666 if (Args.getLastArg(OPT_cl_strict_aliasing) &&
668 Diags.
Report(diag::warn_option_invalid_ocl_version)
670 << Args.getLastArg(OPT_cl_strict_aliasing)->getAsString(Args);
672 if (Arg *A = Args.getLastArg(OPT_fdefault_calling_conv_EQ)) {
673 auto DefaultCC = LangOpts.getDefaultCallingConv();
677 Arch != llvm::Triple::x86;
683 Diags.
Report(diag::err_drv_argument_not_allowed_with)
684 << A->getSpelling() <<
T.getTriple();
696 unsigned DefaultOpt = 0;
699 !Args.hasArg(OPT_cl_opt_disable))
702 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
703 if (A->getOption().matches(options::OPT_O0))
706 if (A->getOption().matches(options::OPT_Ofast))
709 assert(A->getOption().matches(options::OPT_O));
711 StringRef S(A->getValue());
712 if (S ==
"s" || S ==
"z")
725 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
726 if (A->getOption().matches(options::OPT_O)) {
727 switch (A->getValue()[0]) {
741 llvm::opt::OptSpecifier OptSpecifier) {
744 Option::OptionClass::FlagClass, 0);
748 llvm::opt::OptSpecifier OptSpecifier,
749 const Twine &
Value) {
787 bool CheckAgainstOriginalInvocation =
false,
788 bool ForceRoundTrip =
false) {
790 bool DoRoundTripDefault =
true;
792 bool DoRoundTripDefault =
false;
795 bool DoRoundTrip = DoRoundTripDefault;
796 if (ForceRoundTrip) {
799 for (
const auto *Arg : CommandLineArgs) {
800 if (Arg == StringRef(
"-round-trip-args"))
802 if (Arg == StringRef(
"-no-round-trip-args"))
810 return Parse(RealInvocation, CommandLineArgs, Diags, Argv0);
815 llvm::raw_string_ostream OS(Buffer);
816 for (
const char *Arg : Args) {
817 llvm::sys::printArg(OS, Arg,
true);
830 if (!Parse(DummyInvocation, CommandLineArgs, DummyDiags, Argv0) ||
837 auto Success = Parse(RealInvocation, CommandLineArgs, Diags, Argv0);
843 Diags.
Report(diag::err_cc1_round_trip_fail_then_ok);
844 Diags.
Report(diag::note_cc1_round_trip_original)
845 << SerializeArgs(CommandLineArgs);
850 llvm::BumpPtrAllocator Alloc;
851 llvm::StringSaver StringPool(Alloc);
852 auto SA = [&StringPool](
const Twine &Arg) {
853 return StringPool.save(Arg).data();
860 Generate(DummyInvocation, GeneratedArgs, SA);
866 bool Success2 = Parse(RealInvocation, GeneratedArgs, Diags, Argv0);
871 Diags.
Report(diag::err_cc1_round_trip_ok_then_fail);
872 Diags.
Report(diag::note_cc1_round_trip_generated)
873 << 1 << SerializeArgs(GeneratedArgs);
878 if (CheckAgainstOriginalInvocation)
880 ComparisonArgs.assign(CommandLineArgs.begin(), CommandLineArgs.end());
884 Generate(RealInvocation, ComparisonArgs, SA);
889 return std::equal(A.begin(), A.end(), B.begin(), B.end(),
890 [](
const char *AElem,
const char *BElem) {
891 return StringRef(AElem) == StringRef(BElem);
898 if (!
Equal(GeneratedArgs, ComparisonArgs)) {
899 Diags.
Report(diag::err_cc1_round_trip_mismatch);
900 Diags.
Report(diag::note_cc1_round_trip_generated)
901 << 1 << SerializeArgs(GeneratedArgs);
902 Diags.
Report(diag::note_cc1_round_trip_generated)
903 << 2 << SerializeArgs(ComparisonArgs);
907 Diags.
Report(diag::remark_cc1_round_trip_generated)
908 << 1 << SerializeArgs(GeneratedArgs);
909 Diags.
Report(diag::remark_cc1_round_trip_generated)
910 << 2 << SerializeArgs(ComparisonArgs);
922 return CreateFromArgsImpl(Invocation, CommandLineArgs, Diags, Argv0);
926 Args.push_back(
"-cc1");
929 DummyInvocation1, DummyInvocation2, Args, Diags, Argv0,
934 OptSpecifier GroupWithValue,
935 std::vector<std::string> &Diagnostics) {
936 for (
auto *A : Args.filtered(Group)) {
937 if (A->getOption().getKind() == Option::FlagClass) {
940 Diagnostics.push_back(
941 std::string(A->getOption().getName().drop_front(1)));
942 }
else if (A->getOption().matches(GroupWithValue)) {
945 Diagnostics.push_back(
946 std::string(A->getOption().getName().drop_front(1).rtrim(
"=-")));
949 Diagnostics.push_back(A->getValue());
960 std::vector<std::string> &Funcs) {
961 std::vector<std::string> Values = Args.getAllArgValues(OPT_fno_builtin_);
963 Funcs.insert(Funcs.end(), Values.begin(), BuiltinEnd);
970#define ANALYZER_OPTION_WITH_MARSHALLING(...) \
971 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
972#include "clang/Driver/Options.inc"
973#undef ANALYZER_OPTION_WITH_MARSHALLING
977#define ANALYSIS_CONSTRAINTS(NAME, CMDFLAG, DESC, CREATFN) \
979 GenerateArg(Consumer, OPT_analyzer_constraints, CMDFLAG); \
981#include "clang/StaticAnalyzer/Core/Analyses.def"
983 llvm_unreachable(
"Tried to generate unknown analysis constraint.");
989#define ANALYSIS_DIAGNOSTICS(NAME, CMDFLAG, DESC, CREATFN) \
991 GenerateArg(Consumer, OPT_analyzer_output, CMDFLAG); \
993#include "clang/StaticAnalyzer/Core/Analyses.def"
995 llvm_unreachable(
"Tried to generate unknown analysis diagnostic client.");
1001#define ANALYSIS_PURGE(NAME, CMDFLAG, DESC) \
1003 GenerateArg(Consumer, OPT_analyzer_purge, CMDFLAG); \
1005#include "clang/StaticAnalyzer/Core/Analyses.def"
1007 llvm_unreachable(
"Tried to generate unknown analysis purge mode.");
1013#define ANALYSIS_INLINING_MODE(NAME, CMDFLAG, DESC) \
1015 GenerateArg(Consumer, OPT_analyzer_inlining_mode, CMDFLAG); \
1017#include "clang/StaticAnalyzer/Core/Analyses.def"
1019 llvm_unreachable(
"Tried to generate unknown analysis inlining mode.");
1025 CP.second ? OPT_analyzer_checker : OPT_analyzer_disable_checker;
1034 for (
const auto &
C : Opts.
Config)
1035 SortedConfigOpts.emplace_back(
C.getKey(),
C.getValue());
1036 llvm::sort(SortedConfigOpts, llvm::less_first());
1038 for (
const auto &[Key,
Value] : SortedConfigOpts) {
1041 auto Entry = ConfigOpts.
Config.find(Key);
1042 if (Entry != ConfigOpts.
Config.end() && Entry->getValue() ==
Value)
1057#define ANALYZER_OPTION_WITH_MARSHALLING(...) \
1058 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
1059#include "clang/Driver/Options.inc"
1060#undef ANALYZER_OPTION_WITH_MARSHALLING
1062 if (Arg *A = Args.getLastArg(OPT_analyzer_constraints)) {
1063 StringRef Name = A->getValue();
1065#define ANALYSIS_CONSTRAINTS(NAME, CMDFLAG, DESC, CREATFN) \
1066 .Case(CMDFLAG, NAME##Model)
1067#include "clang/StaticAnalyzer/Core/Analyses.def"
1070 Diags.
Report(diag::err_drv_invalid_value)
1071 << A->getAsString(Args) << Name;
1074 if (
Value == AnalysisConstraints::Z3ConstraintsModel) {
1075 Diags.
Report(diag::err_analyzer_not_built_with_z3);
1082 if (Arg *A = Args.getLastArg(OPT_analyzer_output)) {
1083 StringRef Name = A->getValue();
1085#define ANALYSIS_DIAGNOSTICS(NAME, CMDFLAG, DESC, CREATFN) \
1086 .Case(CMDFLAG, PD_##NAME)
1087#include "clang/StaticAnalyzer/Core/Analyses.def"
1090 Diags.
Report(diag::err_drv_invalid_value)
1091 << A->getAsString(Args) << Name;
1097 if (Arg *A = Args.getLastArg(OPT_analyzer_purge)) {
1098 StringRef Name = A->getValue();
1100#define ANALYSIS_PURGE(NAME, CMDFLAG, DESC) \
1101 .Case(CMDFLAG, NAME)
1102#include "clang/StaticAnalyzer/Core/Analyses.def"
1105 Diags.
Report(diag::err_drv_invalid_value)
1106 << A->getAsString(Args) << Name;
1112 if (Arg *A = Args.getLastArg(OPT_analyzer_inlining_mode)) {
1113 StringRef Name = A->getValue();
1115#define ANALYSIS_INLINING_MODE(NAME, CMDFLAG, DESC) \
1116 .Case(CMDFLAG, NAME)
1117#include "clang/StaticAnalyzer/Core/Analyses.def"
1120 Diags.
Report(diag::err_drv_invalid_value)
1121 << A->getAsString(Args) << Name;
1129 Args.filtered(OPT_analyzer_checker, OPT_analyzer_disable_checker)) {
1131 bool IsEnabled = A->getOption().getID() == OPT_analyzer_checker;
1134 StringRef CheckerAndPackageList = A->getValue();
1136 CheckerAndPackageList.split(CheckersAndPackages,
",");
1137 for (
const StringRef &CheckerOrPackage : CheckersAndPackages)
1143 for (
const auto *A : Args.filtered(OPT_analyzer_config)) {
1147 StringRef configList = A->getValue();
1149 configList.split(configVals,
",");
1150 for (
const auto &configVal : configVals) {
1152 std::tie(key, val) = configVal.split(
"=");
1155 diag::err_analyzer_config_no_value) << configVal;
1158 if (val.contains(
'=')) {
1160 diag::err_analyzer_config_multiple_values)
1169 Diags.
Report(diag::err_analyzer_config_unknown) << key;
1174 Opts.
Config[key] = std::string(val);
1184 for (
unsigned i = 0; i < Args.getNumInputArgStrings(); ++i) {
1187 os << Args.getArgString(i);
1195 StringRef OptionName, StringRef DefaultVal) {
1196 return Config.insert({OptionName, std::string(DefaultVal)}).first->second;
1201 StringRef &OptionField, StringRef Name,
1202 StringRef DefaultVal) {
1211 bool &OptionField, StringRef Name,
bool DefaultVal) {
1212 auto PossiblyInvalidVal =
1213 llvm::StringSwitch<std::optional<bool>>(
1216 .Case(
"false",
false)
1217 .Default(std::nullopt);
1219 if (!PossiblyInvalidVal) {
1221 Diags->
Report(diag::err_analyzer_config_invalid_input)
1222 << Name <<
"a boolean";
1224 OptionField = DefaultVal;
1226 OptionField = *PossiblyInvalidVal;
1231 unsigned &OptionField, StringRef Name,
1232 unsigned DefaultVal) {
1234 OptionField = DefaultVal;
1235 bool HasFailed =
getStringOption(Config, Name, std::to_string(DefaultVal))
1236 .getAsInteger(0, OptionField);
1237 if (Diags && HasFailed)
1238 Diags->
Report(diag::err_analyzer_config_invalid_input)
1239 << Name <<
"an unsigned";
1247#define ANALYZER_OPTION(TYPE, NAME, CMDFLAG, DESC, DEFAULT_VAL) \
1248 initOption(AnOpts.Config, Diags, AnOpts.NAME, CMDFLAG, DEFAULT_VAL);
1249#define ANALYZER_OPTION_DEPENDS_ON_USER_MODE(...)
1250#include "clang/StaticAnalyzer/Core/AnalyzerOptions.def"
1252 assert(AnOpts.UserMode ==
"shallow" || AnOpts.UserMode ==
"deep");
1253 const bool InShallowMode = AnOpts.UserMode ==
"shallow";
1255#define ANALYZER_OPTION(...)
1256#define ANALYZER_OPTION_DEPENDS_ON_USER_MODE(TYPE, NAME, CMDFLAG, DESC, \
1257 SHALLOW_VAL, DEEP_VAL) \
1258 initOption(AnOpts.Config, Diags, AnOpts.NAME, CMDFLAG, \
1259 InShallowMode ? SHALLOW_VAL : DEEP_VAL);
1260#include "clang/StaticAnalyzer/Core/AnalyzerOptions.def"
1267 if (!AnOpts.RawSilencedCheckersAndPackages.empty()) {
1268 std::vector<StringRef> Checkers =
1270 std::vector<StringRef> Packages =
1274 AnOpts.RawSilencedCheckersAndPackages.split(CheckersAndPackages,
";");
1276 for (
const StringRef &CheckerOrPackage : CheckersAndPackages) {
1278 bool IsChecker = CheckerOrPackage.contains(
'.');
1279 bool IsValidName = IsChecker
1280 ? llvm::is_contained(Checkers, CheckerOrPackage)
1281 : llvm::is_contained(Packages, CheckerOrPackage);
1284 Diags->
Report(diag::err_unknown_analyzer_checker_or_package)
1285 << CheckerOrPackage;
1295 if (AnOpts.ShouldTrackConditionsDebug && !AnOpts.ShouldTrackConditions)
1296 Diags->
Report(diag::err_analyzer_config_invalid_input)
1297 <<
"track-conditions-debug" <<
"'track-conditions' to also be enabled";
1299 if (!AnOpts.CTUDir.empty() && !llvm::sys::fs::is_directory(AnOpts.CTUDir))
1300 Diags->
Report(diag::err_analyzer_config_invalid_input) <<
"ctu-dir"
1303 if (!AnOpts.ModelPath.empty() &&
1304 !llvm::sys::fs::is_directory(AnOpts.ModelPath))
1305 Diags->
Report(diag::err_analyzer_config_invalid_input) <<
"model-path"
1314 if (
Remark.hasValidPattern()) {
1319 GenerateArg(Consumer, OPT_R_Joined, StringRef(
"no-") + Name);
1328 OptSpecifier OptEQ, StringRef Name) {
1331 auto InitializeResultPattern = [&Diags, &Args, &
Result](
const Arg *A,
1332 StringRef Pattern) {
1333 Result.Pattern = Pattern.str();
1335 std::string RegexError;
1336 Result.Regex = std::make_shared<llvm::Regex>(
Result.Pattern);
1337 if (!
Result.Regex->isValid(RegexError)) {
1338 Diags.
Report(diag::err_drv_optimization_remark_pattern)
1339 << RegexError << A->getAsString(Args);
1346 for (Arg *A : Args) {
1347 if (A->getOption().matches(OPT_R_Joined)) {
1348 StringRef
Value = A->getValue();
1352 else if (
Value ==
"everything")
1354 else if (
Value.split(
'-') == std::make_pair(StringRef(
"no"), Name))
1356 else if (
Value ==
"no-everything")
1366 InitializeResultPattern(A,
".*");
1368 }
else if (A->getOption().matches(OptEQ)) {
1370 if (!InitializeResultPattern(A, A->getValue()))
1379 const std::vector<std::string> &Levels,
1383 for (
const auto &Level : Levels) {
1385 llvm::StringSwitch<DiagnosticLevelMask>(Level)
1393 Diags.
Report(diag::err_drv_invalid_value) << FlagName << Level;
1401 const std::vector<std::string> &Sanitizers,
1403 for (
const auto &Sanitizer : Sanitizers) {
1406 Diags.
Report(diag::err_drv_invalid_value) << FlagName << Sanitizer;
1422 llvm::SplitString(Bundle, BundleParts,
",");
1423 for (
const auto &B : BundleParts) {
1427 D.Report(diag::err_drv_invalid_value) << FlagName << Bundle;
1441 llvm::raw_string_ostream OS(Buffer);
1442 llvm::interleave(BundleParts, OS, [&OS](StringRef Part) { OS << Part; },
",");
1448 const Twine &ProfileName,
1449 llvm::vfs::FileSystem &FS,
1451 auto ReaderOrErr = llvm::IndexedInstrProfReader::create(ProfileName, FS);
1452 if (
auto E = ReaderOrErr.takeError()) {
1454 "Error in reading profile %0: %1");
1455 llvm::handleAllErrors(std::move(
E), [&](
const llvm::ErrorInfoBase &EI) {
1456 Diags.
Report(DiagID) << ProfileName.str() << EI.message();
1460 std::unique_ptr<llvm::IndexedInstrProfReader> PGOReader =
1461 std::move(ReaderOrErr.get());
1465 if (PGOReader->isIRLevelProfile() || PGOReader->hasMemoryProfile()) {
1466 if (PGOReader->hasCSIRLevelProfile())
1476 const llvm::Triple &Triple) {
1477 assert(Triple.getArch() == llvm::Triple::aarch64);
1484 LangOpts.PointerAuthFunctionTypeDiscrimination ? Discrimination::Type
1485 : Discrimination::None);
1488 Key::ASDA,
LangOpts.PointerAuthVTPtrAddressDiscrimination,
1489 LangOpts.PointerAuthVTPtrTypeDiscrimination ? Discrimination::Type
1490 : Discrimination::None);
1492 if (
LangOpts.PointerAuthTypeInfoVTPtrDiscrimination)
1512 const llvm::Triple &Triple,
1514 if (!LangOpts.PointerAuthCalls && !LangOpts.PointerAuthIndirectGotos)
1520void CompilerInvocationBase::GenerateCodeGenArgs(
const CodeGenOptions &Opts,
1522 const llvm::Triple &
T,
1523 const std::string &OutputFile,
1527 if (Opts.OptimizationLevel == 0)
1530 GenerateArg(Consumer, OPT_O, Twine(Opts.OptimizationLevel));
1532#define CODEGEN_OPTION_WITH_MARSHALLING(...) \
1533 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
1534#include "clang/Driver/Options.inc"
1535#undef CODEGEN_OPTION_WITH_MARSHALLING
1537 if (Opts.OptimizationLevel > 0) {
1541 GenerateArg(Consumer, OPT_finline_hint_functions);
1546 if (Opts.DirectAccessExternalData &&
LangOpts->PICLevel != 0)
1547 GenerateArg(Consumer, OPT_fdirect_access_external_data);
1548 else if (!Opts.DirectAccessExternalData &&
LangOpts->PICLevel == 0)
1549 GenerateArg(Consumer, OPT_fno_direct_access_external_data);
1551 std::optional<StringRef> DebugInfoVal;
1552 switch (Opts.DebugInfo) {
1553 case llvm::codegenoptions::DebugLineTablesOnly:
1554 DebugInfoVal =
"line-tables-only";
1556 case llvm::codegenoptions::DebugDirectivesOnly:
1557 DebugInfoVal =
"line-directives-only";
1559 case llvm::codegenoptions::DebugInfoConstructor:
1560 DebugInfoVal =
"constructor";
1562 case llvm::codegenoptions::LimitedDebugInfo:
1563 DebugInfoVal =
"limited";
1565 case llvm::codegenoptions::FullDebugInfo:
1566 DebugInfoVal =
"standalone";
1568 case llvm::codegenoptions::UnusedTypeInfo:
1569 DebugInfoVal =
"unused-types";
1571 case llvm::codegenoptions::NoDebugInfo:
1572 DebugInfoVal = std::nullopt;
1574 case llvm::codegenoptions::LocTrackingOnly:
1575 DebugInfoVal = std::nullopt;
1579 GenerateArg(Consumer, OPT_debug_info_kind_EQ, *DebugInfoVal);
1583 Prefix.first +
"=" + Prefix.second);
1586 GenerateArg(Consumer, OPT_fcoverage_prefix_map_EQ,
1587 Prefix.first +
"=" + Prefix.second);
1589 if (Opts.NewStructPathTBAA)
1592 if (Opts.OptimizeSize == 1)
1594 else if (Opts.OptimizeSize == 2)
1602 if (Opts.UnrollLoops && Opts.OptimizationLevel <= 1)
1604 else if (!Opts.UnrollLoops && Opts.OptimizationLevel > 1)
1610 if (Opts.DebugNameTable ==
1611 static_cast<unsigned>(llvm::DICompileUnit::DebugNameTableKind::GNU))
1613 else if (Opts.DebugNameTable ==
1614 static_cast<unsigned>(
1615 llvm::DICompileUnit::DebugNameTableKind::Default))
1618 if (Opts.DebugTemplateAlias)
1621 auto TNK = Opts.getDebugSimpleTemplateNames();
1622 if (TNK != llvm::codegenoptions::DebugTemplateNamesKind::Full) {
1623 if (TNK == llvm::codegenoptions::DebugTemplateNamesKind::Simple)
1624 GenerateArg(Consumer, OPT_gsimple_template_names_EQ,
"simple");
1625 else if (TNK == llvm::codegenoptions::DebugTemplateNamesKind::Mangled)
1626 GenerateArg(Consumer, OPT_gsimple_template_names_EQ,
"mangled");
1631 if (Opts.TimePasses) {
1632 if (Opts.TimePassesPerRun)
1633 GenerateArg(Consumer, OPT_ftime_report_EQ,
"per-pass-run");
1638 if (Opts.PrepareForLTO && !Opts.PrepareForThinLTO)
1641 if (Opts.PrepareForThinLTO)
1650 StringRef MemProfileBasename(
"memprof.profraw");
1671 std::string InstrBundle =
1673 if (!InstrBundle.empty())
1674 GenerateArg(Consumer, OPT_fxray_instrumentation_bundle, InstrBundle);
1677 if (Opts.CFProtectionReturn && Opts.CFProtectionBranch)
1678 GenerateArg(Consumer, OPT_fcf_protection_EQ,
"full");
1679 else if (Opts.CFProtectionReturn)
1680 GenerateArg(Consumer, OPT_fcf_protection_EQ,
"return");
1681 else if (Opts.CFProtectionBranch)
1682 GenerateArg(Consumer, OPT_fcf_protection_EQ,
"branch");
1684 if (Opts.FunctionReturnThunks)
1685 GenerateArg(Consumer, OPT_mfunction_return_EQ,
"thunk-extern");
1688 bool Builtint = F.LinkFlags == llvm::Linker::Flags::LinkOnlyNeeded &&
1689 F.PropagateAttrs && F.Internalize;
1691 Builtint ? OPT_mlink_builtin_bitcode : OPT_mlink_bitcode_file,
1695 if (Opts.EmulatedTLS)
1703 GenerateArg(Consumer, OPT_fdenormal_fp_math_f32_EQ,
1708 T.isPPC32() ? OPT_maix_struct_return : OPT_fpcc_struct_return;
1712 T.isPPC32() ? OPT_msvr4_struct_return : OPT_freg_struct_return;
1716 if (Opts.EnableAIXExtendedAltivecABI)
1719 if (Opts.XCOFFReadOnlyPointers)
1737 GenerateArg(Consumer, OPT_fdiagnostics_hotness_threshold_EQ,
1742 GenerateArg(Consumer, OPT_fdiagnostics_misexpect_tolerance_EQ,
1746 GenerateArg(Consumer, OPT_fsanitize_recover_EQ, Sanitizer);
1749 GenerateArg(Consumer, OPT_fsanitize_trap_EQ, Sanitizer);
1751 if (!Opts.EmitVersionIdentMetadata)
1754 switch (Opts.FiniteLoops) {
1766bool CompilerInvocation::ParseCodeGenArgs(
CodeGenOptions &Opts, ArgList &Args,
1769 const llvm::Triple &
T,
1770 const std::string &OutputFile,
1776 unsigned MaxOptLevel = 3;
1777 if (OptimizationLevel > MaxOptLevel) {
1780 Diags.
Report(diag::warn_drv_optimization_value)
1781 << Args.getLastArg(OPT_O)->getAsString(Args) <<
"-O" << MaxOptLevel;
1782 OptimizationLevel = MaxOptLevel;
1784 Opts.OptimizationLevel = OptimizationLevel;
1793#define CODEGEN_OPTION_WITH_MARSHALLING(...) \
1794 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
1795#include "clang/Driver/Options.inc"
1796#undef CODEGEN_OPTION_WITH_MARSHALLING
1800 if (Opts.OptimizationLevel == 0) {
1802 }
else if (
const Arg *A = Args.getLastArg(options::OPT_finline_functions,
1803 options::OPT_finline_hint_functions,
1804 options::OPT_fno_inline_functions,
1805 options::OPT_fno_inline)) {
1808 if (A->getOption().matches(options::OPT_finline_functions))
1810 else if (A->getOption().matches(options::OPT_finline_hint_functions))
1820 Opts.DirectAccessExternalData =
1821 Args.hasArg(OPT_fdirect_access_external_data) ||
1822 (!Args.hasArg(OPT_fno_direct_access_external_data) &&
1825 if (Arg *A = Args.getLastArg(OPT_debug_info_kind_EQ)) {
1827 llvm::StringSwitch<unsigned>(A->getValue())
1828 .Case(
"line-tables-only", llvm::codegenoptions::DebugLineTablesOnly)
1829 .Case(
"line-directives-only",
1830 llvm::codegenoptions::DebugDirectivesOnly)
1831 .Case(
"constructor", llvm::codegenoptions::DebugInfoConstructor)
1832 .Case(
"limited", llvm::codegenoptions::LimitedDebugInfo)
1833 .Case(
"standalone", llvm::codegenoptions::FullDebugInfo)
1834 .Case(
"unused-types", llvm::codegenoptions::UnusedTypeInfo)
1837 Diags.
Report(diag::err_drv_invalid_value) << A->getAsString(Args)
1840 Opts.setDebugInfo(
static_cast<llvm::codegenoptions::DebugInfoKind
>(Val));
1846 Args.getLastArg(OPT_fuse_ctor_homing, OPT_fno_use_ctor_homing)) {
1847 if (A->getOption().matches(OPT_fuse_ctor_homing) &&
1848 Opts.getDebugInfo() == llvm::codegenoptions::LimitedDebugInfo)
1849 Opts.setDebugInfo(llvm::codegenoptions::DebugInfoConstructor);
1850 if (A->getOption().matches(OPT_fno_use_ctor_homing) &&
1851 Opts.getDebugInfo() == llvm::codegenoptions::DebugInfoConstructor)
1852 Opts.setDebugInfo(llvm::codegenoptions::LimitedDebugInfo);
1855 for (
const auto &Arg : Args.getAllArgValues(OPT_fdebug_prefix_map_EQ)) {
1856 auto Split = StringRef(Arg).split(
'=');
1860 for (
const auto &Arg : Args.getAllArgValues(OPT_fcoverage_prefix_map_EQ)) {
1861 auto Split = StringRef(Arg).split(
'=');
1865 const llvm::Triple::ArchType DebugEntryValueArchs[] = {
1866 llvm::Triple::x86, llvm::Triple::x86_64, llvm::Triple::aarch64,
1867 llvm::Triple::arm, llvm::Triple::armeb, llvm::Triple::mips,
1868 llvm::Triple::mipsel, llvm::Triple::mips64, llvm::Triple::mips64el};
1871 llvm::is_contained(DebugEntryValueArchs,
T.getArch()))
1872 Opts.EmitCallSiteInfo =
true;
1875 Diags.
Report(diag::warn_ignoring_verify_debuginfo_preserve_export)
1880 Opts.NewStructPathTBAA = !Args.hasArg(OPT_no_struct_path_tbaa) &&
1881 Args.hasArg(OPT_new_struct_path_tbaa);
1883 Opts.SimplifyLibCalls = !
LangOpts->NoBuiltin;
1884 if (Opts.SimplifyLibCalls)
1887 Args.hasFlag(OPT_funroll_loops, OPT_fno_unroll_loops,
1888 (Opts.OptimizationLevel > 1));
1890 std::string(Args.getLastArgValue(OPT_fbinutils_version_EQ));
1892 Opts.DebugTemplateAlias = Args.hasArg(OPT_gtemplate_alias);
1894 Opts.DebugNameTable =
static_cast<unsigned>(
1895 Args.hasArg(OPT_ggnu_pubnames)
1896 ? llvm::DICompileUnit::DebugNameTableKind::GNU
1897 : Args.hasArg(OPT_gpubnames)
1898 ? llvm::DICompileUnit::DebugNameTableKind::Default
1899 : llvm::DICompileUnit::DebugNameTableKind::None);
1900 if (
const Arg *A = Args.getLastArg(OPT_gsimple_template_names_EQ)) {
1901 StringRef
Value = A->getValue();
1903 Diags.
Report(diag::err_drv_unsupported_option_argument)
1904 << A->getSpelling() << A->getValue();
1905 Opts.setDebugSimpleTemplateNames(
1906 StringRef(A->getValue()) ==
"simple"
1907 ? llvm::codegenoptions::DebugTemplateNamesKind::Simple
1908 : llvm::codegenoptions::DebugTemplateNamesKind::Mangled);
1911 if (
const Arg *A = Args.getLastArg(OPT_ftime_report, OPT_ftime_report_EQ)) {
1912 Opts.TimePasses =
true;
1915 if (A->getOption().getID() == OPT_ftime_report_EQ) {
1916 StringRef Val = A->getValue();
1917 if (Val ==
"per-pass")
1918 Opts.TimePassesPerRun =
false;
1919 else if (Val ==
"per-pass-run")
1920 Opts.TimePassesPerRun =
true;
1922 Diags.
Report(diag::err_drv_invalid_value)
1923 << A->getAsString(Args) << A->getValue();
1927 Opts.PrepareForLTO =
false;
1928 Opts.PrepareForThinLTO =
false;
1929 if (Arg *A = Args.getLastArg(OPT_flto_EQ)) {
1930 Opts.PrepareForLTO =
true;
1931 StringRef S = A->getValue();
1933 Opts.PrepareForThinLTO =
true;
1934 else if (S !=
"full")
1935 Diags.
Report(diag::err_drv_invalid_value) << A->getAsString(Args) << S;
1936 if (Args.hasArg(OPT_funified_lto))
1937 Opts.PrepareForThinLTO =
true;
1939 if (Arg *A = Args.getLastArg(OPT_fthinlto_index_EQ)) {
1941 Diags.
Report(diag::err_drv_argument_only_allowed_with)
1942 << A->getAsString(Args) <<
"-x ir";
1944 std::string(Args.getLastArgValue(OPT_fthinlto_index_EQ));
1946 if (Arg *A = Args.getLastArg(OPT_save_temps_EQ))
1948 llvm::StringSwitch<std::string>(A->getValue())
1949 .Case(
"obj", OutputFile)
1950 .Default(llvm::sys::path::filename(OutputFile).str());
1953 const char *MemProfileBasename =
"memprof.profraw";
1954 if (Args.hasArg(OPT_fmemory_profile_EQ)) {
1956 std::string(Args.getLastArgValue(OPT_fmemory_profile_EQ)));
1957 llvm::sys::path::append(
Path, MemProfileBasename);
1959 }
else if (Args.hasArg(OPT_fmemory_profile))
1964 if (Args.hasArg(OPT_coverage_version_EQ)) {
1965 StringRef CoverageVersion = Args.getLastArgValue(OPT_coverage_version_EQ);
1966 if (CoverageVersion.size() != 4) {
1967 Diags.
Report(diag::err_drv_invalid_value)
1968 << Args.getLastArg(OPT_coverage_version_EQ)->getAsString(Args)
1978 for (
const auto &A : Args) {
1980 if (A->getOption().getID() == options::OPT_o ||
1981 A->getOption().getID() == options::OPT_INPUT ||
1982 A->getOption().getID() == options::OPT_x ||
1983 A->getOption().getID() == options::OPT_fembed_bitcode ||
1984 A->getOption().matches(options::OPT_W_Group))
1987 A->render(Args, ASL);
1988 for (
const auto &arg : ASL) {
1989 StringRef ArgStr(arg);
1990 Opts.
CmdArgs.insert(Opts.
CmdArgs.end(), ArgStr.begin(), ArgStr.end());
1996 auto XRayInstrBundles =
1997 Args.getAllArgValues(OPT_fxray_instrumentation_bundle);
1998 if (XRayInstrBundles.empty())
2001 for (
const auto &A : XRayInstrBundles)
2005 if (
const Arg *A = Args.getLastArg(OPT_fcf_protection_EQ)) {
2006 StringRef Name = A->getValue();
2007 if (Name ==
"full") {
2008 Opts.CFProtectionReturn = 1;
2009 Opts.CFProtectionBranch = 1;
2010 }
else if (Name ==
"return")
2011 Opts.CFProtectionReturn = 1;
2012 else if (Name ==
"branch")
2013 Opts.CFProtectionBranch = 1;
2014 else if (Name !=
"none")
2015 Diags.
Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Name;
2018 if (
const Arg *A = Args.getLastArg(OPT_mfunction_return_EQ)) {
2019 auto Val = llvm::StringSwitch<llvm::FunctionReturnThunksKind>(A->getValue())
2020 .Case(
"keep", llvm::FunctionReturnThunksKind::Keep)
2021 .Case(
"thunk-extern", llvm::FunctionReturnThunksKind::Extern)
2022 .Default(llvm::FunctionReturnThunksKind::Invalid);
2025 Diags.
Report(diag::err_drv_argument_not_allowed_with)
2026 << A->getSpelling() <<
T.getTriple();
2027 else if (Val == llvm::FunctionReturnThunksKind::Invalid)
2028 Diags.
Report(diag::err_drv_invalid_value)
2029 << A->getAsString(Args) << A->getValue();
2030 else if (Val == llvm::FunctionReturnThunksKind::Extern &&
2031 Args.getLastArgValue(OPT_mcmodel_EQ) ==
"large")
2032 Diags.
Report(diag::err_drv_argument_not_allowed_with)
2033 << A->getAsString(Args)
2034 << Args.getLastArg(OPT_mcmodel_EQ)->getAsString(Args);
2036 Opts.FunctionReturnThunks =
static_cast<unsigned>(Val);
2040 Args.filtered(OPT_mlink_bitcode_file, OPT_mlink_builtin_bitcode)) {
2043 if (A->getOption().matches(OPT_mlink_builtin_bitcode)) {
2044 F.
LinkFlags = llvm::Linker::Flags::LinkOnlyNeeded;
2053 if (Arg *A = Args.getLastArg(OPT_fdenormal_fp_math_EQ)) {
2054 StringRef Val = A->getValue();
2058 Diags.
Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Val;
2061 if (Arg *A = Args.getLastArg(OPT_fdenormal_fp_math_f32_EQ)) {
2062 StringRef Val = A->getValue();
2065 Diags.
Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Val;
2071 Args.getLastArg(OPT_fpcc_struct_return, OPT_freg_struct_return,
2072 OPT_maix_struct_return, OPT_msvr4_struct_return)) {
2076 Diags.
Report(diag::err_drv_unsupported_opt_for_target)
2077 << A->getSpelling() <<
T.str();
2079 const Option &O = A->getOption();
2080 if (O.matches(OPT_fpcc_struct_return) ||
2081 O.matches(OPT_maix_struct_return)) {
2084 assert(O.matches(OPT_freg_struct_return) ||
2085 O.matches(OPT_msvr4_struct_return));
2090 if (Arg *A = Args.getLastArg(OPT_mxcoff_roptr)) {
2092 Diags.
Report(diag::err_drv_unsupported_opt_for_target)
2093 << A->getSpelling() <<
T.str();
2103 if (!Args.hasFlag(OPT_fdata_sections, OPT_fno_data_sections,
false))
2104 Diags.
Report(diag::err_roptr_requires_data_sections);
2106 Opts.XCOFFReadOnlyPointers =
true;
2109 if (Arg *A = Args.getLastArg(OPT_mabi_EQ_quadword_atomics)) {
2110 if (!
T.isOSAIX() ||
T.isPPC32())
2111 Diags.
Report(diag::err_drv_unsupported_opt_for_target)
2112 << A->getSpelling() <<
T.str();
2115 bool NeedLocTracking =
false;
2118 NeedLocTracking =
true;
2120 if (Arg *A = Args.getLastArg(OPT_opt_record_passes)) {
2122 NeedLocTracking =
true;
2125 if (Arg *A = Args.getLastArg(OPT_opt_record_format)) {
2127 NeedLocTracking =
true;
2137 Diags, Args, OPT_Rpass_analysis_EQ,
"pass-analysis");
2147 if (Opts.DiagnosticsWithHotness && !UsingProfile &&
2150 Diags.
Report(diag::warn_drv_diagnostics_hotness_requires_pgo)
2151 <<
"-fdiagnostics-show-hotness";
2155 Args.getLastArg(options::OPT_fdiagnostics_hotness_threshold_EQ)) {
2157 llvm::remarks::parseHotnessThresholdOption(
arg->getValue());
2160 Diags.
Report(diag::err_drv_invalid_diagnotics_hotness_threshold)
2161 <<
"-fdiagnostics-hotness-threshold=";
2167 Diags.
Report(diag::warn_drv_diagnostics_hotness_requires_pgo)
2168 <<
"-fdiagnostics-hotness-threshold=";
2173 Args.getLastArg(options::OPT_fdiagnostics_misexpect_tolerance_EQ)) {
2177 Diags.
Report(diag::err_drv_invalid_diagnotics_misexpect_tolerance)
2178 <<
"-fdiagnostics-misexpect-tolerance=";
2184 Diags.
Report(diag::warn_drv_diagnostics_misexpect_requires_pgo)
2185 <<
"-fdiagnostics-misexpect-tolerance=";
2192 if (UsingSampleProfile)
2193 NeedLocTracking =
true;
2196 NeedLocTracking =
true;
2200 if (NeedLocTracking &&
2201 Opts.getDebugInfo() == llvm::codegenoptions::NoDebugInfo)
2202 Opts.setDebugInfo(llvm::codegenoptions::LocTrackingOnly);
2207 Args.getAllArgValues(OPT_fsanitize_recover_EQ), Diags,
2210 Args.getAllArgValues(OPT_fsanitize_trap_EQ), Diags,
2213 Opts.EmitVersionIdentMetadata = Args.hasFlag(OPT_Qy, OPT_Qn,
true);
2218 if (Args.hasArg(options::OPT_ffinite_loops))
2220 else if (Args.hasArg(options::OPT_fno_finite_loops))
2223 Opts.EmitIEEENaNCompliantInsts = Args.hasFlag(
2224 options::OPT_mamdgpu_ieee, options::OPT_mno_amdgpu_ieee,
true);
2225 if (!Opts.EmitIEEENaNCompliantInsts && !LangOptsRef.NoHonorNaNs)
2226 Diags.
Report(diag::err_drv_amdgpu_ieee_without_no_honor_nans);
2234#define DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING(...) \
2235 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
2236#include "clang/Driver/Options.inc"
2237#undef DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING
2242 for (
const auto &Dep : Opts.
ExtraDeps) {
2243 switch (Dep.second) {
2256 GenerateArg(Consumer, OPT_fdepfile_entry, Dep.first);
2265 bool ShowLineMarkers) {
2269#define DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING(...) \
2270 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
2271#include "clang/Driver/Options.inc"
2272#undef DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING
2274 if (Args.hasArg(OPT_show_includes)) {
2289 if (!Args.hasArg(OPT_fno_sanitize_ignorelist)) {
2290 for (
const auto *A : Args.filtered(OPT_fsanitize_ignorelist_EQ)) {
2291 StringRef Val = A->getValue();
2292 if (!Val.contains(
'='))
2296 for (
const auto *A : Args.filtered(OPT_fsanitize_system_ignorelist_EQ)) {
2297 StringRef Val = A->getValue();
2298 if (!Val.contains(
'='))
2305 for (
const auto &
Filename : Args.getAllArgValues(OPT_fprofile_list_EQ))
2309 for (
const auto *A : Args.filtered(OPT_fdepfile_entry))
2313 for (
const auto *A : Args.filtered(OPT_fmodule_file)) {
2314 StringRef Val = A->getValue();
2315 if (!Val.contains(
'='))
2325 Diags.
Report(diag::err_drv_print_header_env_var_combination_cc1)
2326 << Args.getLastArg(OPT_header_include_format_EQ)->getValue()
2327 << Args.getLastArg(OPT_header_include_filtering_EQ)->getValue();
2341 }
ShowColors = DefaultColor ? Colors_Auto : Colors_Off;
2342 for (
auto *A : Args) {
2343 const Option &O = A->getOption();
2344 if (O.matches(options::OPT_fcolor_diagnostics)) {
2346 }
else if (O.matches(options::OPT_fno_color_diagnostics)) {
2348 }
else if (O.matches(options::OPT_fdiagnostics_color_EQ)) {
2349 StringRef
Value(A->getValue());
2350 if (
Value ==
"always")
2352 else if (
Value ==
"never")
2354 else if (
Value ==
"auto")
2360 llvm::sys::Process::StandardErrHasColors());
2366 for (
const auto &Prefix : VerifyPrefixes) {
2369 auto BadChar = llvm::find_if(Prefix, [](
char C) {
2372 if (BadChar != Prefix.end() || !
isLetter(Prefix[0])) {
2374 Diags.
Report(diag::err_drv_invalid_value) <<
"-verify=" << Prefix;
2375 Diags.
Report(diag::note_drv_verify_prefix_spelling);
2385#define FILE_SYSTEM_OPTION_WITH_MARSHALLING(...) \
2386 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
2387#include "clang/Driver/Options.inc"
2388#undef FILE_SYSTEM_OPTION_WITH_MARSHALLING
2397#define FILE_SYSTEM_OPTION_WITH_MARSHALLING(...) \
2398 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
2399#include "clang/Driver/Options.inc"
2400#undef FILE_SYSTEM_OPTION_WITH_MARSHALLING
2408#define MIGRATOR_OPTION_WITH_MARSHALLING(...) \
2409 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
2410#include "clang/Driver/Options.inc"
2411#undef MIGRATOR_OPTION_WITH_MARSHALLING
2420#define MIGRATOR_OPTION_WITH_MARSHALLING(...) \
2421 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
2422#include "clang/Driver/Options.inc"
2423#undef MIGRATOR_OPTION_WITH_MARSHALLING
2428void CompilerInvocationBase::GenerateDiagnosticArgs(
2430 bool DefaultDiagColor) {
2432#define DIAG_OPTION_WITH_MARSHALLING(...) \
2433 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
2434#include "clang/Driver/Options.inc"
2435#undef DIAG_OPTION_WITH_MARSHALLING
2438 GenerateArg(Consumer, OPT_diagnostic_serialized_file,
2441 if (Opts.ShowColors)
2444 if (Opts.VerifyDiagnostics &&
2449 if (Prefix !=
"expected")
2456 GenerateArg(Consumer, OPT_verify_ignore_unexpected);
2459 GenerateArg(Consumer, OPT_verify_ignore_unexpected_EQ,
"note");
2461 GenerateArg(Consumer, OPT_verify_ignore_unexpected_EQ,
"remark");
2463 GenerateArg(Consumer, OPT_verify_ignore_unexpected_EQ,
"warning");
2465 GenerateArg(Consumer, OPT_verify_ignore_unexpected_EQ,
"error");
2470 if (
Warning ==
"undef-prefix")
2473 if (
Warning ==
"invalid-constexpr" ||
Warning ==
"no-invalid-constexpr")
2475 Consumer(StringRef(
"-W") +
Warning);
2481 StringRef IgnoredRemarks[] = {
"pass",
"no-pass",
2482 "pass-analysis",
"no-pass-analysis",
2483 "pass-missed",
"no-pass-missed"};
2484 if (llvm::is_contained(IgnoredRemarks,
Remark))
2487 Consumer(StringRef(
"-R") +
Remark);
2491std::unique_ptr<DiagnosticOptions>
2493 auto DiagOpts = std::make_unique<DiagnosticOptions>();
2494 unsigned MissingArgIndex, MissingArgCount;
2496 Argv.slice(1), MissingArgIndex, MissingArgCount);
2499 if (std::optional<std::string> NoColor =
2500 llvm::sys::Process::GetEnv(
"NO_COLOR");
2501 NoColor && !NoColor->empty()) {
2516 bool DefaultDiagColor) {
2517 std::optional<DiagnosticsEngine> IgnoringDiags;
2521 Diags = &*IgnoringDiags;
2530#define DIAG_OPTION_WITH_MARSHALLING(...) \
2531 PARSE_OPTION_WITH_MARSHALLING(Args, *Diags, __VA_ARGS__)
2532#include "clang/Driver/Options.inc"
2533#undef DIAG_OPTION_WITH_MARSHALLING
2535 llvm::sys::Process::UseANSIEscapeCodes(Opts.UseANSIEscapeCodes);
2538 Args.getLastArg(OPT_diagnostic_serialized_file, OPT__serialize_diags))
2542 Opts.VerifyDiagnostics = Args.hasArg(OPT_verify) || Args.hasArg(OPT_verify_EQ);
2544 if (Args.hasArg(OPT_verify))
2549 Opts.VerifyDiagnostics =
false;
2554 "-verify-ignore-unexpected=",
2555 Args.getAllArgValues(OPT_verify_ignore_unexpected_EQ), *Diags, DiagMask);
2556 if (Args.hasArg(OPT_verify_ignore_unexpected))
2558 Opts.setVerifyIgnoreUnexpected(DiagMask);
2560 Diags->
Report(diag::warn_ignoring_ftabstop_value)
2576 std::string &BlockName,
2577 unsigned &MajorVersion,
2578 unsigned &MinorVersion,
2580 std::string &UserInfo) {
2582 Arg.split(Args,
':', 5);
2583 if (Args.size() < 5)
2586 BlockName = std::string(Args[0]);
2587 if (Args[1].getAsInteger(10, MajorVersion))
return true;
2588 if (Args[2].getAsInteger(10, MinorVersion))
return true;
2589 if (Args[3].getAsInteger(2, Hashed))
return true;
2590 if (Args.size() > 4)
2591 UserInfo = std::string(Args[4]);
2600 static const std::pair<frontend::ActionKind, unsigned> Table[] = {
2631 OPT_emit_reduced_module_interface},
2649 OPT_print_dependency_directives_minimized_source},
2656static std::optional<frontend::ActionKind>
2659 if (ActionOpt.second == Opt.getID())
2660 return ActionOpt.first;
2662 return std::nullopt;
2666static std::optional<OptSpecifier>
2669 if (ActionOpt.first == ProgramAction)
2670 return OptSpecifier(ActionOpt.second);
2672 return std::nullopt;
2678#define FRONTEND_OPTION_WITH_MARSHALLING(...) \
2679 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
2680#include "clang/Driver/Options.inc"
2681#undef FRONTEND_OPTION_WITH_MARSHALLING
2683 std::optional<OptSpecifier> ProgramActionOpt =
2687 std::function<void()> GenerateProgramAction = [&]() {
2691 if (!ProgramActionOpt) {
2694 "Frontend action without option.");
2695 GenerateProgramAction = [&]() {
2702 GenerateProgramAction = [&]() {
2710 llvm_unreachable(
"Default AST dump format.");
2717 GenerateArg(Consumer, OPT_ast_dump_all_EQ, Format);
2730 GenerateProgramAction = [&]() {
2735 GenerateProgramAction();
2737 for (
const auto &PluginArgs : Opts.
PluginArgs) {
2739 for (
const auto &PluginArg : PluginArgs.second)
2741 Opt.getPrefix() + Opt.getName() + PluginArgs.first,
2742 Opt.getKind(), 0, PluginArg);
2746 if (
auto *TestExt = dyn_cast_or_null<TestModuleFileExtension>(Ext.get()))
2747 GenerateArg(Consumer, OPT_ftest_module_file_extension_EQ, TestExt->str());
2753 for (
const auto &Plugin : Opts.
Plugins)
2759 GenerateArg(Consumer, OPT_fmodule_file, ModuleFile);
2766 GenerateArg(Consumer, OPT_aux_target_feature, Feature);
2772 StringRef HeaderUnit =
"";
2777 HeaderUnit =
"-user";
2780 HeaderUnit =
"-system";
2783 HeaderUnit =
"-header-unit";
2786 StringRef Header = IsHeader ?
"-header" :
"";
2809 Lang =
"objective-c";
2812 Lang =
"objective-c++";
2815 Lang =
"renderscript";
2818 Lang =
"assembler-with-cpp";
2822 "Generating -x argument for unknown language (not precompiled).");
2837 Lang + HeaderUnit + Header +
ModuleMap + Preprocessed);
2841 for (
const auto &Input : Opts.
Inputs)
2842 Consumer(Input.getFile());
2851#define FRONTEND_OPTION_WITH_MARSHALLING(...) \
2852 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
2853#include "clang/Driver/Options.inc"
2854#undef FRONTEND_OPTION_WITH_MARSHALLING
2857 if (
const Arg *A = Args.getLastArg(OPT_Action_Group)) {
2858 OptSpecifier Opt = OptSpecifier(A->getOption().getID());
2860 assert(ProgramAction &&
"Option specifier not in Action_Group.");
2863 (Opt == OPT_ast_dump_all_EQ || Opt == OPT_ast_dump_EQ)) {
2864 unsigned Val = llvm::StringSwitch<unsigned>(A->getValue())
2867 .Default(std::numeric_limits<unsigned>::max());
2869 if (Val != std::numeric_limits<unsigned>::max())
2872 Diags.
Report(diag::err_drv_invalid_value)
2873 << A->getAsString(Args) << A->getValue();
2883 Args.hasArg(OPT_interface_stub_version_EQ)
2884 ? Args.getLastArgValue(OPT_interface_stub_version_EQ)
2886 if (ArgStr ==
"experimental-yaml-elf-v1" ||
2887 ArgStr ==
"experimental-ifs-v1" || ArgStr ==
"experimental-ifs-v2" ||
2888 ArgStr ==
"experimental-tapi-elf-v1") {
2889 std::string ErrorMessage =
2890 "Invalid interface stub format: " + ArgStr.str() +
2892 Diags.
Report(diag::err_drv_invalid_value)
2893 <<
"Must specify a valid interface stub format type, ie: "
2894 "-interface-stub-version=ifs-v1"
2897 }
else if (!ArgStr.starts_with(
"ifs-")) {
2898 std::string ErrorMessage =
2899 "Invalid interface stub format: " + ArgStr.str() +
".";
2900 Diags.
Report(diag::err_drv_invalid_value)
2901 <<
"Must specify a valid interface stub format type, ie: "
2902 "-interface-stub-version=ifs-v1"
2917 if (!A->getSpelling().starts_with(
"-ast-dump")) {
2918 const Arg *SavedAction =
nullptr;
2919 for (
const Arg *AA :
2920 Args.filtered(OPT_Action_Group, OPT_main_file_name)) {
2921 if (AA->getOption().matches(OPT_main_file_name)) {
2922 SavedAction =
nullptr;
2923 }
else if (!SavedAction) {
2926 if (!A->getOption().matches(OPT_ast_dump_EQ))
2927 Diags.
Report(diag::err_fe_invalid_multiple_actions)
2928 << SavedAction->getSpelling() << A->getSpelling();
2935 if (
const Arg* A = Args.getLastArg(OPT_plugin)) {
2936 Opts.
Plugins.emplace_back(A->getValue(0));
2940 for (
const auto *AA : Args.filtered(OPT_plugin_arg))
2941 Opts.
PluginArgs[AA->getValue(0)].emplace_back(AA->getValue(1));
2943 for (
const std::string &Arg :
2944 Args.getAllArgValues(OPT_ftest_module_file_extension_EQ)) {
2945 std::string BlockName;
2946 unsigned MajorVersion;
2947 unsigned MinorVersion;
2949 std::string UserInfo;
2951 MinorVersion, Hashed, UserInfo)) {
2952 Diags.
Report(diag::err_test_module_file_extension_format) << Arg;
2959 std::make_shared<TestModuleFileExtension>(
2960 BlockName, MajorVersion, MinorVersion, Hashed, UserInfo));
2963 if (
const Arg *A = Args.getLastArg(OPT_code_completion_at)) {
2967 Diags.
Report(diag::err_drv_invalid_value)
2968 << A->getAsString(Args) << A->getValue();
2971 Opts.
Plugins = Args.getAllArgValues(OPT_load);
2972 Opts.
ASTDumpDecls = Args.hasArg(OPT_ast_dump, OPT_ast_dump_EQ);
2973 Opts.
ASTDumpAll = Args.hasArg(OPT_ast_dump_all, OPT_ast_dump_all_EQ);
2975 for (
const auto *A : Args.filtered(OPT_fmodule_file)) {
2976 StringRef Val = A->getValue();
2977 if (!Val.contains(
'='))
2982 Diags.
Report(diag::err_drv_argument_only_allowed_with) <<
"-fsystem-module"
2984 if (Args.hasArg(OPT_fclangir) || Args.hasArg(OPT_emit_cir))
2987 if (Args.hasArg(OPT_aux_target_cpu))
2988 Opts.
AuxTargetCPU = std::string(Args.getLastArgValue(OPT_aux_target_cpu));
2989 if (Args.hasArg(OPT_aux_target_feature))
2994 Diags.
Report(diag::err_drv_argument_not_allowed_with)
2995 <<
"ARC migration" <<
"ObjC migration";
2999 if (
const Arg *A = Args.getLastArg(OPT_x)) {
3000 StringRef XValue = A->getValue();
3005 bool Preprocessed = XValue.consume_back(
"-cpp-output");
3006 bool ModuleMap = XValue.consume_back(
"-module-map");
3009 XValue !=
"precompiled-header" && XValue.consume_back(
"-header");
3015 if (IsHeader || Preprocessed) {
3016 if (XValue.consume_back(
"-header-unit"))
3018 else if (XValue.consume_back(
"-system"))
3020 else if (XValue.consume_back(
"-user"))
3026 IsHeaderFile = IsHeader && !Preprocessed && !
ModuleMap &&
3030 DashX = llvm::StringSwitch<InputKind>(XValue)
3047 DashX = llvm::StringSwitch<InputKind>(XValue)
3055 DashX = llvm::StringSwitch<InputKind>(XValue)
3058 .Cases(
"ast",
"pcm",
"precompiled-header",
3065 Diags.
Report(diag::err_drv_invalid_value)
3066 << A->getAsString(Args) << A->getValue();
3073 IsHeaderFile =
true;
3074 }
else if (IsHeaderFile)
3081 std::vector<std::string> Inputs = Args.getAllArgValues(OPT_INPUT);
3084 Inputs.push_back(
"-");
3088 Diags.
Report(diag::err_drv_header_unit_extra_inputs) << Inputs[1];
3090 for (
unsigned i = 0, e = Inputs.size(); i != e; ++i) {
3094 StringRef(Inputs[i]).rsplit(
'.').second);
3103 bool IsSystem =
false;
3112 Opts.
Inputs.emplace_back(std::move(Inputs[i]), IK, IsSystem);
3122 std::string ClangExecutable =
3123 llvm::sys::fs::getMainExecutable(Argv0, MainAddr);
3130#define HEADER_SEARCH_OPTION_WITH_MARSHALLING(...) \
3131 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
3132#include "clang/Driver/Options.inc"
3133#undef HEADER_SEARCH_OPTION_WITH_MARSHALLING
3148 GenerateArg(Consumer, OPT_fmodules_ignore_macro, Macro.val());
3152 std::optional<bool> IsFramework,
3153 std::optional<bool> IgnoreSysRoot) {
3154 return llvm::is_contained(Groups, Entry.
Group) &&
3155 (!IsFramework || (Entry.
IsFramework == *IsFramework)) &&
3156 (!IgnoreSysRoot || (Entry.
IgnoreSysRoot == *IgnoreSysRoot));
3164 std::nullopt,
true);
3166 OptSpecifier Opt = [It, Matches]() {
3175 llvm_unreachable(
"Unexpected HeaderSearchOptions::Entry.");
3191 It->Group ==
frontend::After ? OPT_iwithprefix : OPT_iwithprefixbefore;
3198 for (; It < End && Matches(*It, {
frontend::After},
false,
true); ++It)
3204 GenerateArg(Consumer, It->IgnoreSysRoot ? OPT_isystem : OPT_iwithsysroot,
3209 GenerateArg(Consumer, OPT_iframeworkwithsysroot, It->Path);
3217 GenerateArg(Consumer, OPT_objc_isystem, It->Path);
3219 GenerateArg(Consumer, OPT_objcxx_isystem, It->Path);
3229 ? OPT_internal_isystem
3230 : OPT_internal_externc_isystem;
3234 assert(It == End &&
"Unhandled HeaderSearchOption::Entry.");
3238 OptSpecifier Opt =
P.IsSystemHeader ? OPT_system_header_prefix
3239 : OPT_no_system_header_prefix;
3249 const std::string &WorkingDir) {
3254#define HEADER_SEARCH_OPTION_WITH_MARSHALLING(...) \
3255 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
3256#include "clang/Driver/Options.inc"
3257#undef HEADER_SEARCH_OPTION_WITH_MARSHALLING
3259 if (
const Arg *A = Args.getLastArg(OPT_stdlib_EQ))
3260 Opts.
UseLibcxx = (strcmp(A->getValue(),
"libc++") == 0);
3264 if (!(
P.empty() || llvm::sys::path::is_absolute(
P))) {
3265 if (WorkingDir.empty())
3266 llvm::sys::fs::make_absolute(
P);
3268 llvm::sys::fs::make_absolute(WorkingDir,
P);
3270 llvm::sys::path::remove_dots(
P);
3274 for (
const auto *A : Args.filtered(OPT_fmodule_file)) {
3275 StringRef Val = A->getValue();
3276 if (Val.contains(
'=')) {
3277 auto Split = Val.split(
'=');
3279 std::string(Split.first), std::string(Split.second));
3282 for (
const auto *A : Args.filtered(OPT_fprebuilt_module_path))
3285 for (
const auto *A : Args.filtered(OPT_fmodules_ignore_macro)) {
3286 StringRef MacroDef = A->getValue();
3288 llvm::CachedHashString(MacroDef.split(
'=').first));
3292 bool IsIndexHeaderMap =
false;
3293 bool IsSysrootSpecified =
3294 Args.hasArg(OPT__sysroot_EQ) || Args.hasArg(OPT_isysroot);
3298 auto PrefixHeaderPath = [IsSysrootSpecified,
3299 &Opts](
const llvm::opt::Arg *A,
3300 bool IsFramework =
false) -> std::string {
3301 assert(A->getNumValues() &&
"Unexpected empty search path flag!");
3302 if (IsSysrootSpecified && !IsFramework && A->getValue()[0] ==
'=') {
3304 llvm::sys::path::append(Buffer, Opts.
Sysroot,
3305 llvm::StringRef(A->getValue()).substr(1));
3306 return std::string(Buffer);
3308 return A->getValue();
3311 for (
const auto *A : Args.filtered(OPT_I, OPT_F, OPT_index_header_map)) {
3312 if (A->getOption().matches(OPT_index_header_map)) {
3314 IsIndexHeaderMap =
true;
3321 bool IsFramework = A->getOption().matches(OPT_F);
3322 Opts.
AddPath(PrefixHeaderPath(A, IsFramework), Group, IsFramework,
3324 IsIndexHeaderMap =
false;
3328 StringRef Prefix =
"";
3329 for (
const auto *A :
3330 Args.filtered(OPT_iprefix, OPT_iwithprefix, OPT_iwithprefixbefore)) {
3331 if (A->getOption().matches(OPT_iprefix))
3332 Prefix = A->getValue();
3333 else if (A->getOption().matches(OPT_iwithprefix))
3339 for (
const auto *A : Args.filtered(OPT_idirafter))
3341 for (
const auto *A : Args.filtered(OPT_iquote))
3344 for (
const auto *A : Args.filtered(OPT_isystem, OPT_iwithsysroot)) {
3345 if (A->getOption().matches(OPT_iwithsysroot)) {
3352 for (
const auto *A : Args.filtered(OPT_iframework))
3354 for (
const auto *A : Args.filtered(OPT_iframeworkwithsysroot))
3359 for (
const auto *A : Args.filtered(OPT_c_isystem))
3361 for (
const auto *A : Args.filtered(OPT_cxx_isystem))
3363 for (
const auto *A : Args.filtered(OPT_objc_isystem))
3365 for (
const auto *A : Args.filtered(OPT_objcxx_isystem))
3369 for (
const auto *A :
3370 Args.filtered(OPT_internal_isystem, OPT_internal_externc_isystem)) {
3372 if (A->getOption().matches(OPT_internal_externc_isystem))
3374 Opts.
AddPath(A->getValue(), Group,
false,
true);
3378 for (
const auto *A :
3379 Args.filtered(OPT_system_header_prefix, OPT_no_system_header_prefix))
3381 A->getValue(), A->getOption().matches(OPT_system_header_prefix));
3383 for (
const auto *A : Args.filtered(OPT_ivfsoverlay, OPT_vfsoverlay))
3392 GenerateArg(Consumer, OPT_fapinotes_swift_version,
3401 if (
const Arg *A = Args.getLastArg(OPT_fapinotes_swift_version)) {
3403 diags.
Report(diag::err_drv_invalid_value)
3404 << A->getAsString(Args) << A->getValue();
3406 for (
const Arg *A : Args.filtered(OPT_iapinotes_modules))
3412 if (Opts.PointerAuthIntrinsics)
3414 if (Opts.PointerAuthCalls)
3416 if (Opts.PointerAuthReturns)
3418 if (Opts.PointerAuthIndirectGotos)
3419 GenerateArg(Consumer, OPT_fptrauth_indirect_gotos);
3420 if (Opts.PointerAuthAuthTraps)
3422 if (Opts.PointerAuthVTPtrAddressDiscrimination)
3423 GenerateArg(Consumer, OPT_fptrauth_vtable_pointer_address_discrimination);
3424 if (Opts.PointerAuthVTPtrTypeDiscrimination)
3425 GenerateArg(Consumer, OPT_fptrauth_vtable_pointer_type_discrimination);
3426 if (Opts.PointerAuthTypeInfoVTPtrDiscrimination)
3427 GenerateArg(Consumer, OPT_fptrauth_type_info_vtable_pointer_discrimination);
3429 if (Opts.PointerAuthInitFini)
3431 if (Opts.PointerAuthFunctionTypeDiscrimination)
3432 GenerateArg(Consumer, OPT_fptrauth_function_pointer_type_discrimination);
3437 Opts.PointerAuthIntrinsics = Args.hasArg(OPT_fptrauth_intrinsics);
3438 Opts.PointerAuthCalls = Args.hasArg(OPT_fptrauth_calls);
3439 Opts.PointerAuthReturns = Args.hasArg(OPT_fptrauth_returns);
3440 Opts.PointerAuthIndirectGotos = Args.hasArg(OPT_fptrauth_indirect_gotos);
3441 Opts.PointerAuthAuthTraps = Args.hasArg(OPT_fptrauth_auth_traps);
3442 Opts.PointerAuthVTPtrAddressDiscrimination =
3443 Args.hasArg(OPT_fptrauth_vtable_pointer_address_discrimination);
3444 Opts.PointerAuthVTPtrTypeDiscrimination =
3445 Args.hasArg(OPT_fptrauth_vtable_pointer_type_discrimination);
3446 Opts.PointerAuthTypeInfoVTPtrDiscrimination =
3447 Args.hasArg(OPT_fptrauth_type_info_vtable_pointer_discrimination);
3449 Opts.PointerAuthInitFini = Args.hasArg(OPT_fptrauth_init_fini);
3450 Opts.PointerAuthFunctionTypeDiscrimination =
3451 Args.hasArg(OPT_fptrauth_function_pointer_type_discrimination);
3461 llvm_unreachable(
"should not parse language flags for this input");
3497 llvm_unreachable(
"unexpected input language");
3506 return "Objective-C";
3510 return "Objective-C++";
3514 return "C++ for OpenCL";
3518 return "RenderScript";
3535 llvm_unreachable(
"unknown input language");
3538void CompilerInvocationBase::GenerateLangArgs(
const LangOptions &Opts,
3540 const llvm::Triple &
T,
3545 if (Opts.ObjCAutoRefCount)
3547 if (Opts.PICLevel != 0)
3548 GenerateArg(Consumer, OPT_pic_level, Twine(Opts.PICLevel));
3552 GenerateArg(Consumer, OPT_fsanitize_EQ, Sanitizer);
3557 OptSpecifier StdOpt;
3559 case LangStandard::lang_opencl10:
3560 case LangStandard::lang_opencl11:
3561 case LangStandard::lang_opencl12:
3562 case LangStandard::lang_opencl20:
3563 case LangStandard::lang_opencl30:
3564 case LangStandard::lang_openclcpp10:
3565 case LangStandard::lang_openclcpp2021:
3566 StdOpt = OPT_cl_std_EQ;
3569 StdOpt = OPT_std_EQ;
3576 if (Opts.IncludeDefaultHeader)
3577 GenerateArg(Consumer, OPT_finclude_default_header);
3578 if (Opts.DeclareOpenCLBuiltins)
3579 GenerateArg(Consumer, OPT_fdeclare_opencl_builtins);
3583#define LANG_OPTION_WITH_MARSHALLING(...) \
3584 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
3585#include "clang/Driver/Options.inc"
3586#undef LANG_OPTION_WITH_MARSHALLING
3597 else if (Opts.ObjCAutoRefCount == 1)
3600 if (Opts.ObjCWeakRuntime)
3601 GenerateArg(Consumer, OPT_fobjc_runtime_has_weak);
3606 if (Opts.ObjCSubscriptingLegacyRuntime)
3607 GenerateArg(Consumer, OPT_fobjc_subscripting_legacy_runtime);
3610 if (Opts.GNUCVersion != 0) {
3611 unsigned Major = Opts.GNUCVersion / 100 / 100;
3612 unsigned Minor = (Opts.GNUCVersion / 100) % 100;
3613 unsigned Patch = Opts.GNUCVersion % 100;
3615 Twine(Major) +
"." + Twine(Minor) +
"." + Twine(Patch));
3618 if (Opts.IgnoreXCOFFVisibility)
3619 GenerateArg(Consumer, OPT_mignore_xcoff_visibility);
3628 if (Opts.MSCompatibilityVersion != 0) {
3629 unsigned Major = Opts.MSCompatibilityVersion / 10000000;
3630 unsigned Minor = (Opts.MSCompatibilityVersion / 100000) % 100;
3631 unsigned Subminor = Opts.MSCompatibilityVersion % 100000;
3632 GenerateArg(Consumer, OPT_fms_compatibility_version,
3633 Twine(Major) +
"." + Twine(Minor) +
"." + Twine(Subminor));
3636 if ((!Opts.GNUMode && !Opts.MSVCCompat && !Opts.CPlusPlus17 && !Opts.C23) ||
3638 if (!Opts.Trigraphs)
3645 if (Opts.Blocks && !(Opts.OpenCL && Opts.OpenCLVersion == 200))
3648 if (Opts.ConvergentFunctions &&
3649 !(Opts.OpenCL || (Opts.CUDA && Opts.CUDAIsDevice) || Opts.SYCLIsDevice ||
3653 if (Opts.NoBuiltin && !Opts.Freestanding)
3656 if (!Opts.NoBuiltin)
3660 if (Opts.LongDoubleSize == 128)
3662 else if (Opts.LongDoubleSize == 64)
3664 else if (Opts.LongDoubleSize == 80)
3671 if (Opts.OpenMP && !Opts.OpenMPSimd) {
3674 if (Opts.OpenMP != 51)
3675 GenerateArg(Consumer, OPT_fopenmp_version_EQ, Twine(Opts.OpenMP));
3677 if (!Opts.OpenMPUseTLS)
3680 if (Opts.OpenMPIsTargetDevice)
3681 GenerateArg(Consumer, OPT_fopenmp_is_target_device);
3683 if (Opts.OpenMPIRBuilder)
3684 GenerateArg(Consumer, OPT_fopenmp_enable_irbuilder);
3687 if (Opts.OpenMPSimd) {
3690 if (Opts.OpenMP != 51)
3691 GenerateArg(Consumer, OPT_fopenmp_version_EQ, Twine(Opts.OpenMP));
3694 if (Opts.OpenMPThreadSubscription)
3695 GenerateArg(Consumer, OPT_fopenmp_assume_threads_oversubscription);
3697 if (Opts.OpenMPTeamSubscription)
3698 GenerateArg(Consumer, OPT_fopenmp_assume_teams_oversubscription);
3700 if (Opts.OpenMPTargetDebug != 0)
3701 GenerateArg(Consumer, OPT_fopenmp_target_debug_EQ,
3702 Twine(Opts.OpenMPTargetDebug));
3704 if (Opts.OpenMPCUDANumSMs != 0)
3705 GenerateArg(Consumer, OPT_fopenmp_cuda_number_of_sm_EQ,
3706 Twine(Opts.OpenMPCUDANumSMs));
3708 if (Opts.OpenMPCUDABlocksPerSM != 0)
3709 GenerateArg(Consumer, OPT_fopenmp_cuda_blocks_per_sm_EQ,
3710 Twine(Opts.OpenMPCUDABlocksPerSM));
3712 if (Opts.OpenMPCUDAReductionBufNum != 1024)
3713 GenerateArg(Consumer, OPT_fopenmp_cuda_teams_reduction_recs_num_EQ,
3714 Twine(Opts.OpenMPCUDAReductionBufNum));
3717 std::string Targets;
3718 llvm::raw_string_ostream OS(Targets);
3721 [&OS](
const llvm::Triple &
T) { OS << T.str(); },
",");
3722 GenerateArg(Consumer, OPT_fopenmp_targets_EQ, OS.str());
3728 if (Opts.OpenMPCUDAMode)
3748 GenerateArg(Consumer, OPT_ffp_contract,
"fast-honor-pragmas");
3751 GenerateArg(Consumer, OPT_fsanitize_EQ, Sanitizer);
3755 GenerateArg(Consumer, OPT_fsanitize_ignorelist_EQ, F);
3757 switch (Opts.getClangABICompat()) {
3759 GenerateArg(Consumer, OPT_fclang_abi_compat_EQ,
"3.8");
3762 GenerateArg(Consumer, OPT_fclang_abi_compat_EQ,
"4.0");
3765 GenerateArg(Consumer, OPT_fclang_abi_compat_EQ,
"6.0");
3768 GenerateArg(Consumer, OPT_fclang_abi_compat_EQ,
"7.0");
3771 GenerateArg(Consumer, OPT_fclang_abi_compat_EQ,
"9.0");
3774 GenerateArg(Consumer, OPT_fclang_abi_compat_EQ,
"11.0");
3777 GenerateArg(Consumer, OPT_fclang_abi_compat_EQ,
"12.0");
3780 GenerateArg(Consumer, OPT_fclang_abi_compat_EQ,
"14.0");
3783 GenerateArg(Consumer, OPT_fclang_abi_compat_EQ,
"15.0");
3786 GenerateArg(Consumer, OPT_fclang_abi_compat_EQ,
"17.0");
3789 GenerateArg(Consumer, OPT_fclang_abi_compat_EQ,
"18.0");
3795 if (Opts.getSignReturnAddressScope() ==
3797 GenerateArg(Consumer, OPT_msign_return_address_EQ,
"all");
3798 else if (Opts.getSignReturnAddressScope() ==
3800 GenerateArg(Consumer, OPT_msign_return_address_EQ,
"non-leaf");
3802 if (Opts.getSignReturnAddressKey() ==
3804 GenerateArg(Consumer, OPT_msign_return_address_key_EQ,
"b_key");
3810 if (Opts.RelativeCXXABIVTables)
3811 GenerateArg(Consumer, OPT_fexperimental_relative_cxx_abi_vtables);
3813 GenerateArg(Consumer, OPT_fno_experimental_relative_cxx_abi_vtables);
3821 GenerateArg(Consumer, OPT_fmacro_prefix_map_EQ, MP.first +
"=" + MP.second);
3827bool CompilerInvocation::ParseLangArgs(
LangOptions &Opts, ArgList &Args,
3829 std::vector<std::string> &Includes,
3839 if (Args.hasArg(OPT_fobjc_arc))
3840 Opts.ObjCAutoRefCount = 1;
3844 Opts.PIE = Args.hasArg(OPT_pic_is_pie);
3856 if (
const Arg *A = Args.getLastArg(OPT_std_EQ)) {
3859 Diags.
Report(diag::err_drv_invalid_value)
3860 << A->getAsString(Args) << A->getValue();
3862 for (
unsigned KindValue = 0;
3868 auto Diag = Diags.
Report(diag::note_drv_use_standard);
3869 Diag <<
Std.getName() <<
Std.getDescription();
3870 unsigned NumAliases = 0;
3871#define LANGSTANDARD(id, name, lang, desc, features)
3872#define LANGSTANDARD_ALIAS(id, alias) \
3873 if (KindValue == LangStandard::lang_##id) ++NumAliases;
3874#define LANGSTANDARD_ALIAS_DEPR(id, alias)
3875#include "clang/Basic/LangStandards.def"
3877#define LANGSTANDARD(id, name, lang, desc, features)
3878#define LANGSTANDARD_ALIAS(id, alias) \
3879 if (KindValue == LangStandard::lang_##id) Diag << alias;
3880#define LANGSTANDARD_ALIAS_DEPR(id, alias)
3881#include "clang/Basic/LangStandards.def"
3889 Diags.
Report(diag::err_drv_argument_not_allowed_with)
3897 if (
const Arg *A = Args.getLastArg(OPT_cl_std_EQ)) {
3899 = llvm::StringSwitch<LangStandard::Kind>(A->getValue())
3900 .Cases(
"cl",
"CL", LangStandard::lang_opencl10)
3901 .Cases(
"cl1.0",
"CL1.0", LangStandard::lang_opencl10)
3902 .Cases(
"cl1.1",
"CL1.1", LangStandard::lang_opencl11)
3903 .Cases(
"cl1.2",
"CL1.2", LangStandard::lang_opencl12)
3904 .Cases(
"cl2.0",
"CL2.0", LangStandard::lang_opencl20)
3905 .Cases(
"cl3.0",
"CL3.0", LangStandard::lang_opencl30)
3906 .Cases(
"clc++",
"CLC++", LangStandard::lang_openclcpp10)
3907 .Cases(
"clc++1.0",
"CLC++1.0", LangStandard::lang_openclcpp10)
3908 .Cases(
"clc++2021",
"CLC++2021", LangStandard::lang_openclcpp2021)
3912 Diags.
Report(diag::err_drv_invalid_value)
3913 << A->getAsString(Args) << A->getValue();
3916 LangStd = OpenCLLangStd;
3920 Opts.IncludeDefaultHeader = Args.hasArg(OPT_finclude_default_header);
3921 Opts.DeclareOpenCLBuiltins = Args.hasArg(OPT_fdeclare_opencl_builtins);
3929#define LANG_OPTION_WITH_MARSHALLING(...) \
3930 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
3931#include "clang/Driver/Options.inc"
3932#undef LANG_OPTION_WITH_MARSHALLING
3934 if (
const Arg *A = Args.getLastArg(OPT_fcf_protection_EQ)) {
3935 StringRef Name = A->getValue();
3936 if (Name ==
"full" || Name ==
"branch") {
3937 Opts.CFProtectionBranch = 1;
3941 if ((Args.hasArg(OPT_fsycl_is_device) || Args.hasArg(OPT_fsycl_is_host)) &&
3942 !Args.hasArg(OPT_sycl_std_EQ)) {
3952 if (Arg *arg = Args.getLastArg(OPT_fobjc_runtime_EQ)) {
3953 StringRef value =
arg->getValue();
3955 Diags.
Report(diag::err_drv_unknown_objc_runtime) << value;
3958 if (Args.hasArg(OPT_fobjc_gc_only))
3960 else if (Args.hasArg(OPT_fobjc_gc))
3962 else if (Args.hasArg(OPT_fobjc_arc)) {
3963 Opts.ObjCAutoRefCount = 1;
3965 Diags.
Report(diag::err_arc_unsupported_on_runtime);
3972 if (Args.hasArg(OPT_fobjc_runtime_has_weak))
3973 Opts.ObjCWeakRuntime = 1;
3979 if (
auto weakArg = Args.getLastArg(OPT_fobjc_weak, OPT_fno_objc_weak)) {
3980 if (!weakArg->getOption().matches(OPT_fobjc_weak)) {
3981 assert(!Opts.ObjCWeak);
3983 Diags.
Report(diag::err_objc_weak_with_gc);
3984 }
else if (!Opts.ObjCWeakRuntime) {
3985 Diags.
Report(diag::err_objc_weak_unsupported);
3989 }
else if (Opts.ObjCAutoRefCount) {
3990 Opts.ObjCWeak = Opts.ObjCWeakRuntime;
3993 if (Args.hasArg(OPT_fobjc_subscripting_legacy_runtime))
3994 Opts.ObjCSubscriptingLegacyRuntime =
3998 if (Arg *A = Args.getLastArg(options::OPT_fgnuc_version_EQ)) {
4001 VersionTuple GNUCVer;
4002 bool Invalid = GNUCVer.tryParse(A->getValue());
4003 unsigned Major = GNUCVer.getMajor();
4004 unsigned Minor = GNUCVer.getMinor().value_or(0);
4005 unsigned Patch = GNUCVer.getSubminor().value_or(0);
4006 if (
Invalid || GNUCVer.getBuild() || Minor >= 100 || Patch >= 100) {
4007 Diags.
Report(diag::err_drv_invalid_value)
4008 << A->getAsString(Args) << A->getValue();
4010 Opts.GNUCVersion = Major * 100 * 100 + Minor * 100 + Patch;
4013 if (
T.isOSAIX() && (Args.hasArg(OPT_mignore_xcoff_visibility)))
4014 Opts.IgnoreXCOFFVisibility = 1;
4016 if (Args.hasArg(OPT_ftrapv)) {
4020 std::string(Args.getLastArgValue(OPT_ftrapv_handler));
4022 else if (Args.hasArg(OPT_fwrapv))
4025 Opts.MSCompatibilityVersion = 0;
4026 if (
const Arg *A = Args.getLastArg(OPT_fms_compatibility_version)) {
4028 if (VT.tryParse(A->getValue()))
4029 Diags.
Report(diag::err_drv_invalid_value) << A->getAsString(Args)
4031 Opts.MSCompatibilityVersion = VT.getMajor() * 10000000 +
4032 VT.getMinor().value_or(0) * 100000 +
4033 VT.getSubminor().value_or(0);
4041 (!Opts.GNUMode && !Opts.MSVCCompat && !Opts.CPlusPlus17 && !Opts.C23) ||
4044 Args.hasFlag(OPT_ftrigraphs, OPT_fno_trigraphs, Opts.Trigraphs);
4046 Opts.Blocks = Args.hasArg(OPT_fblocks) || (Opts.OpenCL
4047 && Opts.OpenCLVersion == 200);
4049 Opts.ConvergentFunctions = Args.hasArg(OPT_fconvergent_functions) ||
4050 Opts.OpenCL || (Opts.CUDA && Opts.CUDAIsDevice) ||
4051 Opts.SYCLIsDevice || Opts.HLSL;
4053 Opts.NoBuiltin = Args.hasArg(OPT_fno_builtin) || Opts.Freestanding;
4054 if (!Opts.NoBuiltin)
4056 if (Arg *A = Args.getLastArg(options::OPT_LongDouble_Group)) {
4057 if (A->getOption().matches(options::OPT_mlong_double_64))
4058 Opts.LongDoubleSize = 64;
4059 else if (A->getOption().matches(options::OPT_mlong_double_80))
4060 Opts.LongDoubleSize = 80;
4061 else if (A->getOption().matches(options::OPT_mlong_double_128))
4062 Opts.LongDoubleSize = 128;
4064 Opts.LongDoubleSize = 0;
4066 if (Opts.FastRelaxedMath || Opts.CLUnsafeMath)
4072 if (Arg *A = Args.getLastArg(OPT_mrtd)) {
4074 Diags.
Report(diag::err_drv_argument_not_allowed_with)
4075 << A->getSpelling() <<
"-fdefault-calling-conv";
4077 switch (
T.getArch()) {
4078 case llvm::Triple::x86:
4081 case llvm::Triple::m68k:
4085 Diags.
Report(diag::err_drv_argument_not_allowed_with)
4086 << A->getSpelling() <<
T.getTriple();
4092 Opts.OpenMP = Args.hasArg(OPT_fopenmp) ? 51 : 0;
4094 bool IsSimdSpecified =
4095 Args.hasFlag(options::OPT_fopenmp_simd, options::OPT_fno_openmp_simd,
4097 Opts.OpenMPSimd = !Opts.OpenMP && IsSimdSpecified;
4099 Opts.OpenMP && !Args.hasArg(options::OPT_fnoopenmp_use_tls);
4100 Opts.OpenMPIsTargetDevice =
4101 Opts.OpenMP && Args.hasArg(options::OPT_fopenmp_is_target_device);
4102 Opts.OpenMPIRBuilder =
4103 Opts.OpenMP && Args.hasArg(options::OPT_fopenmp_enable_irbuilder);
4104 bool IsTargetSpecified =
4105 Opts.OpenMPIsTargetDevice || Args.hasArg(options::OPT_fopenmp_targets_EQ);
4107 Opts.ConvergentFunctions =
4108 Opts.ConvergentFunctions || Opts.OpenMPIsTargetDevice;
4110 if (Opts.OpenMP || Opts.OpenMPSimd) {
4112 Args, OPT_fopenmp_version_EQ,
4113 (IsSimdSpecified || IsTargetSpecified) ? 51 : Opts.OpenMP, Diags))
4114 Opts.OpenMP = Version;
4117 if (!Opts.OpenMPIsTargetDevice) {
4118 switch (
T.getArch()) {
4122 case llvm::Triple::nvptx:
4123 case llvm::Triple::nvptx64:
4124 Diags.
Report(diag::err_drv_omp_host_target_not_supported) <<
T.str();
4132 if ((Opts.OpenMPIsTargetDevice && (
T.isNVPTX() ||
T.isAMDGCN())) ||
4133 Opts.OpenCLCPlusPlus) {
4135 Opts.Exceptions = 0;
4136 Opts.CXXExceptions = 0;
4138 if (Opts.OpenMPIsTargetDevice &&
T.isNVPTX()) {
4139 Opts.OpenMPCUDANumSMs =
4141 Opts.OpenMPCUDANumSMs, Diags);
4142 Opts.OpenMPCUDABlocksPerSM =
4144 Opts.OpenMPCUDABlocksPerSM, Diags);
4146 Args, options::OPT_fopenmp_cuda_teams_reduction_recs_num_EQ,
4147 Opts.OpenMPCUDAReductionBufNum, Diags);
4152 if (Opts.OpenMPIsTargetDevice && (Args.hasArg(OPT_fopenmp_target_debug) ||
4153 Args.hasArg(OPT_fopenmp_target_debug_EQ))) {
4155 Args, OPT_fopenmp_target_debug_EQ, Opts.OpenMPTargetDebug, Diags);
4156 if (!Opts.OpenMPTargetDebug && Args.hasArg(OPT_fopenmp_target_debug))
4157 Opts.OpenMPTargetDebug = 1;
4160 if (Opts.OpenMPIsTargetDevice) {
4161 if (Args.hasArg(OPT_fopenmp_assume_teams_oversubscription))
4162 Opts.OpenMPTeamSubscription =
true;
4163 if (Args.hasArg(OPT_fopenmp_assume_threads_oversubscription))
4164 Opts.OpenMPThreadSubscription =
true;
4168 if (Arg *A = Args.getLastArg(options::OPT_fopenmp_targets_EQ)) {
4169 enum ArchPtrSize { Arch16Bit, Arch32Bit, Arch64Bit };
4170 auto getArchPtrSize = [](
const llvm::Triple &
T) {
4171 if (
T.isArch16Bit())
4173 if (
T.isArch32Bit())
4175 assert(
T.isArch64Bit() &&
"Expected 64-bit architecture");
4179 for (
unsigned i = 0; i < A->getNumValues(); ++i) {
4180 llvm::Triple TT(A->getValue(i));
4182 if (TT.getArch() == llvm::Triple::UnknownArch ||
4183 !(TT.getArch() == llvm::Triple::aarch64 || TT.isPPC() ||
4184 TT.getArch() == llvm::Triple::systemz ||
4185 TT.getArch() == llvm::Triple::nvptx ||
4186 TT.getArch() == llvm::Triple::nvptx64 ||
4187 TT.getArch() == llvm::Triple::amdgcn ||
4188 TT.getArch() == llvm::Triple::x86 ||
4189 TT.getArch() == llvm::Triple::x86_64))
4190 Diags.
Report(diag::err_drv_invalid_omp_target) << A->getValue(i);
4191 else if (getArchPtrSize(
T) != getArchPtrSize(TT))
4192 Diags.
Report(diag::err_drv_incompatible_omp_arch)
4193 << A->getValue(i) <<
T.str();
4201 if (Arg *A = Args.getLastArg(options::OPT_fopenmp_host_ir_file_path)) {
4204 Diags.
Report(diag::err_drv_omp_host_ir_file_not_found)
4209 Opts.OpenMPCUDAMode = Opts.OpenMPIsTargetDevice &&
4210 (
T.isNVPTX() ||
T.isAMDGCN()) &&
4211 Args.hasArg(options::OPT_fopenmp_cuda_mode);
4214 if (Args.hasArg(options::OPT_fopenacc)) {
4215 Opts.OpenACC =
true;
4217 if (Arg *A = Args.getLastArg(options::OPT_openacc_macro_override))
4224 Opts.Optimize = Opt != 0;
4225 Opts.OptimizeSize = OptSize != 0;
4230 Opts.NoInlineDefine = !Opts.Optimize;
4231 if (Arg *InlineArg = Args.getLastArg(
4232 options::OPT_finline_functions, options::OPT_finline_hint_functions,
4233 options::OPT_fno_inline_functions, options::OPT_fno_inline))
4234 if (InlineArg->getOption().matches(options::OPT_fno_inline))
4235 Opts.NoInlineDefine =
true;
4237 if (Arg *A = Args.getLastArg(OPT_ffp_contract)) {
4238 StringRef Val = A->getValue();
4241 else if (Val ==
"on")
4243 else if (Val ==
"off")
4245 else if (Val ==
"fast-honor-pragmas")
4248 Diags.
Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Val;
4254 Opts.
NoSanitizeFiles = Args.getAllArgValues(OPT_fsanitize_ignorelist_EQ);
4255 std::vector<std::string> systemIgnorelists =
4256 Args.getAllArgValues(OPT_fsanitize_system_ignorelist_EQ);
4258 systemIgnorelists.begin(),
4259 systemIgnorelists.end());
4261 if (Arg *A = Args.getLastArg(OPT_fclang_abi_compat_EQ)) {
4264 StringRef Ver = A->getValue();
4265 std::pair<StringRef, StringRef> VerParts = Ver.split(
'.');
4266 unsigned Major, Minor = 0;
4270 if (!VerParts.first.starts_with(
"0") &&
4271 !VerParts.first.getAsInteger(10, Major) && 3 <= Major &&
4272 Major <= CLANG_VERSION_MAJOR &&
4274 ? VerParts.second.size() == 1 &&
4275 !VerParts.second.getAsInteger(10, Minor)
4276 : VerParts.first.size() == Ver.size() || VerParts.second ==
"0")) {
4278 if (Major == 3 && Minor <= 8)
4280 else if (Major <= 4)
4282 else if (Major <= 6)
4284 else if (Major <= 7)
4286 else if (Major <= 9)
4288 else if (Major <= 11)
4290 else if (Major <= 12)
4292 else if (Major <= 14)
4294 else if (Major <= 15)
4296 else if (Major <= 17)
4298 else if (Major <= 18)
4300 }
else if (Ver !=
"latest") {
4301 Diags.
Report(diag::err_drv_invalid_value)
4302 << A->getAsString(Args) << A->getValue();
4306 if (Arg *A = Args.getLastArg(OPT_msign_return_address_EQ)) {
4307 StringRef SignScope = A->getValue();
4309 if (SignScope.equals_insensitive(
"none"))
4310 Opts.setSignReturnAddressScope(
4312 else if (SignScope.equals_insensitive(
"all"))
4313 Opts.setSignReturnAddressScope(
4315 else if (SignScope.equals_insensitive(
"non-leaf"))
4316 Opts.setSignReturnAddressScope(
4319 Diags.
Report(diag::err_drv_invalid_value)
4320 << A->getAsString(Args) << SignScope;
4322 if (Arg *A = Args.getLastArg(OPT_msign_return_address_key_EQ)) {
4323 StringRef SignKey = A->getValue();
4324 if (!SignScope.empty() && !SignKey.empty()) {
4325 if (SignKey ==
"a_key")
4326 Opts.setSignReturnAddressKey(
4328 else if (SignKey ==
"b_key")
4329 Opts.setSignReturnAddressKey(
4332 Diags.
Report(diag::err_drv_invalid_value)
4333 << A->getAsString(Args) << SignKey;
4339 StringRef
CXXABI = Args.getLastArgValue(OPT_fcxx_abi_EQ);
4346 Diags.
Report(diag::err_unsupported_cxx_abi) <<
CXXABI <<
T.str();
4352 Opts.RelativeCXXABIVTables =
4353 Args.hasFlag(options::OPT_fexperimental_relative_cxx_abi_vtables,
4354 options::OPT_fno_experimental_relative_cxx_abi_vtables,
4358 bool HasRTTI = !Args.hasArg(options::OPT_fno_rtti);
4359 Opts.OmitVTableRTTI =
4360 Args.hasFlag(options::OPT_fexperimental_omit_vtable_rtti,
4361 options::OPT_fno_experimental_omit_vtable_rtti,
false);
4362 if (Opts.OmitVTableRTTI && HasRTTI)
4363 Diags.
Report(diag::err_drv_using_omit_rtti_component_without_no_rtti);
4365 for (
const auto &A : Args.getAllArgValues(OPT_fmacro_prefix_map_EQ)) {
4366 auto Split = StringRef(A).split(
'=');
4368 {std::string(
Split.first), std::string(
Split.second)});
4372 !Args.getLastArg(OPT_fno_file_reproducible) &&
4373 (Args.getLastArg(OPT_ffile_compilation_dir_EQ) ||
4374 Args.getLastArg(OPT_fmacro_prefix_map_EQ) ||
4375 Args.getLastArg(OPT_ffile_reproducible));
4378 if (Arg *A = Args.getLastArg(options::OPT_mvscale_min_EQ)) {
4380 if (StringRef(A->getValue()).getAsInteger(10, VScaleMin) || VScaleMin == 0)
4381 Diags.
Report(diag::err_cc1_unbounded_vscale_min);
4384 if (
const Arg *A = Args.getLastArg(OPT_frandomize_layout_seed_file_EQ)) {
4385 std::ifstream SeedFile(A->getValue(0));
4387 if (!SeedFile.is_open())
4388 Diags.
Report(diag::err_drv_cannot_open_randomize_layout_seed_file)
4394 if (
const Arg *A = Args.getLastArg(OPT_frandomize_layout_seed_EQ))
4401 if (
T.isDXIL() ||
T.isSPIRVLogical()) {
4403 enum { OS, Environment };
4405 int ExpectedOS =
T.isSPIRVLogical() ? VulkanEnv : ShaderModel;
4407 if (
T.getOSName().empty()) {
4408 Diags.
Report(diag::err_drv_hlsl_bad_shader_required_in_target)
4409 << ExpectedOS << OS <<
T.str();
4410 }
else if (
T.getEnvironmentName().empty()) {
4411 Diags.
Report(diag::err_drv_hlsl_bad_shader_required_in_target)
4413 }
else if (!
T.isShaderStageEnvironment()) {
4414 Diags.
Report(diag::err_drv_hlsl_bad_shader_unsupported)
4419 if (!
T.isShaderModelOS() ||
T.getOSVersion() == VersionTuple(0)) {
4420 Diags.
Report(diag::err_drv_hlsl_bad_shader_unsupported)
4421 << ShaderModel <<
T.getOSName() <<
T.str();
4426 if (Args.getLastArg(OPT_fnative_half_type)) {
4429 if (!(Opts.
LangStd >= LangStandard::lang_hlsl2018 &&
4430 T.getOSVersion() >= VersionTuple(6, 2)))
4431 Diags.
Report(diag::err_drv_hlsl_16bit_types_unsupported)
4432 <<
"-enable-16bit-types" <<
true <<
Std.getName()
4433 <<
T.getOSVersion().getAsString();
4435 }
else if (
T.isSPIRVLogical()) {
4436 if (!
T.isVulkanOS() ||
T.getVulkanVersion() == VersionTuple(0)) {
4437 Diags.
Report(diag::err_drv_hlsl_bad_shader_unsupported)
4438 << VulkanEnv <<
T.getOSName() <<
T.str();
4440 if (Args.getLastArg(OPT_fnative_half_type)) {
4443 if (!(Opts.
LangStd >= LangStandard::lang_hlsl2018))
4444 Diags.
Report(diag::err_drv_hlsl_16bit_types_unsupported)
4445 <<
"-fnative-half-type" <<
false <<
Std.getName();
4448 llvm_unreachable(
"expected DXIL or SPIR-V target");
4451 Diags.
Report(diag::err_drv_hlsl_unsupported_target) <<
T.str();
4501 llvm_unreachable(
"invalid frontend action");
4511#define PREPROCESSOR_OPTION_WITH_MARSHALLING(...) \
4512 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
4513#include "clang/Driver/Options.inc"
4514#undef PREPROCESSOR_OPTION_WITH_MARSHALLING
4517 GenerateArg(Consumer, OPT_pch_through_hdrstop_use);
4520 GenerateArg(Consumer, OPT_error_on_deserialized_pch_decl,
D);
4527 for (
const auto &M : Opts.
Macros) {
4530 if (M.first ==
"__CET__=1" && !M.second &&
4531 !CodeGenOpts.CFProtectionReturn && CodeGenOpts.CFProtectionBranch)
4533 if (M.first ==
"__CET__=2" && !M.second && CodeGenOpts.CFProtectionReturn &&
4534 !CodeGenOpts.CFProtectionBranch)
4536 if (M.first ==
"__CET__=3" && !M.second && CodeGenOpts.CFProtectionReturn &&
4537 CodeGenOpts.CFProtectionBranch)
4540 GenerateArg(Consumer, M.second ? OPT_U : OPT_D, M.first);
4543 for (
const auto &I : Opts.
Includes) {
4546 if (LangOpts.OpenCL && LangOpts.IncludeDefaultHeader &&
4547 ((LangOpts.DeclareOpenCLBuiltins && I ==
"opencl-c-base.h") ||
4552 if (LangOpts.HLSL && I ==
"hlsl.h")
4562 GenerateArg(Consumer, OPT_remap_file, RF.first +
";" + RF.second);
4568 GenerateArg(Consumer, OPT_fdefine_target_os_macros);
4571 GenerateArg(Consumer, OPT_embed_dir_EQ, EmbedEntry);
4585#define PREPROCESSOR_OPTION_WITH_MARSHALLING(...) \
4586 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
4587#include "clang/Driver/Options.inc"
4588#undef PREPROCESSOR_OPTION_WITH_MARSHALLING
4590 Opts.
PCHWithHdrStop = Args.hasArg(OPT_pch_through_hdrstop_create) ||
4591 Args.hasArg(OPT_pch_through_hdrstop_use);
4593 for (
const auto *A : Args.filtered(OPT_error_on_deserialized_pch_decl))
4596 if (
const Arg *A = Args.getLastArg(OPT_preamble_bytes_EQ)) {
4597 StringRef
Value(A->getValue());
4598 size_t Comma =
Value.find(
',');
4600 unsigned EndOfLine = 0;
4602 if (Comma == StringRef::npos ||
4603 Value.substr(0, Comma).getAsInteger(10, Bytes) ||
4604 Value.substr(Comma + 1).getAsInteger(10, EndOfLine))
4605 Diags.
Report(diag::err_drv_preamble_format);
4613 if (
const Arg *A = Args.getLastArg(OPT_fcf_protection_EQ)) {
4614 StringRef Name = A->getValue();
4615 if (Name ==
"branch")
4617 else if (Name ==
"return")
4619 else if (Name ==
"full")
4624 for (
const auto *A : Args.filtered(OPT_D, OPT_U)) {
4625 if (A->getOption().matches(OPT_D))
4632 for (
const auto *A : Args.filtered(OPT_include))
4633 Opts.
Includes.emplace_back(A->getValue());
4635 for (
const auto *A : Args.filtered(OPT_chain_include))
4638 for (
const auto *A : Args.filtered(OPT_remap_file)) {
4639 std::pair<StringRef, StringRef> Split = StringRef(A->getValue()).split(
';');
4641 if (Split.second.empty()) {
4642 Diags.
Report(diag::err_drv_invalid_remap_file) << A->getAsString(Args);
4649 if (
const Arg *A = Args.getLastArg(OPT_source_date_epoch)) {
4650 StringRef Epoch = A->getValue();
4654 const uint64_t MaxTimestamp =
4655 std::min<uint64_t>(std::numeric_limits<time_t>::max(), 253402300799);
4657 if (Epoch.getAsInteger(10,
V) ||
V > MaxTimestamp) {
4658 Diags.
Report(diag::err_fe_invalid_source_date_epoch)
4659 << Epoch << MaxTimestamp;
4665 for (
const auto *A : Args.filtered(OPT_embed_dir_EQ)) {
4666 StringRef Val = A->getValue();
4677 Args.hasFlag(OPT_fdefine_target_os_macros,
4689#define PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING(...) \
4690 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
4691#include "clang/Driver/Options.inc"
4692#undef PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING
4710#define PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING(...) \
4711 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
4712#include "clang/Driver/Options.inc"
4713#undef PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING
4716 Opts.
ShowMacros = Args.hasArg(OPT_dM) || Args.hasArg(OPT_dD);
4725#define TARGET_OPTION_WITH_MARSHALLING(...) \
4726 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
4727#include "clang/Driver/Options.inc"
4728#undef TARGET_OPTION_WITH_MARSHALLING
4734 GenerateArg(Consumer, OPT_darwin_target_variant_sdk_version_EQ,
4744#define TARGET_OPTION_WITH_MARSHALLING(...) \
4745 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
4746#include "clang/Driver/Options.inc"
4747#undef TARGET_OPTION_WITH_MARSHALLING
4749 if (Arg *A = Args.getLastArg(options::OPT_target_sdk_version_EQ)) {
4750 llvm::VersionTuple Version;
4751 if (Version.tryParse(A->getValue()))
4752 Diags.
Report(diag::err_drv_invalid_value)
4753 << A->getAsString(Args) << A->getValue();
4758 Args.getLastArg(options::OPT_darwin_target_variant_sdk_version_EQ)) {
4759 llvm::VersionTuple Version;
4760 if (Version.tryParse(A->getValue()))
4761 Diags.
Report(diag::err_drv_invalid_value)
4762 << A->getAsString(Args) << A->getValue();
4770bool CompilerInvocation::CreateFromArgsImpl(
4778 unsigned MissingArgIndex, MissingArgCount;
4779 InputArgList Args = Opts.ParseArgs(CommandLineArgs, MissingArgIndex,
4780 MissingArgCount, VisibilityMask);
4784 if (MissingArgCount)
4785 Diags.
Report(diag::err_drv_missing_argument)
4786 << Args.getArgString(MissingArgIndex) << MissingArgCount;
4789 for (
const auto *A : Args.filtered(OPT_UNKNOWN)) {
4790 auto ArgString = A->getAsString(Args);
4791 std::string Nearest;
4792 if (Opts.findNearest(ArgString, Nearest, VisibilityMask) > 1)
4793 Diags.
Report(diag::err_drv_unknown_argument) << ArgString;
4795 Diags.
Report(diag::err_drv_unknown_argument_with_suggestion)
4796 << ArgString << Nearest;
4845 !
LangOpts.Sanitize.has(SanitizerKind::Address) &&
4846 !
LangOpts.Sanitize.has(SanitizerKind::KernelAddress) &&
4847 !
LangOpts.Sanitize.has(SanitizerKind::Memory) &&
4848 !
LangOpts.Sanitize.has(SanitizerKind::KernelMemory);
4861 Diags.
Report(diag::err_fe_dependency_file_requires_MT);
4867 Diags.
Report(diag::warn_drv_fine_grained_bitfield_accesses_ignored);
4881 Diags, llvm::vfs::getRealFileSystem());
4895 const char *Argv0) {
4901 return CreateFromArgsImpl(Invocation, CommandLineArgs, Diags, Argv0);
4905 Args.push_back(
"-cc1");
4908 Invocation, DummyInvocation, CommandLineArgs, Diags, Argv0);
4913 llvm::HashBuilder<llvm::MD5, llvm::endianness::native> HBuilder;
4926#define LANGOPT(Name, Bits, Default, Description) HBuilder.add(LangOpts->Name);
4927#define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
4928 HBuilder.add(static_cast<unsigned>(LangOpts->get##Name()));
4929#define BENIGN_LANGOPT(Name, Bits, Default, Description)
4930#define BENIGN_ENUM_LANGOPT(Name, Type, Bits, Default, Description)
4931#include "clang/Basic/LangOptions.def"
4936 HBuilder.addRange(
getLangOpts().CommentOpts.BlockCommandNames);
4953 StringRef MacroDef = Macro.first;
4955 llvm::CachedHashString(MacroDef.split(
'=').first)))
4959 HBuilder.add(Macro);
4975#define DIAGOPT(Name, Bits, Default) HBuilder.add(diagOpts.Name);
4976#define ENUM_DIAGOPT(Name, Type, Bits, Default) \
4977 HBuilder.add(diagOpts.get##Name());
4978#include "clang/Basic/DiagnosticOptions.def"
4988 ext->hashExtension(HBuilder);
4995 HBuilder.add(*Minor);
4996 if (
auto Subminor =
APINotesOpts.SwiftVersion.getSubminor())
4997 HBuilder.add(*Subminor);
4999 HBuilder.add(*Build);
5009#define DEBUGOPT(Name, Bits, Default) HBuilder.add(CodeGenOpts->Name);
5010#define VALUE_DEBUGOPT(Name, Bits, Default) HBuilder.add(CodeGenOpts->Name);
5011#define ENUM_DEBUGOPT(Name, Type, Bits, Default) \
5012 HBuilder.add(static_cast<unsigned>(CodeGenOpts->get##Name()));
5013#define BENIGN_DEBUGOPT(Name, Bits, Default)
5014#define BENIGN_VALUE_DEBUGOPT(Name, Bits, Default)
5015#define BENIGN_ENUM_DEBUGOPT(Name, Type, Bits, Default)
5016#include "clang/Basic/DebugOptions.def"
5023 if (!SanHash.
empty())
5024 HBuilder.add(SanHash.
Mask);
5026 llvm::MD5::MD5Result
Result;
5027 HBuilder.getHasher().final(
Result);
5029 return toString(llvm::APInt(64, Hash), 36,
false);
5057 std::vector<std::string> Args{
"-cc1"};
5059 [&Args](
const Twine &Arg) { Args.push_back(Arg.str()); });
5085 llvm::vfs::getRealFileSystem());
5093 Diags, std::move(BaseFS));
5099 if (VFSOverlayFiles.empty())
5104 for (
const auto &
File : VFSOverlayFiles) {
5105 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> Buffer =
5108 Diags.
Report(diag::err_missing_vfs_overlay_file) <<
File;
5113 std::move(Buffer.get()),
nullptr,
File,
5116 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 void parsePointerAuthOptions(PointerAuthOptions &Opts, const LangOptions &LangOpts, const llvm::Triple &Triple, DiagnosticsEngine &Diags)
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
PointerAuthOptions PointerAuth
Configuration for pointer-signing.
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)
static void setDefaultPointerAuthOptions(PointerAuthOptions &Opts, const LangOptions &LangOpts, const llvm::Triple &Triple)
Populate Opts with the default set of pointer authentication-related options given LangOpts and Tripl...
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.
unsigned UseClangIRPipeline
Use Clang IR pipeline to emit code.
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.
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.
enum clang::FrontendOptions::@201 ARCMTAction
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...
Discrimination
Forms of extra discrimination.
ARM8_3Key
Hardware pointer-signing keys in ARM8.3.
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...
std::vector< std::string > EmbedEntries
User specified embed entries.
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.
@ EmitCIR
Emit a .cir 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.
constexpr uint16_t StdTypeInfoVTablePointerConstantDiscrimination
Constant discriminator for std::type_info vtable pointers: 0xB1EA/45546 The value is ptrauth_string_d...
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.
PointerAuthSchema CXXVTablePointers
The ABI for C++ virtual table pointers (the pointer to the table itself) as installed in an actual cl...
PointerAuthSchema CXXVTTVTablePointers
The ABI for C++ virtual table pointers as installed in a VTT.
PointerAuthSchema CXXTypeInfoVTablePointer
TypeInfo has external ABI requirements and is emitted without actually having parsed the libcxx defin...
PointerAuthSchema FunctionPointers
The ABI for C function pointers.
PointerAuthSchema CXXMemberFunctionPointers
The ABI for C++ member function pointers.
PointerAuthSchema CXXVirtualVariadicFunctionPointers
The ABI for variadic C++ virtual function pointers.
PointerAuthSchema CXXVirtualFunctionPointers
The ABI for most C++ virtual function pointers, i.e. v-table entries.
bool IndirectGotos
Do indirect goto label addresses need to be authenticated?
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.