29#include "clang/Config/config.h"
48#include "llvm/ADT/APInt.h"
49#include "llvm/ADT/ArrayRef.h"
50#include "llvm/ADT/CachedHashString.h"
51#include "llvm/ADT/FloatingPointMode.h"
52#include "llvm/ADT/Hashing.h"
53#include "llvm/ADT/STLExtras.h"
54#include "llvm/ADT/SmallString.h"
55#include "llvm/ADT/SmallVector.h"
56#include "llvm/ADT/StringRef.h"
57#include "llvm/ADT/StringSwitch.h"
58#include "llvm/ADT/Twine.h"
59#include "llvm/Config/llvm-config.h"
60#include "llvm/Frontend/Debug/Options.h"
61#include "llvm/IR/DebugInfoMetadata.h"
62#include "llvm/Linker/Linker.h"
63#include "llvm/MC/MCTargetOptions.h"
64#include "llvm/Option/Arg.h"
65#include "llvm/Option/ArgList.h"
66#include "llvm/Option/OptSpecifier.h"
67#include "llvm/Option/OptTable.h"
68#include "llvm/Option/Option.h"
69#include "llvm/ProfileData/InstrProfReader.h"
70#include "llvm/Remarks/HotnessThresholdParser.h"
71#include "llvm/Support/CodeGen.h"
72#include "llvm/Support/Compiler.h"
73#include "llvm/Support/Error.h"
74#include "llvm/Support/ErrorHandling.h"
75#include "llvm/Support/ErrorOr.h"
76#include "llvm/Support/FileSystem.h"
77#include "llvm/Support/HashBuilder.h"
78#include "llvm/Support/MathExtras.h"
79#include "llvm/Support/MemoryBuffer.h"
80#include "llvm/Support/Path.h"
81#include "llvm/Support/Process.h"
82#include "llvm/Support/Regex.h"
83#include "llvm/Support/VersionTuple.h"
84#include "llvm/Support/VirtualFileSystem.h"
85#include "llvm/Support/raw_ostream.h"
86#include "llvm/Target/TargetOptions.h"
87#include "llvm/TargetParser/Host.h"
88#include "llvm/TargetParser/Triple.h"
101#include <type_traits>
105using namespace clang;
106using namespace driver;
107using namespace options;
118 if (Arg.getAsInteger(10, Val))
119 return llvm::createStringError(llvm::inconvertibleErrorCode(),
120 "Not an integer: %s", Arg.data());
129template <
class T> std::shared_ptr<T> make_shared_copy(
const T &
X) {
130 return std::make_shared<T>(
X);
135 return llvm::makeIntrusiveRefCnt<T>(
X);
157 LangOpts = make_shared_copy(
X.getLangOpts());
160 HSOpts = make_shared_copy(
X.getHeaderSearchOpts());
161 PPOpts = make_shared_copy(
X.getPreprocessorOpts());
166 FSOpts = make_shared_copy(
X.getFileSystemOpts());
207T &ensureOwned(std::shared_ptr<T> &Storage) {
208 if (Storage.use_count() > 1)
209 Storage = std::make_shared<T>(*Storage);
215 if (Storage.useCount() > 1)
216 Storage = llvm::makeIntrusiveRefCnt<T>(*Storage);
234 return ensureOwned(
HSOpts);
238 return ensureOwned(
PPOpts);
258 return ensureOwned(
FSOpts);
280#define SIMPLE_ENUM_VALUE_TABLE
281#include "clang/Driver/Options.inc"
282#undef SIMPLE_ENUM_VALUE_TABLE
288 if (Args.hasArg(Opt))
297 if (Args.hasArg(Opt))
307 const Twine &Spelling, Option::OptionClass,
313 return !std::is_same_v<T, uint64_t> && llvm::is_integral_or_enum<T>::value;
317 std::enable_if_t<!is_uint64_t_convertible<T>(),
bool> =
false>
319 return [
Value](OptSpecifier Opt,
unsigned,
const ArgList &Args,
321 if (Args.hasArg(Opt))
328 std::enable_if_t<is_uint64_t_convertible<T>(),
bool> =
false>
334 OptSpecifier OtherOpt) {
335 return [
Value, OtherValue,
336 OtherOpt](OptSpecifier Opt,
unsigned,
const ArgList &Args,
338 if (
const Arg *A = Args.getLastArg(Opt, OtherOpt)) {
339 return A->getOption().matches(Opt) ?
Value : OtherValue;
347 Option::OptionClass,
unsigned,
bool KeyPath) {
348 if (KeyPath ==
Value)
354 const Twine &Spelling,
355 Option::OptionClass OptClass,
unsigned,
356 const Twine &
Value) {
358 case Option::SeparateClass:
359 case Option::JoinedOrSeparateClass:
360 case Option::JoinedAndSeparateClass:
364 case Option::JoinedClass:
365 case Option::CommaJoinedClass:
366 Consumer(Spelling +
Value);
369 llvm_unreachable(
"Cannot denormalize an option with option class "
370 "incompatible with string denormalization.");
376 Option::OptionClass OptClass,
unsigned TableIndex,
381static std::optional<SimpleEnumValue>
383 for (
int I = 0, E = Table.Size; I != E; ++I)
384 if (Name == Table.Table[I].Name)
385 return Table.Table[I];
390static std::optional<SimpleEnumValue>
392 for (
int I = 0, E = Table.Size; I != E; ++I)
394 return Table.Table[I];
403 assert(TableIndex < SimpleEnumValueTablesSize);
404 const SimpleEnumValueTable &Table = SimpleEnumValueTables[TableIndex];
406 auto *Arg = Args.getLastArg(Opt);
410 StringRef ArgValue = Arg->getValue();
412 return MaybeEnumVal->Value;
414 Diags.
Report(diag::err_drv_invalid_value)
415 << Arg->getAsString(Args) << ArgValue;
420 const Twine &Spelling,
421 Option::OptionClass OptClass,
422 unsigned TableIndex,
unsigned Value) {
423 assert(TableIndex < SimpleEnumValueTablesSize);
424 const SimpleEnumValueTable &Table = SimpleEnumValueTables[TableIndex];
429 llvm_unreachable(
"The simple enum value was not correctly defined in "
430 "the tablegen option description");
436 const Twine &Spelling,
437 Option::OptionClass OptClass,
438 unsigned TableIndex,
T Value) {
440 static_cast<unsigned>(
Value));
447 auto *Arg = Args.getLastArg(Opt);
450 return std::string(Arg->getValue());
453template <
typename IntTy>
457 auto *Arg = Args.getLastArg(Opt);
461 if (StringRef(Arg->getValue()).getAsInteger(0, Res)) {
462 Diags.
Report(diag::err_drv_invalid_int_value)
463 << Arg->getAsString(Args) << Arg->getValue();
469static std::optional<std::vector<std::string>>
472 return Args.getAllArgValues(Opt);
476 const Twine &Spelling,
477 Option::OptionClass OptClass,
479 const std::vector<std::string> &Values) {
481 case Option::CommaJoinedClass: {
482 std::string CommaJoinedValue;
483 if (!Values.empty()) {
484 CommaJoinedValue.append(Values.front());
485 for (
const std::string &
Value : llvm::drop_begin(Values, 1)) {
486 CommaJoinedValue.append(
",");
487 CommaJoinedValue.append(
Value);
491 TableIndex, CommaJoinedValue);
494 case Option::JoinedClass:
495 case Option::SeparateClass:
496 case Option::JoinedOrSeparateClass:
497 for (
const std::string &
Value : Values)
501 llvm_unreachable(
"Cannot denormalize an option with option class "
502 "incompatible with string vector denormalization.");
510 auto *Arg = Args.getLastArg(Opt);
513 return llvm::Triple::normalize(Arg->getValue());
516template <
typename T,
typename U>
518 return static_cast<T>(
Value);
522 return KeyPath |
Value;
529template <
typename T,
typename U, U Value>
534#define PARSE_OPTION_WITH_MARSHALLING( \
535 ARGS, DIAGS, PREFIX_TYPE, SPELLING, ID, KIND, GROUP, ALIAS, ALIASARGS, \
536 FLAGS, VISIBILITY, PARAM, HELPTEXT, HELPTEXTSFORVARIANTS, METAVAR, VALUES, \
537 SHOULD_PARSE, ALWAYS_EMIT, KEYPATH, DEFAULT_VALUE, IMPLIED_CHECK, \
538 IMPLIED_VALUE, NORMALIZER, DENORMALIZER, MERGER, EXTRACTOR, TABLE_INDEX) \
539 if ((VISIBILITY) & options::CC1Option) { \
540 KEYPATH = MERGER(KEYPATH, DEFAULT_VALUE); \
542 KEYPATH = MERGER(KEYPATH, IMPLIED_VALUE); \
544 if (auto MaybeValue = NORMALIZER(OPT_##ID, TABLE_INDEX, ARGS, DIAGS)) \
546 MERGER(KEYPATH, static_cast<decltype(KEYPATH)>(*MaybeValue)); \
551#define GENERATE_OPTION_WITH_MARSHALLING( \
552 CONSUMER, PREFIX_TYPE, SPELLING, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, \
553 VISIBILITY, PARAM, HELPTEXT, HELPTEXTSFORVARIANTS, METAVAR, VALUES, \
554 SHOULD_PARSE, ALWAYS_EMIT, KEYPATH, DEFAULT_VALUE, IMPLIED_CHECK, \
555 IMPLIED_VALUE, NORMALIZER, DENORMALIZER, MERGER, EXTRACTOR, TABLE_INDEX) \
556 if ((VISIBILITY) & options::CC1Option) { \
557 [&](const auto &Extracted) { \
560 static_cast<decltype(KEYPATH)>((IMPLIED_CHECK) ? (IMPLIED_VALUE) \
561 : (DEFAULT_VALUE)))) \
562 DENORMALIZER(CONSUMER, SPELLING, Option::KIND##Class, TABLE_INDEX, \
564 }(EXTRACTOR(KEYPATH)); \
578 CodeGenOpts.XRayInstrumentFunctions = LangOpts.XRayInstrument;
579 CodeGenOpts.XRayAlwaysEmitCustomEvents = LangOpts.XRayAlwaysEmitCustomEvents;
580 CodeGenOpts.XRayAlwaysEmitTypedEvents = LangOpts.XRayAlwaysEmitTypedEvents;
581 CodeGenOpts.DisableFree = FrontendOpts.
DisableFree;
584 CodeGenOpts.ClearASTBeforeBackend =
false;
586 LangOpts.ForceEmitVTables = CodeGenOpts.ForceEmitVTables;
587 LangOpts.SpeculativeLoadHardening = CodeGenOpts.SpeculativeLoadHardening;
590 llvm::Triple
T(TargetOpts.
Triple);
591 llvm::Triple::ArchType Arch =
T.getArch();
596 if (LangOpts.getExceptionHandling() !=
598 T.isWindowsMSVCEnvironment())
599 Diags.
Report(diag::err_fe_invalid_exception_model)
600 <<
static_cast<unsigned>(LangOpts.getExceptionHandling()) <<
T.str();
602 if (LangOpts.AppleKext && !LangOpts.CPlusPlus)
603 Diags.
Report(diag::warn_c_kext);
605 if (LangOpts.NewAlignOverride &&
606 !llvm::isPowerOf2_32(LangOpts.NewAlignOverride)) {
607 Arg *A = Args.getLastArg(OPT_fnew_alignment_EQ);
608 Diags.
Report(diag::err_fe_invalid_alignment)
609 << A->getAsString(Args) << A->getValue();
610 LangOpts.NewAlignOverride = 0;
614 if (LangOpts.SYCLIsDevice && LangOpts.SYCLIsHost)
615 Diags.
Report(diag::err_drv_argument_not_allowed_with) <<
"-fsycl-is-device"
618 if (Args.hasArg(OPT_fgnu89_inline) && LangOpts.CPlusPlus)
619 Diags.
Report(diag::err_drv_argument_not_allowed_with)
622 if (Args.hasArg(OPT_hlsl_entrypoint) && !LangOpts.HLSL)
623 Diags.
Report(diag::err_drv_argument_not_allowed_with)
626 if (Args.hasArg(OPT_fgpu_allow_device_init) && !LangOpts.HIP)
627 Diags.
Report(diag::warn_ignored_hip_only_option)
628 << Args.getLastArg(OPT_fgpu_allow_device_init)->getAsString(Args);
630 if (Args.hasArg(OPT_gpu_max_threads_per_block_EQ) && !LangOpts.HIP)
631 Diags.
Report(diag::warn_ignored_hip_only_option)
632 << Args.getLastArg(OPT_gpu_max_threads_per_block_EQ)->getAsString(Args);
641 if (Args.hasArg(OPT_ffp_eval_method_EQ)) {
642 if (LangOpts.ApproxFunc)
643 Diags.
Report(diag::err_incompatible_fp_eval_method_options) << 0;
644 if (LangOpts.AllowFPReassoc)
645 Diags.
Report(diag::err_incompatible_fp_eval_method_options) << 1;
646 if (LangOpts.AllowRecip)
647 Diags.
Report(diag::err_incompatible_fp_eval_method_options) << 2;
653 if (Args.getLastArg(OPT_cl_strict_aliasing) &&
655 Diags.
Report(diag::warn_option_invalid_ocl_version)
657 << Args.getLastArg(OPT_cl_strict_aliasing)->getAsString(Args);
659 if (Arg *A = Args.getLastArg(OPT_fdefault_calling_conv_EQ)) {
660 auto DefaultCC = LangOpts.getDefaultCallingConv();
664 Arch != llvm::Triple::x86;
670 Diags.
Report(diag::err_drv_argument_not_allowed_with)
671 << A->getSpelling() <<
T.getTriple();
683 unsigned DefaultOpt = 0;
686 !Args.hasArg(OPT_cl_opt_disable))
689 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
690 if (A->getOption().matches(options::OPT_O0))
693 if (A->getOption().matches(options::OPT_Ofast))
696 assert(A->getOption().matches(options::OPT_O));
698 StringRef S(A->getValue());
699 if (S ==
"s" || S ==
"z")
712 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
713 if (A->getOption().matches(options::OPT_O)) {
714 switch (A->getValue()[0]) {
728 llvm::opt::OptSpecifier OptSpecifier) {
731 Option::OptionClass::FlagClass, 0);
735 llvm::opt::OptSpecifier OptSpecifier,
736 const Twine &
Value) {
774 bool CheckAgainstOriginalInvocation =
false,
775 bool ForceRoundTrip =
false) {
777 bool DoRoundTripDefault =
true;
779 bool DoRoundTripDefault =
false;
782 bool DoRoundTrip = DoRoundTripDefault;
783 if (ForceRoundTrip) {
786 for (
const auto *Arg : CommandLineArgs) {
787 if (Arg == StringRef(
"-round-trip-args"))
789 if (Arg == StringRef(
"-no-round-trip-args"))
797 return Parse(RealInvocation, CommandLineArgs, Diags, Argv0);
802 llvm::raw_string_ostream OS(Buffer);
803 for (
const char *Arg : Args) {
804 llvm::sys::printArg(OS, Arg,
true);
817 if (!Parse(DummyInvocation, CommandLineArgs, DummyDiags, Argv0) ||
824 auto Success = Parse(RealInvocation, CommandLineArgs, Diags, Argv0);
830 Diags.
Report(diag::err_cc1_round_trip_fail_then_ok);
831 Diags.
Report(diag::note_cc1_round_trip_original)
832 << SerializeArgs(CommandLineArgs);
837 llvm::BumpPtrAllocator Alloc;
838 llvm::StringSaver StringPool(Alloc);
839 auto SA = [&StringPool](
const Twine &Arg) {
840 return StringPool.save(Arg).data();
847 Generate(DummyInvocation, GeneratedArgs, SA);
853 bool Success2 = Parse(RealInvocation, GeneratedArgs, Diags, Argv0);
858 Diags.
Report(diag::err_cc1_round_trip_ok_then_fail);
859 Diags.
Report(diag::note_cc1_round_trip_generated)
860 << 1 << SerializeArgs(GeneratedArgs);
865 if (CheckAgainstOriginalInvocation)
867 ComparisonArgs.assign(CommandLineArgs.begin(), CommandLineArgs.end());
871 Generate(RealInvocation, ComparisonArgs, SA);
876 return std::equal(A.begin(), A.end(), B.begin(), B.end(),
877 [](
const char *AElem,
const char *BElem) {
878 return StringRef(AElem) == StringRef(BElem);
885 if (!
Equal(GeneratedArgs, ComparisonArgs)) {
886 Diags.
Report(diag::err_cc1_round_trip_mismatch);
887 Diags.
Report(diag::note_cc1_round_trip_generated)
888 << 1 << SerializeArgs(GeneratedArgs);
889 Diags.
Report(diag::note_cc1_round_trip_generated)
890 << 2 << SerializeArgs(ComparisonArgs);
894 Diags.
Report(diag::remark_cc1_round_trip_generated)
895 << 1 << SerializeArgs(GeneratedArgs);
896 Diags.
Report(diag::remark_cc1_round_trip_generated)
897 << 2 << SerializeArgs(ComparisonArgs);
909 return CreateFromArgsImpl(Invocation, CommandLineArgs, Diags, Argv0);
913 Args.push_back(
"-cc1");
916 DummyInvocation1, DummyInvocation2, Args, Diags, Argv0,
921 OptSpecifier GroupWithValue,
922 std::vector<std::string> &Diagnostics) {
923 for (
auto *A : Args.filtered(Group)) {
924 if (A->getOption().getKind() == Option::FlagClass) {
927 Diagnostics.push_back(
928 std::string(A->getOption().getName().drop_front(1)));
929 }
else if (A->getOption().matches(GroupWithValue)) {
932 Diagnostics.push_back(
933 std::string(A->getOption().getName().drop_front(1).rtrim(
"=-")));
936 Diagnostics.push_back(A->getValue());
947 std::vector<std::string> &Funcs) {
948 std::vector<std::string> Values = Args.getAllArgValues(OPT_fno_builtin_);
950 Funcs.insert(Funcs.end(), Values.begin(), BuiltinEnd);
957#define ANALYZER_OPTION_WITH_MARSHALLING(...) \
958 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
959#include "clang/Driver/Options.inc"
960#undef ANALYZER_OPTION_WITH_MARSHALLING
964#define ANALYSIS_CONSTRAINTS(NAME, CMDFLAG, DESC, CREATFN) \
966 GenerateArg(Consumer, OPT_analyzer_constraints, CMDFLAG); \
968#include "clang/StaticAnalyzer/Core/Analyses.def"
970 llvm_unreachable(
"Tried to generate unknown analysis constraint.");
976#define ANALYSIS_DIAGNOSTICS(NAME, CMDFLAG, DESC, CREATFN) \
978 GenerateArg(Consumer, OPT_analyzer_output, CMDFLAG); \
980#include "clang/StaticAnalyzer/Core/Analyses.def"
982 llvm_unreachable(
"Tried to generate unknown analysis diagnostic client.");
988#define ANALYSIS_PURGE(NAME, CMDFLAG, DESC) \
990 GenerateArg(Consumer, OPT_analyzer_purge, CMDFLAG); \
992#include "clang/StaticAnalyzer/Core/Analyses.def"
994 llvm_unreachable(
"Tried to generate unknown analysis purge mode.");
1000#define ANALYSIS_INLINING_MODE(NAME, CMDFLAG, DESC) \
1002 GenerateArg(Consumer, OPT_analyzer_inlining_mode, CMDFLAG); \
1004#include "clang/StaticAnalyzer/Core/Analyses.def"
1006 llvm_unreachable(
"Tried to generate unknown analysis inlining mode.");
1012 CP.second ? OPT_analyzer_checker : OPT_analyzer_disable_checker;
1021 for (
const auto &
C : Opts.
Config)
1022 SortedConfigOpts.emplace_back(
C.getKey(),
C.getValue());
1023 llvm::sort(SortedConfigOpts, llvm::less_first());
1025 for (
const auto &[Key,
Value] : SortedConfigOpts) {
1028 auto Entry = ConfigOpts.
Config.find(Key);
1029 if (Entry != ConfigOpts.
Config.end() && Entry->getValue() ==
Value)
1044#define ANALYZER_OPTION_WITH_MARSHALLING(...) \
1045 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
1046#include "clang/Driver/Options.inc"
1047#undef ANALYZER_OPTION_WITH_MARSHALLING
1049 if (Arg *A = Args.getLastArg(OPT_analyzer_constraints)) {
1050 StringRef Name = A->getValue();
1052#define ANALYSIS_CONSTRAINTS(NAME, CMDFLAG, DESC, CREATFN) \
1053 .Case(CMDFLAG, NAME##Model)
1054#include "clang/StaticAnalyzer/Core/Analyses.def"
1057 Diags.
Report(diag::err_drv_invalid_value)
1058 << A->getAsString(Args) << Name;
1061 if (
Value == AnalysisConstraints::Z3ConstraintsModel) {
1062 Diags.
Report(diag::err_analyzer_not_built_with_z3);
1069 if (Arg *A = Args.getLastArg(OPT_analyzer_output)) {
1070 StringRef Name = A->getValue();
1072#define ANALYSIS_DIAGNOSTICS(NAME, CMDFLAG, DESC, CREATFN) \
1073 .Case(CMDFLAG, PD_##NAME)
1074#include "clang/StaticAnalyzer/Core/Analyses.def"
1077 Diags.
Report(diag::err_drv_invalid_value)
1078 << A->getAsString(Args) << Name;
1084 if (Arg *A = Args.getLastArg(OPT_analyzer_purge)) {
1085 StringRef Name = A->getValue();
1087#define ANALYSIS_PURGE(NAME, CMDFLAG, DESC) \
1088 .Case(CMDFLAG, NAME)
1089#include "clang/StaticAnalyzer/Core/Analyses.def"
1092 Diags.
Report(diag::err_drv_invalid_value)
1093 << A->getAsString(Args) << Name;
1099 if (Arg *A = Args.getLastArg(OPT_analyzer_inlining_mode)) {
1100 StringRef Name = A->getValue();
1102#define ANALYSIS_INLINING_MODE(NAME, CMDFLAG, DESC) \
1103 .Case(CMDFLAG, NAME)
1104#include "clang/StaticAnalyzer/Core/Analyses.def"
1107 Diags.
Report(diag::err_drv_invalid_value)
1108 << A->getAsString(Args) << Name;
1116 Args.filtered(OPT_analyzer_checker, OPT_analyzer_disable_checker)) {
1118 bool IsEnabled = A->getOption().getID() == OPT_analyzer_checker;
1121 StringRef CheckerAndPackageList = A->getValue();
1123 CheckerAndPackageList.split(CheckersAndPackages,
",");
1124 for (
const StringRef &CheckerOrPackage : CheckersAndPackages)
1130 for (
const auto *A : Args.filtered(OPT_analyzer_config)) {
1134 StringRef configList = A->getValue();
1136 configList.split(configVals,
",");
1137 for (
const auto &configVal : configVals) {
1139 std::tie(key, val) = configVal.split(
"=");
1142 diag::err_analyzer_config_no_value) << configVal;
1145 if (val.contains(
'=')) {
1147 diag::err_analyzer_config_multiple_values)
1156 Diags.
Report(diag::err_analyzer_config_unknown) << key;
1161 Opts.
Config[key] = std::string(val);
1171 for (
unsigned i = 0; i < Args.getNumInputArgStrings(); ++i) {
1174 os << Args.getArgString(i);
1182 StringRef OptionName, StringRef DefaultVal) {
1183 return Config.insert({OptionName, std::string(DefaultVal)}).first->second;
1188 StringRef &OptionField, StringRef Name,
1189 StringRef DefaultVal) {
1198 bool &OptionField, StringRef Name,
bool DefaultVal) {
1199 auto PossiblyInvalidVal =
1200 llvm::StringSwitch<std::optional<bool>>(
1203 .Case(
"false",
false)
1204 .Default(std::nullopt);
1206 if (!PossiblyInvalidVal) {
1208 Diags->
Report(diag::err_analyzer_config_invalid_input)
1209 << Name <<
"a boolean";
1211 OptionField = DefaultVal;
1213 OptionField = *PossiblyInvalidVal;
1218 unsigned &OptionField, StringRef Name,
1219 unsigned DefaultVal) {
1221 OptionField = DefaultVal;
1222 bool HasFailed =
getStringOption(Config, Name, std::to_string(DefaultVal))
1223 .getAsInteger(0, OptionField);
1224 if (Diags && HasFailed)
1225 Diags->
Report(diag::err_analyzer_config_invalid_input)
1226 << Name <<
"an unsigned";
1234#define ANALYZER_OPTION(TYPE, NAME, CMDFLAG, DESC, DEFAULT_VAL) \
1235 initOption(AnOpts.Config, Diags, AnOpts.NAME, CMDFLAG, DEFAULT_VAL);
1236#define ANALYZER_OPTION_DEPENDS_ON_USER_MODE(...)
1237#include "clang/StaticAnalyzer/Core/AnalyzerOptions.def"
1239 assert(AnOpts.UserMode ==
"shallow" || AnOpts.UserMode ==
"deep");
1240 const bool InShallowMode = AnOpts.UserMode ==
"shallow";
1242#define ANALYZER_OPTION(...)
1243#define ANALYZER_OPTION_DEPENDS_ON_USER_MODE(TYPE, NAME, CMDFLAG, DESC, \
1244 SHALLOW_VAL, DEEP_VAL) \
1245 initOption(AnOpts.Config, Diags, AnOpts.NAME, CMDFLAG, \
1246 InShallowMode ? SHALLOW_VAL : DEEP_VAL);
1247#include "clang/StaticAnalyzer/Core/AnalyzerOptions.def"
1254 if (!AnOpts.RawSilencedCheckersAndPackages.empty()) {
1255 std::vector<StringRef> Checkers =
1257 std::vector<StringRef> Packages =
1261 AnOpts.RawSilencedCheckersAndPackages.split(CheckersAndPackages,
";");
1263 for (
const StringRef &CheckerOrPackage : CheckersAndPackages) {
1265 bool IsChecker = CheckerOrPackage.contains(
'.');
1266 bool IsValidName = IsChecker
1267 ? llvm::is_contained(Checkers, CheckerOrPackage)
1268 : llvm::is_contained(Packages, CheckerOrPackage);
1271 Diags->
Report(diag::err_unknown_analyzer_checker_or_package)
1272 << CheckerOrPackage;
1282 if (AnOpts.ShouldTrackConditionsDebug && !AnOpts.ShouldTrackConditions)
1283 Diags->
Report(diag::err_analyzer_config_invalid_input)
1284 <<
"track-conditions-debug" <<
"'track-conditions' to also be enabled";
1286 if (!AnOpts.CTUDir.empty() && !llvm::sys::fs::is_directory(AnOpts.CTUDir))
1287 Diags->
Report(diag::err_analyzer_config_invalid_input) <<
"ctu-dir"
1290 if (!AnOpts.ModelPath.empty() &&
1291 !llvm::sys::fs::is_directory(AnOpts.ModelPath))
1292 Diags->
Report(diag::err_analyzer_config_invalid_input) <<
"model-path"
1301 if (
Remark.hasValidPattern()) {
1306 GenerateArg(Consumer, OPT_R_Joined, StringRef(
"no-") + Name);
1315 OptSpecifier OptEQ, StringRef Name) {
1318 auto InitializeResultPattern = [&Diags, &Args, &
Result](
const Arg *A,
1319 StringRef Pattern) {
1320 Result.Pattern = Pattern.str();
1322 std::string RegexError;
1323 Result.Regex = std::make_shared<llvm::Regex>(
Result.Pattern);
1324 if (!
Result.Regex->isValid(RegexError)) {
1325 Diags.
Report(diag::err_drv_optimization_remark_pattern)
1326 << RegexError << A->getAsString(Args);
1333 for (Arg *A : Args) {
1334 if (A->getOption().matches(OPT_R_Joined)) {
1335 StringRef
Value = A->getValue();
1339 else if (
Value ==
"everything")
1341 else if (
Value.split(
'-') == std::make_pair(StringRef(
"no"), Name))
1343 else if (
Value ==
"no-everything")
1353 InitializeResultPattern(A,
".*");
1355 }
else if (A->getOption().matches(OptEQ)) {
1357 if (!InitializeResultPattern(A, A->getValue()))
1366 const std::vector<std::string> &Levels,
1370 for (
const auto &Level : Levels) {
1372 llvm::StringSwitch<DiagnosticLevelMask>(Level)
1380 Diags.
Report(diag::err_drv_invalid_value) << FlagName << Level;
1388 const std::vector<std::string> &Sanitizers,
1390 for (
const auto &Sanitizer : Sanitizers) {
1393 Diags.
Report(diag::err_drv_invalid_value) << FlagName << Sanitizer;
1409 llvm::SplitString(Bundle, BundleParts,
",");
1410 for (
const auto &B : BundleParts) {
1414 D.
Report(diag::err_drv_invalid_value) << FlagName << Bundle;
1428 llvm::raw_string_ostream OS(Buffer);
1429 llvm::interleave(BundleParts, OS, [&OS](StringRef Part) { OS << Part; },
",");
1435 const Twine &ProfileName,
1436 llvm::vfs::FileSystem &FS,
1438 auto ReaderOrErr = llvm::IndexedInstrProfReader::create(ProfileName, FS);
1439 if (
auto E = ReaderOrErr.takeError()) {
1441 "Error in reading profile %0: %1");
1442 llvm::handleAllErrors(std::move(E), [&](
const llvm::ErrorInfoBase &EI) {
1443 Diags.
Report(DiagID) << ProfileName.str() << EI.message();
1447 std::unique_ptr<llvm::IndexedInstrProfReader> PGOReader =
1448 std::move(ReaderOrErr.get());
1452 if (PGOReader->isIRLevelProfile() || PGOReader->hasMemoryProfile()) {
1453 if (PGOReader->hasCSIRLevelProfile())
1461void CompilerInvocationBase::GenerateCodeGenArgs(
const CodeGenOptions &Opts,
1463 const llvm::Triple &
T,
1464 const std::string &OutputFile,
1468 if (Opts.OptimizationLevel == 0)
1471 GenerateArg(Consumer, OPT_O, Twine(Opts.OptimizationLevel));
1473#define CODEGEN_OPTION_WITH_MARSHALLING(...) \
1474 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
1475#include "clang/Driver/Options.inc"
1476#undef CODEGEN_OPTION_WITH_MARSHALLING
1478 if (Opts.OptimizationLevel > 0) {
1482 GenerateArg(Consumer, OPT_finline_hint_functions);
1487 if (Opts.DirectAccessExternalData &&
LangOpts->PICLevel != 0)
1488 GenerateArg(Consumer, OPT_fdirect_access_external_data);
1489 else if (!Opts.DirectAccessExternalData &&
LangOpts->PICLevel == 0)
1490 GenerateArg(Consumer, OPT_fno_direct_access_external_data);
1492 std::optional<StringRef> DebugInfoVal;
1493 switch (Opts.DebugInfo) {
1494 case llvm::codegenoptions::DebugLineTablesOnly:
1495 DebugInfoVal =
"line-tables-only";
1497 case llvm::codegenoptions::DebugDirectivesOnly:
1498 DebugInfoVal =
"line-directives-only";
1500 case llvm::codegenoptions::DebugInfoConstructor:
1501 DebugInfoVal =
"constructor";
1503 case llvm::codegenoptions::LimitedDebugInfo:
1504 DebugInfoVal =
"limited";
1506 case llvm::codegenoptions::FullDebugInfo:
1507 DebugInfoVal =
"standalone";
1509 case llvm::codegenoptions::UnusedTypeInfo:
1510 DebugInfoVal =
"unused-types";
1512 case llvm::codegenoptions::NoDebugInfo:
1513 DebugInfoVal = std::nullopt;
1515 case llvm::codegenoptions::LocTrackingOnly:
1516 DebugInfoVal = std::nullopt;
1520 GenerateArg(Consumer, OPT_debug_info_kind_EQ, *DebugInfoVal);
1524 Prefix.first +
"=" + Prefix.second);
1527 GenerateArg(Consumer, OPT_fcoverage_prefix_map_EQ,
1528 Prefix.first +
"=" + Prefix.second);
1530 if (Opts.NewStructPathTBAA)
1533 if (Opts.OptimizeSize == 1)
1535 else if (Opts.OptimizeSize == 2)
1543 if (Opts.UnrollLoops && Opts.OptimizationLevel <= 1)
1545 else if (!Opts.UnrollLoops && Opts.OptimizationLevel > 1)
1551 if (Opts.DebugNameTable ==
1552 static_cast<unsigned>(llvm::DICompileUnit::DebugNameTableKind::GNU))
1554 else if (Opts.DebugNameTable ==
1555 static_cast<unsigned>(
1556 llvm::DICompileUnit::DebugNameTableKind::Default))
1559 if (Opts.DebugTemplateAlias)
1562 auto TNK = Opts.getDebugSimpleTemplateNames();
1563 if (TNK != llvm::codegenoptions::DebugTemplateNamesKind::Full) {
1564 if (TNK == llvm::codegenoptions::DebugTemplateNamesKind::Simple)
1565 GenerateArg(Consumer, OPT_gsimple_template_names_EQ,
"simple");
1566 else if (TNK == llvm::codegenoptions::DebugTemplateNamesKind::Mangled)
1567 GenerateArg(Consumer, OPT_gsimple_template_names_EQ,
"mangled");
1572 if (Opts.TimePasses) {
1573 if (Opts.TimePassesPerRun)
1574 GenerateArg(Consumer, OPT_ftime_report_EQ,
"per-pass-run");
1579 if (Opts.PrepareForLTO && !Opts.PrepareForThinLTO)
1582 if (Opts.PrepareForThinLTO)
1591 StringRef MemProfileBasename(
"memprof.profraw");
1612 std::string InstrBundle =
1614 if (!InstrBundle.empty())
1615 GenerateArg(Consumer, OPT_fxray_instrumentation_bundle, InstrBundle);
1618 if (Opts.CFProtectionReturn && Opts.CFProtectionBranch)
1619 GenerateArg(Consumer, OPT_fcf_protection_EQ,
"full");
1620 else if (Opts.CFProtectionReturn)
1621 GenerateArg(Consumer, OPT_fcf_protection_EQ,
"return");
1622 else if (Opts.CFProtectionBranch)
1623 GenerateArg(Consumer, OPT_fcf_protection_EQ,
"branch");
1625 if (Opts.FunctionReturnThunks)
1626 GenerateArg(Consumer, OPT_mfunction_return_EQ,
"thunk-extern");
1629 bool Builtint = F.LinkFlags == llvm::Linker::Flags::LinkOnlyNeeded &&
1630 F.PropagateAttrs && F.Internalize;
1632 Builtint ? OPT_mlink_builtin_bitcode : OPT_mlink_bitcode_file,
1636 if (Opts.EmulatedTLS)
1644 GenerateArg(Consumer, OPT_fdenormal_fp_math_f32_EQ,
1649 T.isPPC32() ? OPT_maix_struct_return : OPT_fpcc_struct_return;
1653 T.isPPC32() ? OPT_msvr4_struct_return : OPT_freg_struct_return;
1657 if (Opts.EnableAIXExtendedAltivecABI)
1660 if (Opts.XCOFFReadOnlyPointers)
1678 GenerateArg(Consumer, OPT_fdiagnostics_hotness_threshold_EQ,
1683 GenerateArg(Consumer, OPT_fdiagnostics_misexpect_tolerance_EQ,
1687 GenerateArg(Consumer, OPT_fsanitize_recover_EQ, Sanitizer);
1690 GenerateArg(Consumer, OPT_fsanitize_trap_EQ, Sanitizer);
1692 if (!Opts.EmitVersionIdentMetadata)
1695 switch (Opts.FiniteLoops) {
1707bool CompilerInvocation::ParseCodeGenArgs(
CodeGenOptions &Opts, ArgList &Args,
1710 const llvm::Triple &
T,
1711 const std::string &OutputFile,
1717 unsigned MaxOptLevel = 3;
1718 if (OptimizationLevel > MaxOptLevel) {
1721 Diags.
Report(diag::warn_drv_optimization_value)
1722 << Args.getLastArg(OPT_O)->getAsString(Args) <<
"-O" << MaxOptLevel;
1723 OptimizationLevel = MaxOptLevel;
1725 Opts.OptimizationLevel = OptimizationLevel;
1734#define CODEGEN_OPTION_WITH_MARSHALLING(...) \
1735 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
1736#include "clang/Driver/Options.inc"
1737#undef CODEGEN_OPTION_WITH_MARSHALLING
1741 if (Opts.OptimizationLevel == 0) {
1743 }
else if (
const Arg *A = Args.getLastArg(options::OPT_finline_functions,
1744 options::OPT_finline_hint_functions,
1745 options::OPT_fno_inline_functions,
1746 options::OPT_fno_inline)) {
1749 if (A->getOption().matches(options::OPT_finline_functions))
1751 else if (A->getOption().matches(options::OPT_finline_hint_functions))
1761 Opts.DirectAccessExternalData =
1762 Args.hasArg(OPT_fdirect_access_external_data) ||
1763 (!Args.hasArg(OPT_fno_direct_access_external_data) &&
1766 if (Arg *A = Args.getLastArg(OPT_debug_info_kind_EQ)) {
1768 llvm::StringSwitch<unsigned>(A->getValue())
1769 .Case(
"line-tables-only", llvm::codegenoptions::DebugLineTablesOnly)
1770 .Case(
"line-directives-only",
1771 llvm::codegenoptions::DebugDirectivesOnly)
1772 .Case(
"constructor", llvm::codegenoptions::DebugInfoConstructor)
1773 .Case(
"limited", llvm::codegenoptions::LimitedDebugInfo)
1774 .Case(
"standalone", llvm::codegenoptions::FullDebugInfo)
1775 .Case(
"unused-types", llvm::codegenoptions::UnusedTypeInfo)
1778 Diags.
Report(diag::err_drv_invalid_value) << A->getAsString(Args)
1781 Opts.setDebugInfo(
static_cast<llvm::codegenoptions::DebugInfoKind
>(Val));
1787 Args.getLastArg(OPT_fuse_ctor_homing, OPT_fno_use_ctor_homing)) {
1788 if (A->getOption().matches(OPT_fuse_ctor_homing) &&
1789 Opts.getDebugInfo() == llvm::codegenoptions::LimitedDebugInfo)
1790 Opts.setDebugInfo(llvm::codegenoptions::DebugInfoConstructor);
1791 if (A->getOption().matches(OPT_fno_use_ctor_homing) &&
1792 Opts.getDebugInfo() == llvm::codegenoptions::DebugInfoConstructor)
1793 Opts.setDebugInfo(llvm::codegenoptions::LimitedDebugInfo);
1796 for (
const auto &Arg : Args.getAllArgValues(OPT_fdebug_prefix_map_EQ)) {
1797 auto Split = StringRef(Arg).split(
'=');
1801 for (
const auto &Arg : Args.getAllArgValues(OPT_fcoverage_prefix_map_EQ)) {
1802 auto Split = StringRef(Arg).split(
'=');
1806 const llvm::Triple::ArchType DebugEntryValueArchs[] = {
1807 llvm::Triple::x86, llvm::Triple::x86_64, llvm::Triple::aarch64,
1808 llvm::Triple::arm, llvm::Triple::armeb, llvm::Triple::mips,
1809 llvm::Triple::mipsel, llvm::Triple::mips64, llvm::Triple::mips64el};
1812 llvm::is_contained(DebugEntryValueArchs,
T.getArch()))
1813 Opts.EmitCallSiteInfo =
true;
1816 Diags.
Report(diag::warn_ignoring_verify_debuginfo_preserve_export)
1821 Opts.NewStructPathTBAA = !Args.hasArg(OPT_no_struct_path_tbaa) &&
1822 Args.hasArg(OPT_new_struct_path_tbaa);
1824 Opts.SimplifyLibCalls = !
LangOpts->NoBuiltin;
1825 if (Opts.SimplifyLibCalls)
1828 Args.hasFlag(OPT_funroll_loops, OPT_fno_unroll_loops,
1829 (Opts.OptimizationLevel > 1));
1831 std::string(Args.getLastArgValue(OPT_fbinutils_version_EQ));
1833 Opts.DebugTemplateAlias = Args.hasArg(OPT_gtemplate_alias);
1835 Opts.DebugNameTable =
static_cast<unsigned>(
1836 Args.hasArg(OPT_ggnu_pubnames)
1837 ? llvm::DICompileUnit::DebugNameTableKind::GNU
1838 : Args.hasArg(OPT_gpubnames)
1839 ? llvm::DICompileUnit::DebugNameTableKind::Default
1840 : llvm::DICompileUnit::DebugNameTableKind::None);
1841 if (
const Arg *A = Args.getLastArg(OPT_gsimple_template_names_EQ)) {
1842 StringRef
Value = A->getValue();
1844 Diags.
Report(diag::err_drv_unsupported_option_argument)
1845 << A->getSpelling() << A->getValue();
1846 Opts.setDebugSimpleTemplateNames(
1847 StringRef(A->getValue()) ==
"simple"
1848 ? llvm::codegenoptions::DebugTemplateNamesKind::Simple
1849 : llvm::codegenoptions::DebugTemplateNamesKind::Mangled);
1852 if (
const Arg *A = Args.getLastArg(OPT_ftime_report, OPT_ftime_report_EQ)) {
1853 Opts.TimePasses =
true;
1856 if (A->getOption().getID() == OPT_ftime_report_EQ) {
1857 StringRef Val = A->getValue();
1858 if (Val ==
"per-pass")
1859 Opts.TimePassesPerRun =
false;
1860 else if (Val ==
"per-pass-run")
1861 Opts.TimePassesPerRun =
true;
1863 Diags.
Report(diag::err_drv_invalid_value)
1864 << A->getAsString(Args) << A->getValue();
1868 Opts.PrepareForLTO =
false;
1869 Opts.PrepareForThinLTO =
false;
1870 if (Arg *A = Args.getLastArg(OPT_flto_EQ)) {
1871 Opts.PrepareForLTO =
true;
1872 StringRef S = A->getValue();
1874 Opts.PrepareForThinLTO =
true;
1875 else if (S !=
"full")
1876 Diags.
Report(diag::err_drv_invalid_value) << A->getAsString(Args) << S;
1877 if (Args.hasArg(OPT_funified_lto))
1878 Opts.PrepareForThinLTO =
true;
1880 if (Arg *A = Args.getLastArg(OPT_fthinlto_index_EQ)) {
1882 Diags.
Report(diag::err_drv_argument_only_allowed_with)
1883 << A->getAsString(Args) <<
"-x ir";
1885 std::string(Args.getLastArgValue(OPT_fthinlto_index_EQ));
1887 if (Arg *A = Args.getLastArg(OPT_save_temps_EQ))
1889 llvm::StringSwitch<std::string>(A->getValue())
1890 .Case(
"obj", OutputFile)
1891 .Default(llvm::sys::path::filename(OutputFile).str());
1894 const char *MemProfileBasename =
"memprof.profraw";
1895 if (Args.hasArg(OPT_fmemory_profile_EQ)) {
1897 std::string(Args.getLastArgValue(OPT_fmemory_profile_EQ)));
1898 llvm::sys::path::append(Path, MemProfileBasename);
1900 }
else if (Args.hasArg(OPT_fmemory_profile))
1905 if (Args.hasArg(OPT_coverage_version_EQ)) {
1906 StringRef CoverageVersion = Args.getLastArgValue(OPT_coverage_version_EQ);
1907 if (CoverageVersion.size() != 4) {
1908 Diags.
Report(diag::err_drv_invalid_value)
1909 << Args.getLastArg(OPT_coverage_version_EQ)->getAsString(Args)
1919 for (
const auto &A : Args) {
1921 if (A->getOption().getID() == options::OPT_o ||
1922 A->getOption().getID() == options::OPT_INPUT ||
1923 A->getOption().getID() == options::OPT_x ||
1924 A->getOption().getID() == options::OPT_fembed_bitcode ||
1925 A->getOption().matches(options::OPT_W_Group))
1928 A->render(Args, ASL);
1929 for (
const auto &arg : ASL) {
1930 StringRef ArgStr(arg);
1931 Opts.
CmdArgs.insert(Opts.
CmdArgs.end(), ArgStr.begin(), ArgStr.end());
1937 auto XRayInstrBundles =
1938 Args.getAllArgValues(OPT_fxray_instrumentation_bundle);
1939 if (XRayInstrBundles.empty())
1942 for (
const auto &A : XRayInstrBundles)
1946 if (
const Arg *A = Args.getLastArg(OPT_fcf_protection_EQ)) {
1947 StringRef Name = A->getValue();
1948 if (Name ==
"full") {
1949 Opts.CFProtectionReturn = 1;
1950 Opts.CFProtectionBranch = 1;
1951 }
else if (Name ==
"return")
1952 Opts.CFProtectionReturn = 1;
1953 else if (Name ==
"branch")
1954 Opts.CFProtectionBranch = 1;
1955 else if (Name !=
"none")
1956 Diags.
Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Name;
1959 if (
const Arg *A = Args.getLastArg(OPT_mfunction_return_EQ)) {
1960 auto Val = llvm::StringSwitch<llvm::FunctionReturnThunksKind>(A->getValue())
1961 .Case(
"keep", llvm::FunctionReturnThunksKind::Keep)
1962 .Case(
"thunk-extern", llvm::FunctionReturnThunksKind::Extern)
1963 .Default(llvm::FunctionReturnThunksKind::Invalid);
1966 Diags.
Report(diag::err_drv_argument_not_allowed_with)
1967 << A->getSpelling() <<
T.getTriple();
1968 else if (Val == llvm::FunctionReturnThunksKind::Invalid)
1969 Diags.
Report(diag::err_drv_invalid_value)
1970 << A->getAsString(Args) << A->getValue();
1971 else if (Val == llvm::FunctionReturnThunksKind::Extern &&
1972 Args.getLastArgValue(OPT_mcmodel_EQ) ==
"large")
1973 Diags.
Report(diag::err_drv_argument_not_allowed_with)
1974 << A->getAsString(Args)
1975 << Args.getLastArg(OPT_mcmodel_EQ)->getAsString(Args);
1977 Opts.FunctionReturnThunks =
static_cast<unsigned>(Val);
1981 Args.filtered(OPT_mlink_bitcode_file, OPT_mlink_builtin_bitcode)) {
1984 if (A->getOption().matches(OPT_mlink_builtin_bitcode)) {
1985 F.
LinkFlags = llvm::Linker::Flags::LinkOnlyNeeded;
1994 if (Arg *A = Args.getLastArg(OPT_fdenormal_fp_math_EQ)) {
1995 StringRef Val = A->getValue();
1999 Diags.
Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Val;
2002 if (Arg *A = Args.getLastArg(OPT_fdenormal_fp_math_f32_EQ)) {
2003 StringRef Val = A->getValue();
2006 Diags.
Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Val;
2012 Args.getLastArg(OPT_fpcc_struct_return, OPT_freg_struct_return,
2013 OPT_maix_struct_return, OPT_msvr4_struct_return)) {
2017 Diags.
Report(diag::err_drv_unsupported_opt_for_target)
2018 << A->getSpelling() <<
T.str();
2020 const Option &O = A->getOption();
2021 if (O.matches(OPT_fpcc_struct_return) ||
2022 O.matches(OPT_maix_struct_return)) {
2025 assert(O.matches(OPT_freg_struct_return) ||
2026 O.matches(OPT_msvr4_struct_return));
2031 if (Arg *A = Args.getLastArg(OPT_mxcoff_roptr)) {
2033 Diags.
Report(diag::err_drv_unsupported_opt_for_target)
2034 << A->getSpelling() <<
T.str();
2044 if (!Args.hasFlag(OPT_fdata_sections, OPT_fno_data_sections,
false))
2045 Diags.
Report(diag::err_roptr_requires_data_sections);
2047 Opts.XCOFFReadOnlyPointers =
true;
2050 if (Arg *A = Args.getLastArg(OPT_mabi_EQ_quadword_atomics)) {
2051 if (!
T.isOSAIX() ||
T.isPPC32())
2052 Diags.
Report(diag::err_drv_unsupported_opt_for_target)
2053 << A->getSpelling() <<
T.str();
2056 bool NeedLocTracking =
false;
2059 NeedLocTracking =
true;
2061 if (Arg *A = Args.getLastArg(OPT_opt_record_passes)) {
2063 NeedLocTracking =
true;
2066 if (Arg *A = Args.getLastArg(OPT_opt_record_format)) {
2068 NeedLocTracking =
true;
2078 Diags, Args, OPT_Rpass_analysis_EQ,
"pass-analysis");
2088 if (Opts.DiagnosticsWithHotness && !UsingProfile &&
2091 Diags.
Report(diag::warn_drv_diagnostics_hotness_requires_pgo)
2092 <<
"-fdiagnostics-show-hotness";
2096 Args.getLastArg(options::OPT_fdiagnostics_hotness_threshold_EQ)) {
2098 llvm::remarks::parseHotnessThresholdOption(
arg->getValue());
2101 Diags.
Report(diag::err_drv_invalid_diagnotics_hotness_threshold)
2102 <<
"-fdiagnostics-hotness-threshold=";
2108 Diags.
Report(diag::warn_drv_diagnostics_hotness_requires_pgo)
2109 <<
"-fdiagnostics-hotness-threshold=";
2114 Args.getLastArg(options::OPT_fdiagnostics_misexpect_tolerance_EQ)) {
2118 Diags.
Report(diag::err_drv_invalid_diagnotics_misexpect_tolerance)
2119 <<
"-fdiagnostics-misexpect-tolerance=";
2125 Diags.
Report(diag::warn_drv_diagnostics_misexpect_requires_pgo)
2126 <<
"-fdiagnostics-misexpect-tolerance=";
2133 if (UsingSampleProfile)
2134 NeedLocTracking =
true;
2137 NeedLocTracking =
true;
2141 if (NeedLocTracking &&
2142 Opts.getDebugInfo() == llvm::codegenoptions::NoDebugInfo)
2143 Opts.setDebugInfo(llvm::codegenoptions::LocTrackingOnly);
2148 Args.getAllArgValues(OPT_fsanitize_recover_EQ), Diags,
2151 Args.getAllArgValues(OPT_fsanitize_trap_EQ), Diags,
2154 Opts.EmitVersionIdentMetadata = Args.hasFlag(OPT_Qy, OPT_Qn,
true);
2156 if (Args.hasArg(options::OPT_ffinite_loops))
2158 else if (Args.hasArg(options::OPT_fno_finite_loops))
2161 Opts.EmitIEEENaNCompliantInsts = Args.hasFlag(
2162 options::OPT_mamdgpu_ieee, options::OPT_mno_amdgpu_ieee,
true);
2163 if (!Opts.EmitIEEENaNCompliantInsts && !LangOptsRef.NoHonorNaNs)
2164 Diags.
Report(diag::err_drv_amdgpu_ieee_without_no_honor_nans);
2172#define DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING(...) \
2173 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
2174#include "clang/Driver/Options.inc"
2175#undef DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING
2180 for (
const auto &Dep : Opts.
ExtraDeps) {
2181 switch (Dep.second) {
2194 GenerateArg(Consumer, OPT_fdepfile_entry, Dep.first);
2203 bool ShowLineMarkers) {
2207#define DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING(...) \
2208 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
2209#include "clang/Driver/Options.inc"
2210#undef DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING
2212 if (Args.hasArg(OPT_show_includes)) {
2227 if (!Args.hasArg(OPT_fno_sanitize_ignorelist)) {
2228 for (
const auto *A : Args.filtered(OPT_fsanitize_ignorelist_EQ)) {
2229 StringRef Val = A->getValue();
2230 if (!Val.contains(
'='))
2234 for (
const auto *A : Args.filtered(OPT_fsanitize_system_ignorelist_EQ)) {
2235 StringRef Val = A->getValue();
2236 if (!Val.contains(
'='))
2243 for (
const auto &
Filename : Args.getAllArgValues(OPT_fprofile_list_EQ))
2247 for (
const auto *A : Args.filtered(OPT_fdepfile_entry))
2251 for (
const auto *A : Args.filtered(OPT_fmodule_file)) {
2252 StringRef Val = A->getValue();
2253 if (!Val.contains(
'='))
2263 Diags.
Report(diag::err_drv_print_header_env_var_combination_cc1)
2264 << Args.getLastArg(OPT_header_include_format_EQ)->getValue()
2265 << Args.getLastArg(OPT_header_include_filtering_EQ)->getValue();
2279 }
ShowColors = DefaultColor ? Colors_Auto : Colors_Off;
2280 for (
auto *A : Args) {
2281 const Option &O = A->getOption();
2282 if (O.matches(options::OPT_fcolor_diagnostics)) {
2284 }
else if (O.matches(options::OPT_fno_color_diagnostics)) {
2286 }
else if (O.matches(options::OPT_fdiagnostics_color_EQ)) {
2287 StringRef
Value(A->getValue());
2288 if (
Value ==
"always")
2290 else if (
Value ==
"never")
2292 else if (
Value ==
"auto")
2298 llvm::sys::Process::StandardErrHasColors());
2304 for (
const auto &Prefix : VerifyPrefixes) {
2307 auto BadChar = llvm::find_if(Prefix, [](
char C) {
2310 if (BadChar != Prefix.end() || !
isLetter(Prefix[0])) {
2312 Diags.
Report(diag::err_drv_invalid_value) <<
"-verify=" << Prefix;
2313 Diags.
Report(diag::note_drv_verify_prefix_spelling);
2323#define FILE_SYSTEM_OPTION_WITH_MARSHALLING(...) \
2324 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
2325#include "clang/Driver/Options.inc"
2326#undef FILE_SYSTEM_OPTION_WITH_MARSHALLING
2335#define FILE_SYSTEM_OPTION_WITH_MARSHALLING(...) \
2336 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
2337#include "clang/Driver/Options.inc"
2338#undef FILE_SYSTEM_OPTION_WITH_MARSHALLING
2346#define MIGRATOR_OPTION_WITH_MARSHALLING(...) \
2347 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
2348#include "clang/Driver/Options.inc"
2349#undef MIGRATOR_OPTION_WITH_MARSHALLING
2358#define MIGRATOR_OPTION_WITH_MARSHALLING(...) \
2359 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
2360#include "clang/Driver/Options.inc"
2361#undef MIGRATOR_OPTION_WITH_MARSHALLING
2366void CompilerInvocationBase::GenerateDiagnosticArgs(
2368 bool DefaultDiagColor) {
2370#define DIAG_OPTION_WITH_MARSHALLING(...) \
2371 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
2372#include "clang/Driver/Options.inc"
2373#undef DIAG_OPTION_WITH_MARSHALLING
2376 GenerateArg(Consumer, OPT_diagnostic_serialized_file,
2379 if (Opts.ShowColors)
2382 if (Opts.VerifyDiagnostics &&
2387 if (Prefix !=
"expected")
2394 GenerateArg(Consumer, OPT_verify_ignore_unexpected);
2397 GenerateArg(Consumer, OPT_verify_ignore_unexpected_EQ,
"note");
2399 GenerateArg(Consumer, OPT_verify_ignore_unexpected_EQ,
"remark");
2401 GenerateArg(Consumer, OPT_verify_ignore_unexpected_EQ,
"warning");
2403 GenerateArg(Consumer, OPT_verify_ignore_unexpected_EQ,
"error");
2408 if (
Warning ==
"undef-prefix")
2410 Consumer(StringRef(
"-W") +
Warning);
2416 StringRef IgnoredRemarks[] = {
"pass",
"no-pass",
2417 "pass-analysis",
"no-pass-analysis",
2418 "pass-missed",
"no-pass-missed"};
2419 if (llvm::is_contained(IgnoredRemarks,
Remark))
2422 Consumer(StringRef(
"-R") +
Remark);
2426std::unique_ptr<DiagnosticOptions>
2428 auto DiagOpts = std::make_unique<DiagnosticOptions>();
2429 unsigned MissingArgIndex, MissingArgCount;
2431 Argv.slice(1), MissingArgIndex, MissingArgCount);
2434 if (std::optional<std::string> NoColor =
2435 llvm::sys::Process::GetEnv(
"NO_COLOR");
2436 NoColor && !NoColor->empty()) {
2451 bool DefaultDiagColor) {
2452 std::optional<DiagnosticsEngine> IgnoringDiags;
2456 Diags = &*IgnoringDiags;
2465#define DIAG_OPTION_WITH_MARSHALLING(...) \
2466 PARSE_OPTION_WITH_MARSHALLING(Args, *Diags, __VA_ARGS__)
2467#include "clang/Driver/Options.inc"
2468#undef DIAG_OPTION_WITH_MARSHALLING
2470 llvm::sys::Process::UseANSIEscapeCodes(Opts.UseANSIEscapeCodes);
2473 Args.getLastArg(OPT_diagnostic_serialized_file, OPT__serialize_diags))
2477 Opts.VerifyDiagnostics = Args.hasArg(OPT_verify) || Args.hasArg(OPT_verify_EQ);
2479 if (Args.hasArg(OPT_verify))
2484 Opts.VerifyDiagnostics =
false;
2489 "-verify-ignore-unexpected=",
2490 Args.getAllArgValues(OPT_verify_ignore_unexpected_EQ), *Diags, DiagMask);
2491 if (Args.hasArg(OPT_verify_ignore_unexpected))
2493 Opts.setVerifyIgnoreUnexpected(DiagMask);
2495 Diags->
Report(diag::warn_ignoring_ftabstop_value)
2511 std::string &BlockName,
2512 unsigned &MajorVersion,
2513 unsigned &MinorVersion,
2515 std::string &UserInfo) {
2517 Arg.split(Args,
':', 5);
2518 if (Args.size() < 5)
2521 BlockName = std::string(Args[0]);
2522 if (Args[1].getAsInteger(10, MajorVersion))
return true;
2523 if (Args[2].getAsInteger(10, MinorVersion))
return true;
2524 if (Args[3].getAsInteger(2, Hashed))
return true;
2525 if (Args.size() > 4)
2526 UserInfo = std::string(Args[4]);
2535 static const std::pair<frontend::ActionKind, unsigned> Table[] = {
2566 OPT_emit_reduced_module_interface},
2584 OPT_print_dependency_directives_minimized_source},
2591static std::optional<frontend::ActionKind>
2594 if (ActionOpt.second == Opt.getID())
2595 return ActionOpt.first;
2597 return std::nullopt;
2601static std::optional<OptSpecifier>
2604 if (ActionOpt.first == ProgramAction)
2605 return OptSpecifier(ActionOpt.second);
2607 return std::nullopt;
2613#define FRONTEND_OPTION_WITH_MARSHALLING(...) \
2614 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
2615#include "clang/Driver/Options.inc"
2616#undef FRONTEND_OPTION_WITH_MARSHALLING
2618 std::optional<OptSpecifier> ProgramActionOpt =
2622 std::function<void()> GenerateProgramAction = [&]() {
2626 if (!ProgramActionOpt) {
2629 "Frontend action without option.");
2630 GenerateProgramAction = [&]() {
2637 GenerateProgramAction = [&]() {
2645 llvm_unreachable(
"Default AST dump format.");
2652 GenerateArg(Consumer, OPT_ast_dump_all_EQ, Format);
2665 GenerateProgramAction = [&]() {
2670 GenerateProgramAction();
2672 for (
const auto &PluginArgs : Opts.
PluginArgs) {
2674 for (
const auto &PluginArg : PluginArgs.second)
2676 Opt.getPrefix() + Opt.getName() + PluginArgs.first,
2677 Opt.getKind(), 0, PluginArg);
2681 if (
auto *TestExt = dyn_cast_or_null<TestModuleFileExtension>(Ext.get()))
2682 GenerateArg(Consumer, OPT_ftest_module_file_extension_EQ, TestExt->str());
2688 for (
const auto &Plugin : Opts.
Plugins)
2694 GenerateArg(Consumer, OPT_fmodule_file, ModuleFile);
2701 GenerateArg(Consumer, OPT_aux_target_feature, Feature);
2707 StringRef HeaderUnit =
"";
2712 HeaderUnit =
"-user";
2715 HeaderUnit =
"-system";
2718 HeaderUnit =
"-header-unit";
2721 StringRef Header = IsHeader ?
"-header" :
"";
2744 Lang =
"objective-c";
2747 Lang =
"objective-c++";
2750 Lang =
"renderscript";
2753 Lang =
"assembler-with-cpp";
2757 "Generating -x argument for unknown language (not precompiled).");
2772 Lang + HeaderUnit + Header +
ModuleMap + Preprocessed);
2776 for (
const auto &Input : Opts.
Inputs)
2777 Consumer(Input.getFile());
2786#define FRONTEND_OPTION_WITH_MARSHALLING(...) \
2787 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
2788#include "clang/Driver/Options.inc"
2789#undef FRONTEND_OPTION_WITH_MARSHALLING
2792 if (
const Arg *A = Args.getLastArg(OPT_Action_Group)) {
2793 OptSpecifier Opt = OptSpecifier(A->getOption().getID());
2795 assert(ProgramAction &&
"Option specifier not in Action_Group.");
2798 (Opt == OPT_ast_dump_all_EQ || Opt == OPT_ast_dump_EQ)) {
2799 unsigned Val = llvm::StringSwitch<unsigned>(A->getValue())
2802 .Default(std::numeric_limits<unsigned>::max());
2804 if (Val != std::numeric_limits<unsigned>::max())
2807 Diags.
Report(diag::err_drv_invalid_value)
2808 << A->getAsString(Args) << A->getValue();
2818 Args.hasArg(OPT_interface_stub_version_EQ)
2819 ? Args.getLastArgValue(OPT_interface_stub_version_EQ)
2821 if (ArgStr ==
"experimental-yaml-elf-v1" ||
2822 ArgStr ==
"experimental-ifs-v1" || ArgStr ==
"experimental-ifs-v2" ||
2823 ArgStr ==
"experimental-tapi-elf-v1") {
2824 std::string ErrorMessage =
2825 "Invalid interface stub format: " + ArgStr.str() +
2827 Diags.
Report(diag::err_drv_invalid_value)
2828 <<
"Must specify a valid interface stub format type, ie: "
2829 "-interface-stub-version=ifs-v1"
2832 }
else if (!ArgStr.starts_with(
"ifs-")) {
2833 std::string ErrorMessage =
2834 "Invalid interface stub format: " + ArgStr.str() +
".";
2835 Diags.
Report(diag::err_drv_invalid_value)
2836 <<
"Must specify a valid interface stub format type, ie: "
2837 "-interface-stub-version=ifs-v1"
2852 if (!A->getSpelling().starts_with(
"-ast-dump")) {
2853 const Arg *SavedAction =
nullptr;
2854 for (
const Arg *AA :
2855 Args.filtered(OPT_Action_Group, OPT_main_file_name)) {
2856 if (AA->getOption().matches(OPT_main_file_name)) {
2857 SavedAction =
nullptr;
2858 }
else if (!SavedAction) {
2861 if (!A->getOption().matches(OPT_ast_dump_EQ))
2862 Diags.
Report(diag::err_fe_invalid_multiple_actions)
2863 << SavedAction->getSpelling() << A->getSpelling();
2870 if (
const Arg* A = Args.getLastArg(OPT_plugin)) {
2871 Opts.
Plugins.emplace_back(A->getValue(0));
2875 for (
const auto *AA : Args.filtered(OPT_plugin_arg))
2876 Opts.
PluginArgs[AA->getValue(0)].emplace_back(AA->getValue(1));
2878 for (
const std::string &Arg :
2879 Args.getAllArgValues(OPT_ftest_module_file_extension_EQ)) {
2880 std::string BlockName;
2881 unsigned MajorVersion;
2882 unsigned MinorVersion;
2884 std::string UserInfo;
2886 MinorVersion, Hashed, UserInfo)) {
2887 Diags.
Report(diag::err_test_module_file_extension_format) << Arg;
2894 std::make_shared<TestModuleFileExtension>(
2895 BlockName, MajorVersion, MinorVersion, Hashed, UserInfo));
2898 if (
const Arg *A = Args.getLastArg(OPT_code_completion_at)) {
2902 Diags.
Report(diag::err_drv_invalid_value)
2903 << A->getAsString(Args) << A->getValue();
2906 Opts.
Plugins = Args.getAllArgValues(OPT_load);
2907 Opts.
ASTDumpDecls = Args.hasArg(OPT_ast_dump, OPT_ast_dump_EQ);
2908 Opts.
ASTDumpAll = Args.hasArg(OPT_ast_dump_all, OPT_ast_dump_all_EQ);
2910 for (
const auto *A : Args.filtered(OPT_fmodule_file)) {
2911 StringRef Val = A->getValue();
2912 if (!Val.contains(
'='))
2917 Diags.
Report(diag::err_drv_argument_only_allowed_with) <<
"-fsystem-module"
2919 if (Args.hasArg(OPT_fclangir) || Args.hasArg(OPT_emit_cir))
2922 if (Args.hasArg(OPT_aux_target_cpu))
2923 Opts.
AuxTargetCPU = std::string(Args.getLastArgValue(OPT_aux_target_cpu));
2924 if (Args.hasArg(OPT_aux_target_feature))
2929 Diags.
Report(diag::err_drv_argument_not_allowed_with)
2930 <<
"ARC migration" <<
"ObjC migration";
2934 if (
const Arg *A = Args.getLastArg(OPT_x)) {
2935 StringRef XValue = A->getValue();
2940 bool Preprocessed = XValue.consume_back(
"-cpp-output");
2941 bool ModuleMap = XValue.consume_back(
"-module-map");
2944 XValue !=
"precompiled-header" && XValue.consume_back(
"-header");
2950 if (IsHeader || Preprocessed) {
2951 if (XValue.consume_back(
"-header-unit"))
2953 else if (XValue.consume_back(
"-system"))
2955 else if (XValue.consume_back(
"-user"))
2961 IsHeaderFile = IsHeader && !Preprocessed && !
ModuleMap &&
2965 DashX = llvm::StringSwitch<InputKind>(XValue)
2982 DashX = llvm::StringSwitch<InputKind>(XValue)
2990 DashX = llvm::StringSwitch<InputKind>(XValue)
2993 .Cases(
"ast",
"pcm",
"precompiled-header",
3000 Diags.
Report(diag::err_drv_invalid_value)
3001 << A->getAsString(Args) << A->getValue();
3008 IsHeaderFile =
true;
3009 }
else if (IsHeaderFile)
3016 std::vector<std::string> Inputs = Args.getAllArgValues(OPT_INPUT);
3019 Inputs.push_back(
"-");
3023 Diags.
Report(diag::err_drv_header_unit_extra_inputs) << Inputs[1];
3025 for (
unsigned i = 0, e = Inputs.size(); i != e; ++i) {
3029 StringRef(Inputs[i]).rsplit(
'.').second);
3038 bool IsSystem =
false;
3047 Opts.
Inputs.emplace_back(std::move(Inputs[i]), IK, IsSystem);
3057 std::string ClangExecutable =
3058 llvm::sys::fs::getMainExecutable(Argv0, MainAddr);
3065#define HEADER_SEARCH_OPTION_WITH_MARSHALLING(...) \
3066 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
3067#include "clang/Driver/Options.inc"
3068#undef HEADER_SEARCH_OPTION_WITH_MARSHALLING
3080 GenerateArg(Consumer, OPT_fprebuilt_module_path, Path);
3083 GenerateArg(Consumer, OPT_fmodules_ignore_macro, Macro.val());
3087 std::optional<bool> IsFramework,
3088 std::optional<bool> IgnoreSysRoot) {
3089 return llvm::is_contained(Groups, Entry.
Group) &&
3090 (!IsFramework || (Entry.
IsFramework == *IsFramework)) &&
3091 (!IgnoreSysRoot || (Entry.
IgnoreSysRoot == *IgnoreSysRoot));
3099 std::nullopt,
true);
3101 OptSpecifier Opt = [It, Matches]() {
3110 llvm_unreachable(
"Unexpected HeaderSearchOptions::Entry.");
3126 It->Group ==
frontend::After ? OPT_iwithprefix : OPT_iwithprefixbefore;
3133 for (; It < End && Matches(*It, {
frontend::After},
false,
true); ++It)
3139 GenerateArg(Consumer, It->IgnoreSysRoot ? OPT_isystem : OPT_iwithsysroot,
3144 GenerateArg(Consumer, OPT_iframeworkwithsysroot, It->Path);
3152 GenerateArg(Consumer, OPT_objc_isystem, It->Path);
3154 GenerateArg(Consumer, OPT_objcxx_isystem, It->Path);
3164 ? OPT_internal_isystem
3165 : OPT_internal_externc_isystem;
3169 assert(It == End &&
"Unhandled HeaderSearchOption::Entry.");
3173 OptSpecifier Opt =
P.IsSystemHeader ? OPT_system_header_prefix
3174 : OPT_no_system_header_prefix;
3184 const std::string &WorkingDir) {
3189#define HEADER_SEARCH_OPTION_WITH_MARSHALLING(...) \
3190 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
3191#include "clang/Driver/Options.inc"
3192#undef HEADER_SEARCH_OPTION_WITH_MARSHALLING
3194 if (
const Arg *A = Args.getLastArg(OPT_stdlib_EQ))
3195 Opts.
UseLibcxx = (strcmp(A->getValue(),
"libc++") == 0);
3199 if (!(
P.empty() || llvm::sys::path::is_absolute(
P))) {
3200 if (WorkingDir.empty())
3201 llvm::sys::fs::make_absolute(
P);
3203 llvm::sys::fs::make_absolute(WorkingDir,
P);
3205 llvm::sys::path::remove_dots(
P);
3209 for (
const auto *A : Args.filtered(OPT_fmodule_file)) {
3210 StringRef Val = A->getValue();
3211 if (Val.contains(
'=')) {
3212 auto Split = Val.split(
'=');
3214 std::string(Split.first), std::string(Split.second));
3217 for (
const auto *A : Args.filtered(OPT_fprebuilt_module_path))
3220 for (
const auto *A : Args.filtered(OPT_fmodules_ignore_macro)) {
3221 StringRef MacroDef = A->getValue();
3223 llvm::CachedHashString(MacroDef.split(
'=').first));
3227 bool IsIndexHeaderMap =
false;
3228 bool IsSysrootSpecified =
3229 Args.hasArg(OPT__sysroot_EQ) || Args.hasArg(OPT_isysroot);
3233 auto PrefixHeaderPath = [IsSysrootSpecified,
3234 &Opts](
const llvm::opt::Arg *A,
3235 bool IsFramework =
false) -> std::string {
3236 assert(A->getNumValues() &&
"Unexpected empty search path flag!");
3237 if (IsSysrootSpecified && !IsFramework && A->getValue()[0] ==
'=') {
3239 llvm::sys::path::append(Buffer, Opts.
Sysroot,
3240 llvm::StringRef(A->getValue()).substr(1));
3241 return std::string(Buffer);
3243 return A->getValue();
3246 for (
const auto *A : Args.filtered(OPT_I, OPT_F, OPT_index_header_map)) {
3247 if (A->getOption().matches(OPT_index_header_map)) {
3249 IsIndexHeaderMap =
true;
3256 bool IsFramework = A->getOption().matches(OPT_F);
3257 Opts.
AddPath(PrefixHeaderPath(A, IsFramework), Group, IsFramework,
3259 IsIndexHeaderMap =
false;
3263 StringRef Prefix =
"";
3264 for (
const auto *A :
3265 Args.filtered(OPT_iprefix, OPT_iwithprefix, OPT_iwithprefixbefore)) {
3266 if (A->getOption().matches(OPT_iprefix))
3267 Prefix = A->getValue();
3268 else if (A->getOption().matches(OPT_iwithprefix))
3274 for (
const auto *A : Args.filtered(OPT_idirafter))
3276 for (
const auto *A : Args.filtered(OPT_iquote))
3279 for (
const auto *A : Args.filtered(OPT_isystem, OPT_iwithsysroot)) {
3280 if (A->getOption().matches(OPT_iwithsysroot)) {
3287 for (
const auto *A : Args.filtered(OPT_iframework))
3289 for (
const auto *A : Args.filtered(OPT_iframeworkwithsysroot))
3294 for (
const auto *A : Args.filtered(OPT_c_isystem))
3296 for (
const auto *A : Args.filtered(OPT_cxx_isystem))
3298 for (
const auto *A : Args.filtered(OPT_objc_isystem))
3300 for (
const auto *A : Args.filtered(OPT_objcxx_isystem))
3304 for (
const auto *A :
3305 Args.filtered(OPT_internal_isystem, OPT_internal_externc_isystem)) {
3307 if (A->getOption().matches(OPT_internal_externc_isystem))
3309 Opts.
AddPath(A->getValue(), Group,
false,
true);
3313 for (
const auto *A :
3314 Args.filtered(OPT_system_header_prefix, OPT_no_system_header_prefix))
3316 A->getValue(), A->getOption().matches(OPT_system_header_prefix));
3318 for (
const auto *A : Args.filtered(OPT_ivfsoverlay, OPT_vfsoverlay))
3327 GenerateArg(Consumer, OPT_fapinotes_swift_version,
3331 GenerateArg(Consumer, OPT_iapinotes_modules, Path);
3336 if (
const Arg *A = Args.getLastArg(OPT_fapinotes_swift_version)) {
3338 diags.
Report(diag::err_drv_invalid_value)
3339 << A->getAsString(Args) << A->getValue();
3341 for (
const Arg *A : Args.filtered(OPT_iapinotes_modules))
3347 if (Opts.PointerAuthIntrinsics)
3349 if (Opts.PointerAuthCalls)
3351 if (Opts.PointerAuthReturns)
3353 if (Opts.PointerAuthAuthTraps)
3355 if (Opts.PointerAuthVTPtrAddressDiscrimination)
3356 GenerateArg(Consumer, OPT_fptrauth_vtable_pointer_address_discrimination);
3357 if (Opts.PointerAuthVTPtrTypeDiscrimination)
3358 GenerateArg(Consumer, OPT_fptrauth_vtable_pointer_type_discrimination);
3359 if (Opts.PointerAuthInitFini)
3365 Opts.PointerAuthIntrinsics = Args.hasArg(OPT_fptrauth_intrinsics);
3366 Opts.PointerAuthCalls = Args.hasArg(OPT_fptrauth_calls);
3367 Opts.PointerAuthReturns = Args.hasArg(OPT_fptrauth_returns);
3368 Opts.PointerAuthAuthTraps = Args.hasArg(OPT_fptrauth_auth_traps);
3369 Opts.PointerAuthVTPtrAddressDiscrimination =
3370 Args.hasArg(OPT_fptrauth_vtable_pointer_address_discrimination);
3371 Opts.PointerAuthVTPtrTypeDiscrimination =
3372 Args.hasArg(OPT_fptrauth_vtable_pointer_type_discrimination);
3373 Opts.PointerAuthInitFini = Args.hasArg(OPT_fptrauth_init_fini);
3383 llvm_unreachable(
"should not parse language flags for this input");
3419 llvm_unreachable(
"unexpected input language");
3428 return "Objective-C";
3432 return "Objective-C++";
3436 return "C++ for OpenCL";
3440 return "RenderScript";
3457 llvm_unreachable(
"unknown input language");
3460void CompilerInvocationBase::GenerateLangArgs(
const LangOptions &Opts,
3462 const llvm::Triple &
T,
3467 if (Opts.ObjCAutoRefCount)
3469 if (Opts.PICLevel != 0)
3470 GenerateArg(Consumer, OPT_pic_level, Twine(Opts.PICLevel));
3474 GenerateArg(Consumer, OPT_fsanitize_EQ, Sanitizer);
3479 OptSpecifier StdOpt;
3481 case LangStandard::lang_opencl10:
3482 case LangStandard::lang_opencl11:
3483 case LangStandard::lang_opencl12:
3484 case LangStandard::lang_opencl20:
3485 case LangStandard::lang_opencl30:
3486 case LangStandard::lang_openclcpp10:
3487 case LangStandard::lang_openclcpp2021:
3488 StdOpt = OPT_cl_std_EQ;
3491 StdOpt = OPT_std_EQ;
3498 if (Opts.IncludeDefaultHeader)
3499 GenerateArg(Consumer, OPT_finclude_default_header);
3500 if (Opts.DeclareOpenCLBuiltins)
3501 GenerateArg(Consumer, OPT_fdeclare_opencl_builtins);
3505#define LANG_OPTION_WITH_MARSHALLING(...) \
3506 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
3507#include "clang/Driver/Options.inc"
3508#undef LANG_OPTION_WITH_MARSHALLING
3519 else if (Opts.ObjCAutoRefCount == 1)
3522 if (Opts.ObjCWeakRuntime)
3523 GenerateArg(Consumer, OPT_fobjc_runtime_has_weak);
3528 if (Opts.ObjCSubscriptingLegacyRuntime)
3529 GenerateArg(Consumer, OPT_fobjc_subscripting_legacy_runtime);
3532 if (Opts.GNUCVersion != 0) {
3533 unsigned Major = Opts.GNUCVersion / 100 / 100;
3534 unsigned Minor = (Opts.GNUCVersion / 100) % 100;
3535 unsigned Patch = Opts.GNUCVersion % 100;
3537 Twine(Major) +
"." + Twine(Minor) +
"." + Twine(Patch));
3540 if (Opts.IgnoreXCOFFVisibility)
3541 GenerateArg(Consumer, OPT_mignore_xcoff_visibility);
3550 if (Opts.MSCompatibilityVersion != 0) {
3551 unsigned Major = Opts.MSCompatibilityVersion / 10000000;
3552 unsigned Minor = (Opts.MSCompatibilityVersion / 100000) % 100;
3553 unsigned Subminor = Opts.MSCompatibilityVersion % 100000;
3554 GenerateArg(Consumer, OPT_fms_compatibility_version,
3555 Twine(Major) +
"." + Twine(Minor) +
"." + Twine(Subminor));
3558 if ((!Opts.GNUMode && !Opts.MSVCCompat && !Opts.CPlusPlus17 && !Opts.C23) ||
3560 if (!Opts.Trigraphs)
3567 if (Opts.Blocks && !(Opts.OpenCL && Opts.OpenCLVersion == 200))
3570 if (Opts.ConvergentFunctions &&
3571 !(Opts.OpenCL || (Opts.CUDA && Opts.CUDAIsDevice) || Opts.SYCLIsDevice ||
3575 if (Opts.NoBuiltin && !Opts.Freestanding)
3578 if (!Opts.NoBuiltin)
3582 if (Opts.LongDoubleSize == 128)
3584 else if (Opts.LongDoubleSize == 64)
3586 else if (Opts.LongDoubleSize == 80)
3593 if (Opts.OpenMP && !Opts.OpenMPSimd) {
3596 if (Opts.OpenMP != 51)
3597 GenerateArg(Consumer, OPT_fopenmp_version_EQ, Twine(Opts.OpenMP));
3599 if (!Opts.OpenMPUseTLS)
3602 if (Opts.OpenMPIsTargetDevice)
3603 GenerateArg(Consumer, OPT_fopenmp_is_target_device);
3605 if (Opts.OpenMPIRBuilder)
3606 GenerateArg(Consumer, OPT_fopenmp_enable_irbuilder);
3609 if (Opts.OpenMPSimd) {
3612 if (Opts.OpenMP != 51)
3613 GenerateArg(Consumer, OPT_fopenmp_version_EQ, Twine(Opts.OpenMP));
3616 if (Opts.OpenMPThreadSubscription)
3617 GenerateArg(Consumer, OPT_fopenmp_assume_threads_oversubscription);
3619 if (Opts.OpenMPTeamSubscription)
3620 GenerateArg(Consumer, OPT_fopenmp_assume_teams_oversubscription);
3622 if (Opts.OpenMPTargetDebug != 0)
3623 GenerateArg(Consumer, OPT_fopenmp_target_debug_EQ,
3624 Twine(Opts.OpenMPTargetDebug));
3626 if (Opts.OpenMPCUDANumSMs != 0)
3627 GenerateArg(Consumer, OPT_fopenmp_cuda_number_of_sm_EQ,
3628 Twine(Opts.OpenMPCUDANumSMs));
3630 if (Opts.OpenMPCUDABlocksPerSM != 0)
3631 GenerateArg(Consumer, OPT_fopenmp_cuda_blocks_per_sm_EQ,
3632 Twine(Opts.OpenMPCUDABlocksPerSM));
3634 if (Opts.OpenMPCUDAReductionBufNum != 1024)
3635 GenerateArg(Consumer, OPT_fopenmp_cuda_teams_reduction_recs_num_EQ,
3636 Twine(Opts.OpenMPCUDAReductionBufNum));
3639 std::string Targets;
3640 llvm::raw_string_ostream OS(Targets);
3643 [&OS](
const llvm::Triple &
T) { OS << T.str(); },
",");
3644 GenerateArg(Consumer, OPT_fopenmp_targets_EQ, OS.str());
3650 if (Opts.OpenMPCUDAMode)
3670 GenerateArg(Consumer, OPT_ffp_contract,
"fast-honor-pragmas");
3673 GenerateArg(Consumer, OPT_fsanitize_EQ, Sanitizer);
3677 GenerateArg(Consumer, OPT_fsanitize_ignorelist_EQ, F);
3679 switch (Opts.getClangABICompat()) {
3681 GenerateArg(Consumer, OPT_fclang_abi_compat_EQ,
"3.8");
3684 GenerateArg(Consumer, OPT_fclang_abi_compat_EQ,
"4.0");
3687 GenerateArg(Consumer, OPT_fclang_abi_compat_EQ,
"6.0");
3690 GenerateArg(Consumer, OPT_fclang_abi_compat_EQ,
"7.0");
3693 GenerateArg(Consumer, OPT_fclang_abi_compat_EQ,
"9.0");
3696 GenerateArg(Consumer, OPT_fclang_abi_compat_EQ,
"11.0");
3699 GenerateArg(Consumer, OPT_fclang_abi_compat_EQ,
"12.0");
3702 GenerateArg(Consumer, OPT_fclang_abi_compat_EQ,
"14.0");
3705 GenerateArg(Consumer, OPT_fclang_abi_compat_EQ,
"15.0");
3708 GenerateArg(Consumer, OPT_fclang_abi_compat_EQ,
"17.0");
3711 GenerateArg(Consumer, OPT_fclang_abi_compat_EQ,
"18.0");
3717 if (Opts.getSignReturnAddressScope() ==
3719 GenerateArg(Consumer, OPT_msign_return_address_EQ,
"all");
3720 else if (Opts.getSignReturnAddressScope() ==
3722 GenerateArg(Consumer, OPT_msign_return_address_EQ,
"non-leaf");
3724 if (Opts.getSignReturnAddressKey() ==
3726 GenerateArg(Consumer, OPT_msign_return_address_key_EQ,
"b_key");
3732 if (Opts.RelativeCXXABIVTables)
3733 GenerateArg(Consumer, OPT_fexperimental_relative_cxx_abi_vtables);
3735 GenerateArg(Consumer, OPT_fno_experimental_relative_cxx_abi_vtables);
3743 GenerateArg(Consumer, OPT_fmacro_prefix_map_EQ, MP.first +
"=" + MP.second);
3749bool CompilerInvocation::ParseLangArgs(
LangOptions &Opts, ArgList &Args,
3751 std::vector<std::string> &Includes,
3761 if (Args.hasArg(OPT_fobjc_arc))
3762 Opts.ObjCAutoRefCount = 1;
3766 Opts.PIE = Args.hasArg(OPT_pic_is_pie);
3778 if (
const Arg *A = Args.getLastArg(OPT_std_EQ)) {
3781 Diags.
Report(diag::err_drv_invalid_value)
3782 << A->getAsString(Args) << A->getValue();
3784 for (
unsigned KindValue = 0;
3790 auto Diag = Diags.
Report(diag::note_drv_use_standard);
3791 Diag <<
Std.getName() <<
Std.getDescription();
3792 unsigned NumAliases = 0;
3793#define LANGSTANDARD(id, name, lang, desc, features)
3794#define LANGSTANDARD_ALIAS(id, alias) \
3795 if (KindValue == LangStandard::lang_##id) ++NumAliases;
3796#define LANGSTANDARD_ALIAS_DEPR(id, alias)
3797#include "clang/Basic/LangStandards.def"
3799#define LANGSTANDARD(id, name, lang, desc, features)
3800#define LANGSTANDARD_ALIAS(id, alias) \
3801 if (KindValue == LangStandard::lang_##id) Diag << alias;
3802#define LANGSTANDARD_ALIAS_DEPR(id, alias)
3803#include "clang/Basic/LangStandards.def"
3811 Diags.
Report(diag::err_drv_argument_not_allowed_with)
3819 if (
const Arg *A = Args.getLastArg(OPT_cl_std_EQ)) {
3821 = llvm::StringSwitch<LangStandard::Kind>(A->getValue())
3822 .Cases(
"cl",
"CL", LangStandard::lang_opencl10)
3823 .Cases(
"cl1.0",
"CL1.0", LangStandard::lang_opencl10)
3824 .Cases(
"cl1.1",
"CL1.1", LangStandard::lang_opencl11)
3825 .Cases(
"cl1.2",
"CL1.2", LangStandard::lang_opencl12)
3826 .Cases(
"cl2.0",
"CL2.0", LangStandard::lang_opencl20)
3827 .Cases(
"cl3.0",
"CL3.0", LangStandard::lang_opencl30)
3828 .Cases(
"clc++",
"CLC++", LangStandard::lang_openclcpp10)
3829 .Cases(
"clc++1.0",
"CLC++1.0", LangStandard::lang_openclcpp10)
3830 .Cases(
"clc++2021",
"CLC++2021", LangStandard::lang_openclcpp2021)
3834 Diags.
Report(diag::err_drv_invalid_value)
3835 << A->getAsString(Args) << A->getValue();
3838 LangStd = OpenCLLangStd;
3842 Opts.IncludeDefaultHeader = Args.hasArg(OPT_finclude_default_header);
3843 Opts.DeclareOpenCLBuiltins = Args.hasArg(OPT_fdeclare_opencl_builtins);
3851#define LANG_OPTION_WITH_MARSHALLING(...) \
3852 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
3853#include "clang/Driver/Options.inc"
3854#undef LANG_OPTION_WITH_MARSHALLING
3856 if (
const Arg *A = Args.getLastArg(OPT_fcf_protection_EQ)) {
3857 StringRef Name = A->getValue();
3858 if (Name ==
"full" || Name ==
"branch") {
3859 Opts.CFProtectionBranch = 1;
3863 if ((Args.hasArg(OPT_fsycl_is_device) || Args.hasArg(OPT_fsycl_is_host)) &&
3864 !Args.hasArg(OPT_sycl_std_EQ)) {
3874 if (Arg *arg = Args.getLastArg(OPT_fobjc_runtime_EQ)) {
3875 StringRef value =
arg->getValue();
3877 Diags.
Report(diag::err_drv_unknown_objc_runtime) << value;
3880 if (Args.hasArg(OPT_fobjc_gc_only))
3882 else if (Args.hasArg(OPT_fobjc_gc))
3884 else if (Args.hasArg(OPT_fobjc_arc)) {
3885 Opts.ObjCAutoRefCount = 1;
3887 Diags.
Report(diag::err_arc_unsupported_on_runtime);
3894 if (Args.hasArg(OPT_fobjc_runtime_has_weak))
3895 Opts.ObjCWeakRuntime = 1;
3901 if (
auto weakArg = Args.getLastArg(OPT_fobjc_weak, OPT_fno_objc_weak)) {
3902 if (!weakArg->getOption().matches(OPT_fobjc_weak)) {
3903 assert(!Opts.ObjCWeak);
3905 Diags.
Report(diag::err_objc_weak_with_gc);
3906 }
else if (!Opts.ObjCWeakRuntime) {
3907 Diags.
Report(diag::err_objc_weak_unsupported);
3911 }
else if (Opts.ObjCAutoRefCount) {
3912 Opts.ObjCWeak = Opts.ObjCWeakRuntime;
3915 if (Args.hasArg(OPT_fobjc_subscripting_legacy_runtime))
3916 Opts.ObjCSubscriptingLegacyRuntime =
3920 if (Arg *A = Args.getLastArg(options::OPT_fgnuc_version_EQ)) {
3923 VersionTuple GNUCVer;
3924 bool Invalid = GNUCVer.tryParse(A->getValue());
3925 unsigned Major = GNUCVer.getMajor();
3926 unsigned Minor = GNUCVer.getMinor().value_or(0);
3927 unsigned Patch = GNUCVer.getSubminor().value_or(0);
3928 if (
Invalid || GNUCVer.getBuild() || Minor >= 100 || Patch >= 100) {
3929 Diags.
Report(diag::err_drv_invalid_value)
3930 << A->getAsString(Args) << A->getValue();
3932 Opts.GNUCVersion = Major * 100 * 100 + Minor * 100 + Patch;
3935 if (
T.isOSAIX() && (Args.hasArg(OPT_mignore_xcoff_visibility)))
3936 Opts.IgnoreXCOFFVisibility = 1;
3938 if (Args.hasArg(OPT_ftrapv)) {
3942 std::string(Args.getLastArgValue(OPT_ftrapv_handler));
3944 else if (Args.hasArg(OPT_fwrapv))
3947 Opts.MSCompatibilityVersion = 0;
3948 if (
const Arg *A = Args.getLastArg(OPT_fms_compatibility_version)) {
3950 if (VT.tryParse(A->getValue()))
3951 Diags.
Report(diag::err_drv_invalid_value) << A->getAsString(Args)
3953 Opts.MSCompatibilityVersion = VT.getMajor() * 10000000 +
3954 VT.getMinor().value_or(0) * 100000 +
3955 VT.getSubminor().value_or(0);
3963 (!Opts.GNUMode && !Opts.MSVCCompat && !Opts.CPlusPlus17 && !Opts.C23) ||
3966 Args.hasFlag(OPT_ftrigraphs, OPT_fno_trigraphs, Opts.Trigraphs);
3968 Opts.Blocks = Args.hasArg(OPT_fblocks) || (Opts.OpenCL
3969 && Opts.OpenCLVersion == 200);
3971 Opts.ConvergentFunctions = Args.hasArg(OPT_fconvergent_functions) ||
3972 Opts.OpenCL || (Opts.CUDA && Opts.CUDAIsDevice) ||
3973 Opts.SYCLIsDevice || Opts.HLSL;
3975 Opts.NoBuiltin = Args.hasArg(OPT_fno_builtin) || Opts.Freestanding;
3976 if (!Opts.NoBuiltin)
3978 if (Arg *A = Args.getLastArg(options::OPT_LongDouble_Group)) {
3979 if (A->getOption().matches(options::OPT_mlong_double_64))
3980 Opts.LongDoubleSize = 64;
3981 else if (A->getOption().matches(options::OPT_mlong_double_80))
3982 Opts.LongDoubleSize = 80;
3983 else if (A->getOption().matches(options::OPT_mlong_double_128))
3984 Opts.LongDoubleSize = 128;
3986 Opts.LongDoubleSize = 0;
3988 if (Opts.FastRelaxedMath || Opts.CLUnsafeMath)
3994 if (Arg *A = Args.getLastArg(OPT_mrtd)) {
3996 Diags.
Report(diag::err_drv_argument_not_allowed_with)
3997 << A->getSpelling() <<
"-fdefault-calling-conv";
3999 switch (
T.getArch()) {
4000 case llvm::Triple::x86:
4003 case llvm::Triple::m68k:
4007 Diags.
Report(diag::err_drv_argument_not_allowed_with)
4008 << A->getSpelling() <<
T.getTriple();
4014 Opts.OpenMP = Args.hasArg(OPT_fopenmp) ? 51 : 0;
4016 bool IsSimdSpecified =
4017 Args.hasFlag(options::OPT_fopenmp_simd, options::OPT_fno_openmp_simd,
4019 Opts.OpenMPSimd = !Opts.OpenMP && IsSimdSpecified;
4021 Opts.OpenMP && !Args.hasArg(options::OPT_fnoopenmp_use_tls);
4022 Opts.OpenMPIsTargetDevice =
4023 Opts.OpenMP && Args.hasArg(options::OPT_fopenmp_is_target_device);
4024 Opts.OpenMPIRBuilder =
4025 Opts.OpenMP && Args.hasArg(options::OPT_fopenmp_enable_irbuilder);
4026 bool IsTargetSpecified =
4027 Opts.OpenMPIsTargetDevice || Args.hasArg(options::OPT_fopenmp_targets_EQ);
4029 Opts.ConvergentFunctions =
4030 Opts.ConvergentFunctions || Opts.OpenMPIsTargetDevice;
4032 if (Opts.OpenMP || Opts.OpenMPSimd) {
4034 Args, OPT_fopenmp_version_EQ,
4035 (IsSimdSpecified || IsTargetSpecified) ? 51 : Opts.OpenMP, Diags))
4036 Opts.OpenMP = Version;
4039 if (!Opts.OpenMPIsTargetDevice) {
4040 switch (
T.getArch()) {
4044 case llvm::Triple::nvptx:
4045 case llvm::Triple::nvptx64:
4046 Diags.
Report(diag::err_drv_omp_host_target_not_supported) <<
T.str();
4054 if ((Opts.OpenMPIsTargetDevice && (
T.isNVPTX() ||
T.isAMDGCN())) ||
4055 Opts.OpenCLCPlusPlus) {
4057 Opts.Exceptions = 0;
4058 Opts.CXXExceptions = 0;
4060 if (Opts.OpenMPIsTargetDevice &&
T.isNVPTX()) {
4061 Opts.OpenMPCUDANumSMs =
4063 Opts.OpenMPCUDANumSMs, Diags);
4064 Opts.OpenMPCUDABlocksPerSM =
4066 Opts.OpenMPCUDABlocksPerSM, Diags);
4068 Args, options::OPT_fopenmp_cuda_teams_reduction_recs_num_EQ,
4069 Opts.OpenMPCUDAReductionBufNum, Diags);
4074 if (Opts.OpenMPIsTargetDevice && (Args.hasArg(OPT_fopenmp_target_debug) ||
4075 Args.hasArg(OPT_fopenmp_target_debug_EQ))) {
4077 Args, OPT_fopenmp_target_debug_EQ, Opts.OpenMPTargetDebug, Diags);
4078 if (!Opts.OpenMPTargetDebug && Args.hasArg(OPT_fopenmp_target_debug))
4079 Opts.OpenMPTargetDebug = 1;
4082 if (Opts.OpenMPIsTargetDevice) {
4083 if (Args.hasArg(OPT_fopenmp_assume_teams_oversubscription))
4084 Opts.OpenMPTeamSubscription =
true;
4085 if (Args.hasArg(OPT_fopenmp_assume_threads_oversubscription))
4086 Opts.OpenMPThreadSubscription =
true;
4090 if (Arg *A = Args.getLastArg(options::OPT_fopenmp_targets_EQ)) {
4091 enum ArchPtrSize { Arch16Bit, Arch32Bit, Arch64Bit };
4092 auto getArchPtrSize = [](
const llvm::Triple &
T) {
4093 if (
T.isArch16Bit())
4095 if (
T.isArch32Bit())
4097 assert(
T.isArch64Bit() &&
"Expected 64-bit architecture");
4101 for (
unsigned i = 0; i < A->getNumValues(); ++i) {
4102 llvm::Triple TT(A->getValue(i));
4104 if (TT.getArch() == llvm::Triple::UnknownArch ||
4105 !(TT.getArch() == llvm::Triple::aarch64 || TT.isPPC() ||
4106 TT.getArch() == llvm::Triple::systemz ||
4107 TT.getArch() == llvm::Triple::nvptx ||
4108 TT.getArch() == llvm::Triple::nvptx64 ||
4109 TT.getArch() == llvm::Triple::amdgcn ||
4110 TT.getArch() == llvm::Triple::x86 ||
4111 TT.getArch() == llvm::Triple::x86_64))
4112 Diags.
Report(diag::err_drv_invalid_omp_target) << A->getValue(i);
4113 else if (getArchPtrSize(
T) != getArchPtrSize(TT))
4114 Diags.
Report(diag::err_drv_incompatible_omp_arch)
4115 << A->getValue(i) <<
T.str();
4123 if (Arg *A = Args.getLastArg(options::OPT_fopenmp_host_ir_file_path)) {
4126 Diags.
Report(diag::err_drv_omp_host_ir_file_not_found)
4131 Opts.OpenMPCUDAMode = Opts.OpenMPIsTargetDevice &&
4132 (
T.isNVPTX() ||
T.isAMDGCN()) &&
4133 Args.hasArg(options::OPT_fopenmp_cuda_mode);
4136 if (Args.hasArg(options::OPT_fopenacc)) {
4137 Opts.OpenACC =
true;
4139 if (Arg *A = Args.getLastArg(options::OPT_openacc_macro_override))
4146 Opts.Optimize = Opt != 0;
4147 Opts.OptimizeSize = OptSize != 0;
4152 Opts.NoInlineDefine = !Opts.Optimize;
4153 if (Arg *InlineArg = Args.getLastArg(
4154 options::OPT_finline_functions, options::OPT_finline_hint_functions,
4155 options::OPT_fno_inline_functions, options::OPT_fno_inline))
4156 if (InlineArg->getOption().matches(options::OPT_fno_inline))
4157 Opts.NoInlineDefine =
true;
4159 if (Arg *A = Args.getLastArg(OPT_ffp_contract)) {
4160 StringRef Val = A->getValue();
4163 else if (Val ==
"on")
4165 else if (Val ==
"off")
4167 else if (Val ==
"fast-honor-pragmas")
4170 Diags.
Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Val;
4176 Opts.
NoSanitizeFiles = Args.getAllArgValues(OPT_fsanitize_ignorelist_EQ);
4177 std::vector<std::string> systemIgnorelists =
4178 Args.getAllArgValues(OPT_fsanitize_system_ignorelist_EQ);
4180 systemIgnorelists.begin(),
4181 systemIgnorelists.end());
4183 if (Arg *A = Args.getLastArg(OPT_fclang_abi_compat_EQ)) {
4186 StringRef Ver = A->getValue();
4187 std::pair<StringRef, StringRef> VerParts = Ver.split(
'.');
4188 unsigned Major, Minor = 0;
4192 if (!VerParts.first.starts_with(
"0") &&
4193 !VerParts.first.getAsInteger(10, Major) && 3 <= Major &&
4194 Major <= CLANG_VERSION_MAJOR &&
4196 ? VerParts.second.size() == 1 &&
4197 !VerParts.second.getAsInteger(10, Minor)
4198 : VerParts.first.size() == Ver.size() || VerParts.second ==
"0")) {
4200 if (Major == 3 && Minor <= 8)
4202 else if (Major <= 4)
4204 else if (Major <= 6)
4206 else if (Major <= 7)
4208 else if (Major <= 9)
4210 else if (Major <= 11)
4212 else if (Major <= 12)
4214 else if (Major <= 14)
4216 else if (Major <= 15)
4218 else if (Major <= 17)
4220 else if (Major <= 18)
4222 }
else if (Ver !=
"latest") {
4223 Diags.
Report(diag::err_drv_invalid_value)
4224 << A->getAsString(Args) << A->getValue();
4228 if (Arg *A = Args.getLastArg(OPT_msign_return_address_EQ)) {
4229 StringRef SignScope = A->getValue();
4231 if (SignScope.equals_insensitive(
"none"))
4232 Opts.setSignReturnAddressScope(
4234 else if (SignScope.equals_insensitive(
"all"))
4235 Opts.setSignReturnAddressScope(
4237 else if (SignScope.equals_insensitive(
"non-leaf"))
4238 Opts.setSignReturnAddressScope(
4241 Diags.
Report(diag::err_drv_invalid_value)
4242 << A->getAsString(Args) << SignScope;
4244 if (Arg *A = Args.getLastArg(OPT_msign_return_address_key_EQ)) {
4245 StringRef SignKey = A->getValue();
4246 if (!SignScope.empty() && !SignKey.empty()) {
4247 if (SignKey ==
"a_key")
4248 Opts.setSignReturnAddressKey(
4250 else if (SignKey ==
"b_key")
4251 Opts.setSignReturnAddressKey(
4254 Diags.
Report(diag::err_drv_invalid_value)
4255 << A->getAsString(Args) << SignKey;
4261 StringRef
CXXABI = Args.getLastArgValue(OPT_fcxx_abi_EQ);
4268 Diags.
Report(diag::err_unsupported_cxx_abi) <<
CXXABI <<
T.str();
4274 Opts.RelativeCXXABIVTables =
4275 Args.hasFlag(options::OPT_fexperimental_relative_cxx_abi_vtables,
4276 options::OPT_fno_experimental_relative_cxx_abi_vtables,
4280 bool HasRTTI = !Args.hasArg(options::OPT_fno_rtti);
4281 Opts.OmitVTableRTTI =
4282 Args.hasFlag(options::OPT_fexperimental_omit_vtable_rtti,
4283 options::OPT_fno_experimental_omit_vtable_rtti,
false);
4284 if (Opts.OmitVTableRTTI && HasRTTI)
4285 Diags.
Report(diag::err_drv_using_omit_rtti_component_without_no_rtti);
4287 for (
const auto &A : Args.getAllArgValues(OPT_fmacro_prefix_map_EQ)) {
4288 auto Split = StringRef(A).split(
'=');
4290 {std::string(
Split.first), std::string(
Split.second)});
4294 !Args.getLastArg(OPT_fno_file_reproducible) &&
4295 (Args.getLastArg(OPT_ffile_compilation_dir_EQ) ||
4296 Args.getLastArg(OPT_fmacro_prefix_map_EQ) ||
4297 Args.getLastArg(OPT_ffile_reproducible));
4300 if (Arg *A = Args.getLastArg(options::OPT_mvscale_min_EQ)) {
4302 if (StringRef(A->getValue()).getAsInteger(10, VScaleMin) || VScaleMin == 0)
4303 Diags.
Report(diag::err_cc1_unbounded_vscale_min);
4306 if (
const Arg *A = Args.getLastArg(OPT_frandomize_layout_seed_file_EQ)) {
4307 std::ifstream SeedFile(A->getValue(0));
4309 if (!SeedFile.is_open())
4310 Diags.
Report(diag::err_drv_cannot_open_randomize_layout_seed_file)
4316 if (
const Arg *A = Args.getLastArg(OPT_frandomize_layout_seed_EQ))
4323 if (
T.isDXIL() ||
T.isSPIRVLogical()) {
4325 enum { OS, Environment };
4327 int ExpectedOS =
T.isSPIRVLogical() ? VulkanEnv : ShaderModel;
4329 if (
T.getOSName().empty()) {
4330 Diags.
Report(diag::err_drv_hlsl_bad_shader_required_in_target)
4331 << ExpectedOS << OS <<
T.str();
4332 }
else if (
T.getEnvironmentName().empty()) {
4333 Diags.
Report(diag::err_drv_hlsl_bad_shader_required_in_target)
4335 }
else if (!
T.isShaderStageEnvironment()) {
4336 Diags.
Report(diag::err_drv_hlsl_bad_shader_unsupported)
4341 if (!
T.isShaderModelOS() ||
T.getOSVersion() == VersionTuple(0)) {
4342 Diags.
Report(diag::err_drv_hlsl_bad_shader_unsupported)
4343 << ShaderModel <<
T.getOSName() <<
T.str();
4348 if (Args.getLastArg(OPT_fnative_half_type)) {
4351 if (!(Opts.
LangStd >= LangStandard::lang_hlsl2018 &&
4352 T.getOSVersion() >= VersionTuple(6, 2)))
4353 Diags.
Report(diag::err_drv_hlsl_16bit_types_unsupported)
4354 <<
"-enable-16bit-types" <<
true <<
Std.getName()
4355 <<
T.getOSVersion().getAsString();
4357 }
else if (
T.isSPIRVLogical()) {
4358 if (!
T.isVulkanOS() ||
T.getVulkanVersion() == VersionTuple(0)) {
4359 Diags.
Report(diag::err_drv_hlsl_bad_shader_unsupported)
4360 << VulkanEnv <<
T.getOSName() <<
T.str();
4362 if (Args.getLastArg(OPT_fnative_half_type)) {
4365 if (!(Opts.
LangStd >= LangStandard::lang_hlsl2018))
4366 Diags.
Report(diag::err_drv_hlsl_16bit_types_unsupported)
4367 <<
"-fnative-half-type" <<
false <<
Std.getName();
4370 llvm_unreachable(
"expected DXIL or SPIR-V target");
4373 Diags.
Report(diag::err_drv_hlsl_unsupported_target) <<
T.str();
4423 llvm_unreachable(
"invalid frontend action");
4433#define PREPROCESSOR_OPTION_WITH_MARSHALLING(...) \
4434 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
4435#include "clang/Driver/Options.inc"
4436#undef PREPROCESSOR_OPTION_WITH_MARSHALLING
4439 GenerateArg(Consumer, OPT_pch_through_hdrstop_use);
4442 GenerateArg(Consumer, OPT_error_on_deserialized_pch_decl, D);
4449 for (
const auto &M : Opts.
Macros) {
4452 if (M.first ==
"__CET__=1" && !M.second &&
4453 !CodeGenOpts.CFProtectionReturn && CodeGenOpts.CFProtectionBranch)
4455 if (M.first ==
"__CET__=2" && !M.second && CodeGenOpts.CFProtectionReturn &&
4456 !CodeGenOpts.CFProtectionBranch)
4458 if (M.first ==
"__CET__=3" && !M.second && CodeGenOpts.CFProtectionReturn &&
4459 CodeGenOpts.CFProtectionBranch)
4462 GenerateArg(Consumer, M.second ? OPT_U : OPT_D, M.first);
4465 for (
const auto &I : Opts.
Includes) {
4468 if (LangOpts.OpenCL && LangOpts.IncludeDefaultHeader &&
4469 ((LangOpts.DeclareOpenCLBuiltins && I ==
"opencl-c-base.h") ||
4474 if (LangOpts.HLSL && I ==
"hlsl.h")
4484 GenerateArg(Consumer, OPT_remap_file, RF.first +
";" + RF.second);
4490 GenerateArg(Consumer, OPT_fdefine_target_os_macros);
4504#define PREPROCESSOR_OPTION_WITH_MARSHALLING(...) \
4505 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
4506#include "clang/Driver/Options.inc"
4507#undef PREPROCESSOR_OPTION_WITH_MARSHALLING
4509 Opts.
PCHWithHdrStop = Args.hasArg(OPT_pch_through_hdrstop_create) ||
4510 Args.hasArg(OPT_pch_through_hdrstop_use);
4512 for (
const auto *A : Args.filtered(OPT_error_on_deserialized_pch_decl))
4515 if (
const Arg *A = Args.getLastArg(OPT_preamble_bytes_EQ)) {
4516 StringRef
Value(A->getValue());
4517 size_t Comma =
Value.find(
',');
4519 unsigned EndOfLine = 0;
4521 if (Comma == StringRef::npos ||
4522 Value.substr(0, Comma).getAsInteger(10, Bytes) ||
4523 Value.substr(Comma + 1).getAsInteger(10, EndOfLine))
4524 Diags.
Report(diag::err_drv_preamble_format);
4532 if (
const Arg *A = Args.getLastArg(OPT_fcf_protection_EQ)) {
4533 StringRef Name = A->getValue();
4534 if (Name ==
"branch")
4536 else if (Name ==
"return")
4538 else if (Name ==
"full")
4543 for (
const auto *A : Args.filtered(OPT_D, OPT_U)) {
4544 if (A->getOption().matches(OPT_D))
4551 for (
const auto *A : Args.filtered(OPT_include))
4552 Opts.
Includes.emplace_back(A->getValue());
4554 for (
const auto *A : Args.filtered(OPT_chain_include))
4557 for (
const auto *A : Args.filtered(OPT_remap_file)) {
4558 std::pair<StringRef, StringRef> Split = StringRef(A->getValue()).split(
';');
4560 if (Split.second.empty()) {
4561 Diags.
Report(diag::err_drv_invalid_remap_file) << A->getAsString(Args);
4568 if (
const Arg *A = Args.getLastArg(OPT_source_date_epoch)) {
4569 StringRef Epoch = A->getValue();
4573 const uint64_t MaxTimestamp =
4574 std::min<uint64_t>(std::numeric_limits<time_t>::max(), 253402300799);
4576 if (Epoch.getAsInteger(10,
V) ||
V > MaxTimestamp) {
4577 Diags.
Report(diag::err_fe_invalid_source_date_epoch)
4578 << Epoch << MaxTimestamp;
4591 Args.hasFlag(OPT_fdefine_target_os_macros,
4603#define PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING(...) \
4604 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
4605#include "clang/Driver/Options.inc"
4606#undef PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING
4624#define PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING(...) \
4625 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
4626#include "clang/Driver/Options.inc"
4627#undef PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING
4630 Opts.
ShowMacros = Args.hasArg(OPT_dM) || Args.hasArg(OPT_dD);
4639#define TARGET_OPTION_WITH_MARSHALLING(...) \
4640 GENERATE_OPTION_WITH_MARSHALLING(Consumer, __VA_ARGS__)
4641#include "clang/Driver/Options.inc"
4642#undef TARGET_OPTION_WITH_MARSHALLING
4648 GenerateArg(Consumer, OPT_darwin_target_variant_sdk_version_EQ,
4658#define TARGET_OPTION_WITH_MARSHALLING(...) \
4659 PARSE_OPTION_WITH_MARSHALLING(Args, Diags, __VA_ARGS__)
4660#include "clang/Driver/Options.inc"
4661#undef TARGET_OPTION_WITH_MARSHALLING
4663 if (Arg *A = Args.getLastArg(options::OPT_target_sdk_version_EQ)) {
4664 llvm::VersionTuple Version;
4665 if (Version.tryParse(A->getValue()))
4666 Diags.
Report(diag::err_drv_invalid_value)
4667 << A->getAsString(Args) << A->getValue();
4672 Args.getLastArg(options::OPT_darwin_target_variant_sdk_version_EQ)) {
4673 llvm::VersionTuple Version;
4674 if (Version.tryParse(A->getValue()))
4675 Diags.
Report(diag::err_drv_invalid_value)
4676 << A->getAsString(Args) << A->getValue();
4684bool CompilerInvocation::CreateFromArgsImpl(
4692 unsigned MissingArgIndex, MissingArgCount;
4693 InputArgList Args = Opts.ParseArgs(CommandLineArgs, MissingArgIndex,
4694 MissingArgCount, VisibilityMask);
4698 if (MissingArgCount)
4699 Diags.
Report(diag::err_drv_missing_argument)
4700 << Args.getArgString(MissingArgIndex) << MissingArgCount;
4703 for (
const auto *A : Args.filtered(OPT_UNKNOWN)) {
4704 auto ArgString = A->getAsString(Args);
4705 std::string Nearest;
4706 if (Opts.findNearest(ArgString, Nearest, VisibilityMask) > 1)
4707 Diags.
Report(diag::err_drv_unknown_argument) << ArgString;
4709 Diags.
Report(diag::err_drv_unknown_argument_with_suggestion)
4710 << ArgString << Nearest;
4759 !
LangOpts.Sanitize.has(SanitizerKind::Address) &&
4760 !
LangOpts.Sanitize.has(SanitizerKind::KernelAddress) &&
4761 !
LangOpts.Sanitize.has(SanitizerKind::Memory) &&
4762 !
LangOpts.Sanitize.has(SanitizerKind::KernelMemory);
4775 Diags.
Report(diag::err_fe_dependency_file_requires_MT);
4781 Diags.
Report(diag::warn_drv_fine_grained_bitfield_accesses_ignored);
4795 Diags, llvm::vfs::getRealFileSystem());
4809 const char *Argv0) {
4815 return CreateFromArgsImpl(Invocation, CommandLineArgs, Diags, Argv0);
4819 Args.push_back(
"-cc1");
4822 Invocation, DummyInvocation, CommandLineArgs, Diags, Argv0);
4827 llvm::HashBuilder<llvm::MD5, llvm::endianness::native> HBuilder;
4840#define LANGOPT(Name, Bits, Default, Description) HBuilder.add(LangOpts->Name);
4841#define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
4842 HBuilder.add(static_cast<unsigned>(LangOpts->get##Name()));
4843#define BENIGN_LANGOPT(Name, Bits, Default, Description)
4844#define BENIGN_ENUM_LANGOPT(Name, Type, Bits, Default, Description)
4845#include "clang/Basic/LangOptions.def"
4850 HBuilder.addRange(
getLangOpts().CommentOpts.BlockCommandNames);
4867 StringRef MacroDef = Macro.first;
4869 llvm::CachedHashString(MacroDef.split(
'=').first)))
4873 HBuilder.add(Macro);
4889#define DIAGOPT(Name, Bits, Default) HBuilder.add(diagOpts.Name);
4890#define ENUM_DIAGOPT(Name, Type, Bits, Default) \
4891 HBuilder.add(diagOpts.get##Name());
4892#include "clang/Basic/DiagnosticOptions.def"
4902 ext->hashExtension(HBuilder);
4909 HBuilder.add(*Minor);
4910 if (
auto Subminor =
APINotesOpts.SwiftVersion.getSubminor())
4911 HBuilder.add(*Subminor);
4913 HBuilder.add(*Build);
4923#define DEBUGOPT(Name, Bits, Default) HBuilder.add(CodeGenOpts->Name);
4924#define VALUE_DEBUGOPT(Name, Bits, Default) HBuilder.add(CodeGenOpts->Name);
4925#define ENUM_DEBUGOPT(Name, Type, Bits, Default) \
4926 HBuilder.add(static_cast<unsigned>(CodeGenOpts->get##Name()));
4927#define BENIGN_DEBUGOPT(Name, Bits, Default)
4928#define BENIGN_VALUE_DEBUGOPT(Name, Bits, Default)
4929#define BENIGN_ENUM_DEBUGOPT(Name, Type, Bits, Default)
4930#include "clang/Basic/DebugOptions.def"
4937 if (!SanHash.
empty())
4938 HBuilder.add(SanHash.
Mask);
4940 llvm::MD5::MD5Result
Result;
4941 HBuilder.getHasher().final(
Result);
4943 return toString(llvm::APInt(64, Hash), 36,
false);
4971 std::vector<std::string> Args{
"-cc1"};
4973 [&Args](
const Twine &Arg) { Args.push_back(Arg.str()); });
4999 llvm::vfs::getRealFileSystem());
5007 Diags, std::move(BaseFS));
5013 if (VFSOverlayFiles.empty())
5018 for (
const auto &
File : VFSOverlayFiles) {
5019 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> Buffer =
5022 Diags.
Report(diag::err_missing_vfs_overlay_file) <<
File;
5027 std::move(Buffer.get()),
nullptr,
File,
5030 Diags.
Report(diag::err_invalid_vfs_overlay) <<
File;
Defines the Diagnostic-related interfaces.
Defines enum values for all the target-independent builtin functions.
static void getAllNoBuiltinFuncValues(ArgList &Args, std::vector< std::string > &Funcs)
static T extractMaskValue(T KeyPath)
static std::optional< IntTy > normalizeStringIntegral(OptSpecifier Opt, int, const ArgList &Args, DiagnosticsEngine &Diags)
static T mergeMaskValue(T KeyPath, U Value)
static std::optional< std::string > normalizeString(OptSpecifier Opt, int TableIndex, const ArgList &Args, DiagnosticsEngine &Diags)
static auto makeBooleanOptionNormalizer(bool Value, bool OtherValue, OptSpecifier OtherOpt)
static SmallVector< StringRef, 4 > serializeSanitizerKinds(SanitizerSet S)
static void parseXRayInstrumentationBundle(StringRef FlagName, StringRef Bundle, ArgList &Args, DiagnosticsEngine &D, XRayInstrSet &S)
static unsigned getOptimizationLevelSize(ArgList &Args)
static void GenerateFrontendArgs(const FrontendOptions &Opts, ArgumentConsumer Consumer, bool IsHeader)
static std::optional< SimpleEnumValue > findValueTableByValue(const SimpleEnumValueTable &Table, unsigned Value)
static bool ParseTargetArgs(TargetOptions &Opts, ArgList &Args, DiagnosticsEngine &Diags)
static auto makeFlagToValueNormalizer(T Value)
static void denormalizeStringVector(ArgumentConsumer Consumer, const Twine &Spelling, Option::OptionClass OptClass, unsigned TableIndex, const std::vector< std::string > &Values)
static CodeGenOptions::OptRemark ParseOptimizationRemark(DiagnosticsEngine &Diags, ArgList &Args, OptSpecifier OptEQ, StringRef Name)
Parse a remark command line argument.
static bool ParseFileSystemArgs(FileSystemOptions &Opts, const ArgList &Args, DiagnosticsEngine &Diags)
static constexpr bool is_uint64_t_convertible()
static void GeneratePointerAuthArgs(const LangOptions &Opts, ArgumentConsumer Consumer)
static std::optional< SimpleEnumValue > findValueTableByName(const SimpleEnumValueTable &Table, StringRef Name)
static std::optional< OptSpecifier > getProgramActionOpt(frontend::ActionKind ProgramAction)
Maps frontend action to command line option.
static bool parseDiagnosticLevelMask(StringRef FlagName, const std::vector< std::string > &Levels, DiagnosticsEngine &Diags, DiagnosticLevelMask &M)
static std::optional< bool > normalizeSimpleFlag(OptSpecifier Opt, unsigned TableIndex, const ArgList &Args, DiagnosticsEngine &Diags)
CompilerInvocation::ArgumentConsumer ArgumentConsumer
static void GenerateArg(ArgumentConsumer Consumer, llvm::opt::OptSpecifier OptSpecifier)
static void addDiagnosticArgs(ArgList &Args, OptSpecifier Group, OptSpecifier GroupWithValue, std::vector< std::string > &Diagnostics)
static bool ParseAnalyzerArgs(AnalyzerOptions &Opts, ArgList &Args, DiagnosticsEngine &Diags)
static void ParsePointerAuthArgs(LangOptions &Opts, ArgList &Args, DiagnosticsEngine &Diags)
static void parseAnalyzerConfigs(AnalyzerOptions &AnOpts, DiagnosticsEngine *Diags)
static void denormalizeSimpleEnum(ArgumentConsumer Consumer, const Twine &Spelling, Option::OptionClass OptClass, unsigned TableIndex, T Value)
static bool ParsePreprocessorArgs(PreprocessorOptions &Opts, ArgList &Args, DiagnosticsEngine &Diags, frontend::ActionKind Action, const FrontendOptions &FrontendOpts)
static std::optional< unsigned > normalizeSimpleEnum(OptSpecifier Opt, unsigned TableIndex, const ArgList &Args, DiagnosticsEngine &Diags)
static StringRef GetInputKindName(InputKind IK)
Get language name for given input kind.
static void initOption(AnalyzerOptions::ConfigTable &Config, DiagnosticsEngine *Diags, StringRef &OptionField, StringRef Name, StringRef DefaultVal)
static void denormalizeString(ArgumentConsumer Consumer, const Twine &Spelling, Option::OptionClass OptClass, unsigned TableIndex, T Value)
static std::optional< std::string > normalizeTriple(OptSpecifier Opt, int TableIndex, const ArgList &Args, DiagnosticsEngine &Diags)
llvm::function_ref< bool(CompilerInvocation &, ArrayRef< const char * >, DiagnosticsEngine &, const char *)> ParseFn
llvm::function_ref< void(CompilerInvocation &, SmallVectorImpl< const char * > &, CompilerInvocation::StringAllocator)> GenerateFn
static void GenerateMigratorArgs(const MigratorOptions &Opts, ArgumentConsumer Consumer)
static const auto & getFrontendActionTable()
Return a table that associates command line option specifiers with the frontend action.
static void GenerateTargetArgs(const TargetOptions &Opts, ArgumentConsumer Consumer)
static std::optional< frontend::ActionKind > getFrontendAction(OptSpecifier &Opt)
Maps command line option to frontend action.
static bool checkVerifyPrefixes(const std::vector< std::string > &VerifyPrefixes, DiagnosticsEngine &Diags)
static void denormalizeSimpleFlag(ArgumentConsumer Consumer, const Twine &Spelling, Option::OptionClass, unsigned,...)
The tblgen-erated code passes in a fifth parameter of an arbitrary type, but denormalizeSimpleFlags n...
static void GenerateAPINotesArgs(const APINotesOptions &Opts, ArgumentConsumer Consumer)
static std::optional< bool > normalizeSimpleNegativeFlag(OptSpecifier Opt, unsigned, const ArgList &Args, DiagnosticsEngine &)
static void GenerateFileSystemArgs(const FileSystemOptions &Opts, ArgumentConsumer Consumer)
static bool IsInputCompatibleWithStandard(InputKind IK, const LangStandard &S)
Check if input file kind and language standard are compatible.
static void denormalizeStringImpl(ArgumentConsumer Consumer, const Twine &Spelling, Option::OptionClass OptClass, unsigned, const Twine &Value)
static void setPGOUseInstrumentor(CodeGenOptions &Opts, const Twine &ProfileName, llvm::vfs::FileSystem &FS, DiagnosticsEngine &Diags)
static void denormalizeSimpleEnumImpl(ArgumentConsumer Consumer, const Twine &Spelling, Option::OptionClass OptClass, unsigned TableIndex, unsigned Value)
static void GeneratePreprocessorArgs(const PreprocessorOptions &Opts, ArgumentConsumer Consumer, const LangOptions &LangOpts, const FrontendOptions &FrontendOpts, const CodeGenOptions &CodeGenOpts)
static bool ParseHeaderSearchArgs(HeaderSearchOptions &Opts, ArgList &Args, DiagnosticsEngine &Diags, const std::string &WorkingDir)
static bool ParseFrontendArgs(FrontendOptions &Opts, ArgList &Args, DiagnosticsEngine &Diags, bool &IsHeaderFile)
static auto makeBooleanOptionDenormalizer(bool Value)
static void GeneratePreprocessorOutputArgs(const PreprocessorOutputOptions &Opts, ArgumentConsumer Consumer, frontend::ActionKind Action)
static bool isStrictlyPreprocessorAction(frontend::ActionKind Action)
static std::string serializeXRayInstrumentationBundle(const XRayInstrSet &S)
static bool ParseMigratorArgs(MigratorOptions &Opts, const ArgList &Args, DiagnosticsEngine &Diags)
static bool parseShowColorsArgs(const ArgList &Args, bool DefaultColor)
static T mergeForwardValue(T KeyPath, U Value)
static void ParseAPINotesArgs(APINotesOptions &Opts, ArgList &Args, DiagnosticsEngine &diags)
static bool ParseDependencyOutputArgs(DependencyOutputOptions &Opts, ArgList &Args, DiagnosticsEngine &Diags, frontend::ActionKind Action, bool ShowLineMarkers)
static Expected< std::optional< uint32_t > > parseToleranceOption(StringRef Arg)
static std::optional< std::vector< std::string > > normalizeStringVector(OptSpecifier Opt, int, const ArgList &Args, DiagnosticsEngine &)
static void GenerateAnalyzerArgs(const AnalyzerOptions &Opts, ArgumentConsumer Consumer)
static void GenerateOptimizationRemark(ArgumentConsumer Consumer, OptSpecifier OptEQ, StringRef Name, const CodeGenOptions::OptRemark &Remark)
Generate a remark argument. This is an inverse of ParseOptimizationRemark.
static bool ParsePreprocessorOutputArgs(PreprocessorOutputOptions &Opts, ArgList &Args, DiagnosticsEngine &Diags, frontend::ActionKind Action)
static bool RoundTrip(ParseFn Parse, GenerateFn Generate, CompilerInvocation &RealInvocation, CompilerInvocation &DummyInvocation, ArrayRef< const char * > CommandLineArgs, DiagnosticsEngine &Diags, const char *Argv0, bool CheckAgainstOriginalInvocation=false, bool ForceRoundTrip=false)
May perform round-trip of command line arguments.
static T extractForwardValue(T KeyPath)
static unsigned getOptimizationLevel(ArgList &Args, InputKind IK, DiagnosticsEngine &Diags)
static bool parseTestModuleFileExtensionArg(StringRef Arg, std::string &BlockName, unsigned &MajorVersion, unsigned &MinorVersion, bool &Hashed, std::string &UserInfo)
Parse the argument to the -ftest-module-file-extension command-line argument.
static void GenerateDependencyOutputArgs(const DependencyOutputOptions &Opts, ArgumentConsumer Consumer)
static StringRef getStringOption(AnalyzerOptions::ConfigTable &Config, StringRef OptionName, StringRef DefaultVal)
static bool FixupInvocation(CompilerInvocation &Invocation, DiagnosticsEngine &Diags, const ArgList &Args, InputKind IK)
static void parseSanitizerKinds(StringRef FlagName, const std::vector< std::string > &Sanitizers, DiagnosticsEngine &Diags, SanitizerSet &S)
static void GenerateHeaderSearchArgs(const HeaderSearchOptions &Opts, ArgumentConsumer Consumer)
Defines the clang::FileSystemOptions interface.
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified.
Defines the clang::LangOptions interface.
static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)
Produce a diagnostic highlighting some portion of a literal.
Defines types useful for describing an Objective-C runtime.
static std::string toString(const clang::SanitizerSet &Sanitizers)
Produce a string containing comma-separated names of sanitizers in Sanitizers set.
Defines the clang::SanitizerKind enum.
Defines the clang::SourceLocation class and associated facilities.
Defines the clang::TargetOptions class.
Defines version macros and version-related utility functions for Clang.
Defines the clang::Visibility enumeration and various utility functions.
Defines the clang::XRayInstrKind enum.
__DEVICE__ void * memcpy(void *__a, const void *__b, size_t __c)
Tracks various options which control how API notes are found and handled.
llvm::VersionTuple SwiftVersion
The Swift version which should be used for API notes.
std::vector< std::string > ModuleSearchPaths
The set of search paths where we API notes can be found for particular modules.
Stores options for the analyzer from the command line.
static std::vector< StringRef > getRegisteredPackages(bool IncludeExperimental=false)
Retrieves the list of packages generated from Checkers.td.
std::vector< std::pair< std::string, bool > > CheckersAndPackages
Pairs of checker/package name and enable/disable.
std::vector< std::string > SilencedCheckersAndPackages
Vector of checker/package names which will not emit warnings.
AnalysisDiagClients AnalysisDiagOpt
AnalysisConstraints AnalysisConstraintsOpt
ConfigTable Config
A key-value table of use-specified configuration values.
unsigned ShouldEmitErrorsOnInvalidConfigValue
AnalysisPurgeMode AnalysisPurgeOpt
bool isUnknownAnalyzerConfig(llvm::StringRef Name)
static std::vector< StringRef > getRegisteredCheckers(bool IncludeExperimental=false)
Retrieves the list of checkers generated from Checkers.td.
llvm::StringMap< std::string > ConfigTable
std::string FullCompilerInvocation
Store full compiler invocation for reproducible instructions in the generated report.
AnalysisInliningMode InliningMode
The mode of function selection used during inlining.
static bool isBuiltinFunc(llvm::StringRef Name)
Returns true if this is a libc/libm function without the '__builtin_' prefix.
Implements C++ ABI-specific semantic analysis functions.
CodeGenOptions - Track various options which control how the code is optimized and passed to the back...
llvm::SmallVector< std::pair< std::string, std::string >, 0 > CoveragePrefixMap
Prefix replacement map for source-based code coverage to remap source file paths in coverage mapping.
llvm::SmallVector< std::pair< std::string, std::string >, 0 > DebugPrefixMap
std::string OptRecordFile
The name of the file to which the backend should save YAML optimization records.
std::string BinutilsVersion
std::vector< BitcodeFileToLink > LinkBitcodeFiles
The files specified here are linked in to the module before optimizations.
std::optional< uint64_t > DiagnosticsHotnessThreshold
The minimum hotness value a diagnostic needs in order to be included in optimization diagnostics.
char CoverageVersion[4]
The version string to put into coverage files.
llvm::DenormalMode FPDenormalMode
The floating-point denormal mode to use.
std::string CoverageNotesFile
The filename with path we use for coverage notes files.
std::string ProfileInstrumentUsePath
Name of the profile file to use as input for -fprofile-instr-use.
std::string SampleProfileFile
Name of the profile file to use with -fprofile-sample-use.
uint64_t LargeDataThreshold
The code model-specific large data threshold to use (-mlarge-data-threshold).
std::string MemoryProfileOutput
Name of the profile file to use as output for with -fmemory-profile.
std::string CodeModel
The code model to use (-mcmodel).
std::string CoverageDataFile
The filename with path we use for coverage data files.
std::optional< uint32_t > DiagnosticsMisExpectTolerance
The maximum percentage profiling weights can deviate from the expected values in order to be included...
std::string StackUsageOutput
Name of the stack usage file (i.e., .su file) if user passes -fstack-usage.
std::string OptRecordPasses
The regex that filters the passes that should be saved to the optimization records.
std::string SaveTempsFilePrefix
Prefix to use for -save-temps output.
XRayInstrSet XRayInstrumentationBundle
Set of XRay instrumentation kinds to emit.
bool hasSanitizeCoverage() const
llvm::DenormalMode FP32DenormalMode
The floating-point denormal mode to use, for float.
SanitizerSet SanitizeTrap
Set of sanitizer checks that trap rather than diagnose.
SanitizerSet SanitizeRecover
Set of sanitizer checks that are non-fatal (i.e.
bool hasReducedDebugInfo() const
Check if type and variable info should be emitted.
OptRemark OptimizationRemark
Selected optimizations for which we should enable optimization remarks.
std::string ThinLTOIndexFile
Name of the function summary index file to use for ThinLTO function importing.
const char * Argv0
Executable and command-line used to create a given CompilerInvocation.
std::vector< std::string > NoBuiltinFuncs
A list of all -fno-builtin-* function names (e.g., memset).
std::vector< uint8_t > CmdArgs
List of backend command-line options for -fembed-bitcode.
OptRemark OptimizationRemarkAnalysis
Selected optimizations for which we should enable optimization analyses.
std::vector< std::string > CommandLineArgs
void resetNonModularOptions(StringRef ModuleFormat)
Reset all of the options that are not considered when building a module.
std::string OptRecordFormat
The format used for serializing remarks (default: YAML)
std::string DIBugsReportFilePath
The file to use for dumping bug report by Debugify for original debug info.
OptRemark OptimizationRemarkMissed
Selected optimizations for which we should enable missed optimization remarks.
The base class of CompilerInvocation.
std::shared_ptr< MigratorOptions > MigratorOpts
std::shared_ptr< PreprocessorOutputOptions > PreprocessorOutputOpts
Options controlling preprocessed output.
std::shared_ptr< APINotesOptions > APINotesOpts
Options controlling API notes.
std::shared_ptr< TargetOptions > TargetOpts
Options controlling the target.
const FrontendOptions & getFrontendOpts() const
const CodeGenOptions & getCodeGenOpts() const
llvm::function_ref< const char *(const Twine &)> StringAllocator
Command line generation.
const FileSystemOptions & getFileSystemOpts() const
std::shared_ptr< PreprocessorOptions > PPOpts
Options controlling the preprocessor (aside from #include handling).
const PreprocessorOutputOptions & getPreprocessorOutputOpts() const
std::vector< std::string > getCC1CommandLine() const
Generate cc1-compatible command line arguments from this instance, wrapping the result as a std::vect...
std::shared_ptr< FileSystemOptions > FSOpts
Options controlling file system operations.
const AnalyzerOptions & getAnalyzerOpts() const
const MigratorOptions & getMigratorOpts() const
void generateCC1CommandLine(llvm::SmallVectorImpl< const char * > &Args, StringAllocator SA) const
Generate cc1-compatible command line arguments from this instance.
CompilerInvocationBase & deep_copy_assign(const CompilerInvocationBase &X)
const DependencyOutputOptions & getDependencyOutputOpts() const
AnalyzerOptionsRef AnalyzerOpts
Options controlling the static analyzer.
IntrusiveRefCntPtr< DiagnosticOptions > DiagnosticOpts
Options controlling the diagnostic engine.
CompilerInvocationBase & shallow_copy_assign(const CompilerInvocationBase &X)
const TargetOptions & getTargetOpts() const
std::shared_ptr< CodeGenOptions > CodeGenOpts
Options controlling IRgen and the backend.
std::shared_ptr< LangOptions > LangOpts
Options controlling the language variant.
const APINotesOptions & getAPINotesOpts() const
const HeaderSearchOptions & getHeaderSearchOpts() const
std::shared_ptr< HeaderSearchOptions > HSOpts
Options controlling the #include directive.
const PreprocessorOptions & getPreprocessorOpts() const
const DiagnosticOptions & getDiagnosticOpts() const
const LangOptions & getLangOpts() const
Const getters.
std::shared_ptr< FrontendOptions > FrontendOpts
Options controlling the frontend itself.
llvm::function_ref< void(const Twine &)> ArgumentConsumer
std::shared_ptr< DependencyOutputOptions > DependencyOutputOpts
Options controlling dependency output.
Helper class for holding the data necessary to invoke the compiler.
PreprocessorOptions & getPreprocessorOpts()
void clearImplicitModuleBuildOptions()
Disable implicit modules and canonicalize options that are only used by implicit modules.
MigratorOptions & getMigratorOpts()
AnalyzerOptions & getAnalyzerOpts()
APINotesOptions & getAPINotesOpts()
static std::string GetResourcesPath(const char *Argv0, void *MainAddr)
Get the directory where the compiler headers reside, relative to the compiler binary (found by the pa...
static bool CreateFromArgs(CompilerInvocation &Res, ArrayRef< const char * > CommandLineArgs, DiagnosticsEngine &Diags, const char *Argv0=nullptr)
Create a compiler invocation from a list of input options.
LangOptions & getLangOpts()
Mutable getters.
static bool checkCC1RoundTrip(ArrayRef< const char * > Args, DiagnosticsEngine &Diags, const char *Argv0=nullptr)
Check that Args can be parsed and re-serialized without change, emiting diagnostics for any differenc...
DependencyOutputOptions & getDependencyOutputOpts()
CompilerInvocation()=default
void resetNonModularOptions()
Reset all of the options that are not considered when building a module.
FrontendOptions & getFrontendOpts()
std::string getModuleHash() const
Retrieve a module hash string that is suitable for uniquely identifying the conditions under which th...
FileSystemOptions & getFileSystemOpts()
CompilerInvocation & operator=(const CompilerInvocation &X)
CodeGenOptions & getCodeGenOpts()
std::shared_ptr< LangOptions > LangOpts
Base class internals.
TargetOptions & getTargetOpts()
HeaderSearchOptions & getHeaderSearchOpts()
DiagnosticOptions & getDiagnosticOpts()
PreprocessorOutputOptions & getPreprocessorOutputOpts()
Same as CompilerInvocation, but with copy-on-write optimization.
FrontendOptions & getMutFrontendOpts()
LangOptions & getMutLangOpts()
Mutable getters.
HeaderSearchOptions & getMutHeaderSearchOpts()
MigratorOptions & getMutMigratorOpts()
PreprocessorOptions & getMutPreprocessorOpts()
APINotesOptions & getMutAPINotesOpts()
PreprocessorOutputOptions & getMutPreprocessorOutputOpts()
CodeGenOptions & getMutCodeGenOpts()
TargetOptions & getMutTargetOpts()
FileSystemOptions & getMutFileSystemOpts()
AnalyzerOptions & getMutAnalyzerOpts()
DiagnosticOptions & getMutDiagnosticOpts()
DependencyOutputOptions & getMutDependencyOutputOpts()
DependencyOutputOptions - Options for controlling the compiler dependency file generation.
ShowIncludesDestination ShowIncludesDest
Destination of cl.exe style /showIncludes info.
HeaderIncludeFormatKind HeaderIncludeFormat
The format of header information.
std::string OutputFile
The file to write dependency output to.
HeaderIncludeFilteringKind HeaderIncludeFiltering
Determine whether header information should be filtered.
std::vector< std::string > Targets
A list of names to use as the targets in the dependency file; this list must contain at least one ent...
std::vector< std::pair< std::string, ExtraDepKind > > ExtraDeps
A list of extra dependencies (filename and kind) to be used for every target.
unsigned IncludeSystemHeaders
Include system header dependencies.
Used for handling and querying diagnostic IDs.
Options for controlling the compiler diagnostics engine.
std::vector< std::string > Remarks
The list of -R... options used to alter the diagnostic mappings, with the prefixes removed.
std::vector< std::string > Warnings
The list of -W... options used to alter the diagnostic mappings, with the prefixes removed.
std::vector< std::string > VerifyPrefixes
The prefixes for comment directives sought by -verify ("expected" by default).
std::string DiagnosticSerializationFile
The file to serialize diagnostics to (non-appending).
Concrete class used by the front-end to report problems and issues.
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
unsigned getCustomDiagID(Level L, const char(&FormatString)[N])
Return an ID for a diagnostic with the specified format string and level.
void setClient(DiagnosticConsumer *client, bool ShouldOwnClient=true)
Set the diagnostic client associated with this diagnostic object.
unsigned getNumErrors() const
bool isIgnored(unsigned DiagID, SourceLocation Loc) const
Determine whether the diagnostic is known to be ignored.
unsigned getNumWarnings() const
Keeps track of options that affect how file operations are performed.
std::string WorkingDir
If set, paths are resolved as if the working directory was set to the value of WorkingDir.
FrontendOptions - Options for controlling the behavior of the frontend.
InputKind DashX
The input kind, either specified via -x argument or deduced from the input file name.
std::vector< std::string > ModuleFiles
The list of additional prebuilt module files to load before processing the input.
std::map< std::string, std::vector< std::string > > PluginArgs
Args to pass to the plugins.
unsigned IsSystemModule
When using -emit-module, treat the modulemap as a system module.
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.
enum clang::FrontendOptions::@198 ARCMTAction
std::vector< std::shared_ptr< ModuleFileExtension > > ModuleFileExtensions
The list of module file extensions.
ParsedSourceLocation CodeCompletionAt
If given, enable code completion at the provided location.
std::string FixItSuffix
If given, the new suffix for fix-it rewritten files.
static InputKind getInputKindForExtension(StringRef Extension)
getInputKindForExtension - Return the appropriate input kind for a file extension.
std::vector< std::string > Plugins
The list of plugins to load.
unsigned ASTDumpAll
Whether we deserialize all decls when forming AST dumps.
unsigned GenerateGlobalModuleIndex
Whether we can generate the global module index if needed.
unsigned DisableFree
Disable memory freeing on exit.
SmallVector< FrontendInputFile, 0 > Inputs
The input files and their types.
frontend::ActionKind ProgramAction
The frontend action to perform.
std::optional< std::vector< std::string > > AuxTargetFeatures
Auxiliary target features for CUDA/HIP compilation.
std::string AuxTriple
Auxiliary triple for CUDA/HIP compilation.
unsigned UseGlobalModuleIndex
Whether we can use the global module index if available.
unsigned ASTDumpDecls
Whether we include declaration dumps in AST dumps.
A diagnostic client that ignores all diagnostics.
@ None
No signing for any function.
@ NonLeaf
Sign the return address of functions that spill LR.
@ All
Sign the return address of all functions,.
@ BKey
Return address signing uses APIB key.
@ AKey
Return address signing uses APIA key.
@ Ver6
Attempt to be ABI-compatible with code generated by Clang 6.0.x (SVN r321711).
@ Ver18
Attempt to be ABI-compatible with code generated by Clang 18.0.x.
@ Ver4
Attempt to be ABI-compatible with code generated by Clang 4.0.x (SVN r291814).
@ Ver14
Attempt to be ABI-compatible with code generated by Clang 14.0.x.
@ Ver11
Attempt to be ABI-compatible with code generated by Clang 11.0.x (git 2e10b7a39b93).
@ Ver15
Attempt to be ABI-compatible with code generated by Clang 15.0.x.
@ Ver17
Attempt to be ABI-compatible with code generated by Clang 17.0.x.
@ Ver7
Attempt to be ABI-compatible with code generated by Clang 7.0.x (SVN r338536).
@ Latest
Conform to the underlying platform's C and C++ ABIs as closely as we can.
@ Ver3_8
Attempt to be ABI-compatible with code generated by Clang 3.8.x (SVN r257626).
@ Ver12
Attempt to be ABI-compatible with code generated by Clang 12.0.x (git 8e464dd76bef).
@ Ver9
Attempt to be ABI-compatible with code generated by Clang 9.0.x (SVN r351319).
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
void resetNonModularOptions()
Reset all of the options that are not considered when building a module.
std::optional< TargetCXXABI::Kind > CXXABI
C++ ABI to compile with, if specified by the frontend through -fc++-abi=.
std::vector< std::string > NoBuiltinFuncs
A list of all -fno-builtin-* function names (e.g., memset).
std::string ModuleName
The module currently being compiled as specified by -fmodule-name.
clang::ObjCRuntime ObjCRuntime
std::string getOpenCLVersionString() const
Return the OpenCL C or C++ for OpenCL language name and version as a string.
SanitizerSet Sanitize
Set of enabled sanitizers.
bool UseTargetPathSeparator
Indicates whether to use target's platform-specific file separator when FILE macro is used and when c...
static void setLangDefaults(LangOptions &Opts, Language Lang, const llvm::Triple &T, std::vector< std::string > &Includes, LangStandard::Kind LangStd=LangStandard::lang_unspecified)
Set language defaults for the given input language and language standard in the given LangOptions obj...
std::string OMPHostIRFile
Name of the IR file that contains the result of the OpenMP target host code generation.
std::string OverflowHandler
The name of the handler function to be called when -ftrapv is specified.
std::string RandstructSeed
The seed used by the randomize structure layout feature.
std::map< std::string, std::string, std::greater< std::string > > MacroPrefixMap
A prefix map for FILE, BASE_FILE and __builtin_FILE().
LangStandard::Kind LangStd
The used language standard.
std::string OpenACCMacroOverride
unsigned getOpenCLCompatibleVersion() const
Return the OpenCL version that kernel language is compatible with.
bool SanitizeCoverage
Is at least one coverage instrumentation type enabled.
std::vector< llvm::Triple > OMPTargetTriples
Triples of the OpenMP targets that the host code codegen should take into account in order to generat...
std::vector< std::string > NoSanitizeFiles
Paths to files specifying which objects (files, functions, variables) should not be instrumented.
std::string CurrentModule
The name of the current module, of which the main source file is a part.
std::vector< std::string > ModuleFeatures
The names of any features to enable in module 'requires' decls in addition to the hard-coded list in ...
The basic abstraction for the target Objective-C runtime.
bool allowsWeak() const
Does this runtime allow the use of __weak?
bool tryParse(StringRef input)
Try to parse an Objective-C runtime specification from the given string.
std::string getAsString() const
bool allowsARC() const
Does this runtime allow ARC at all?
@ FragileMacOSX
'macosx-fragile' is the Apple-provided NeXT-derived runtime on Mac OS X platforms that use the fragil...
PreprocessorOptions - This class is used for passing the various options used in preprocessor initial...
std::vector< std::pair< std::string, std::string > > RemappedFiles
The set of file remappings, which take existing files on the system (the first part of each pair) and...
bool PCHWithHdrStopCreate
When true, we are creating a PCH or creating the PCH object while expecting a #pragma hdrstop to sepa...
std::vector< std::string > Includes
std::pair< unsigned, bool > PrecompiledPreambleBytes
If non-zero, the implicit PCH include is actually a precompiled preamble that covers this number of b...
bool LexEditorPlaceholders
When enabled, the preprocessor will construct editor placeholder tokens.
void resetNonModularOptions()
Reset any options that are not considered when building a module.
void addMacroUndef(StringRef Name)
std::set< std::string > DeserializedPCHDeclsToErrorOn
This is a set of names for decls that we do not want to be deserialized, and we emit an error if they...
void addMacroDef(StringRef Name)
bool DefineTargetOSMacros
Indicates whether to predefine target OS macros.
bool DetailedRecord
Whether we should maintain a detailed record of all macro definitions and expansions.
std::vector< std::string > ChainedIncludes
Headers that will be converted to chained PCHs in memory.
bool PCHWithHdrStop
When true, we are creating or using a PCH where a #pragma hdrstop is expected to indicate the beginni...
std::optional< uint64_t > SourceDateEpoch
If set, the UNIX timestamp specified by SOURCE_DATE_EPOCH.
bool UsePredefines
Initialize the preprocessor with the compiler and target specific predefines.
void addRemappedFile(StringRef From, StringRef To)
std::vector< std::pair< std::string, bool > > Macros
PreprocessorOutputOptions - Options for controlling the C preprocessor output (e.g....
unsigned ShowMacros
Print macro definitions.
unsigned ShowCPP
Print normal preprocessed output.
unsigned ShowLineMarkers
Show #line markers.
unsigned DirectivesOnly
Process directives but do not expand macros.
Encodes a location in the source.
static bool isSupportedCXXABI(const llvm::Triple &T, Kind Kind)
static const auto & getSpelling(Kind ABIKind)
static bool usesRelativeVTables(const llvm::Triple &T)
static bool isABI(StringRef Name)
Options for controlling the target.
std::string Triple
The name of the target triple to compile for.
llvm::VersionTuple SDKVersion
The version of the SDK which was used during the compilation.
uint64_t LargeDataThreshold
llvm::VersionTuple DarwinTargetVariantSDKVersion
The version of the darwin target variant SDK which was used during the compilation.
std::string HostTriple
When compiling for the device side, contains the triple used to compile for the host.
Action - Represent an abstract compilation step to perform.
static std::string GetResourcesPath(StringRef BinaryPath, StringRef CustomResourceDir="")
Takes the path to a binary that's either in bin/ or lib/ and returns the path to clang's resource dir...
constexpr XRayInstrMask None
constexpr XRayInstrMask All
const llvm::opt::OptTable & getDriverOptTable()
IncludeDirGroup
IncludeDirGroup - Identifies the group an include Entry belongs to, representing its relative positiv...
@ CXXSystem
Like System, but only used for C++.
@ Angled
Paths for '#include <>' added by '-I'.
@ CSystem
Like System, but only used for C.
@ System
Like Angled, but marks system directories.
@ Quoted
'#include ""' paths, added by 'gcc -iquote'.
@ ExternCSystem
Like System, but headers are implicitly wrapped in extern "C".
@ ObjCSystem
Like System, but only used for ObjC.
@ IndexHeaderMap
Like Angled, but marks header maps used when building frameworks.
@ ObjCXXSystem
Like System, but only used for ObjC++.
@ After
Like System, but searched after the system directories.
@ GenerateHeaderUnit
Generate a C++20 header unit module from a header file.
@ VerifyPCH
Load and verify that a PCH file is usable.
@ PrintPreprocessedInput
-E mode.
@ RewriteTest
Rewriter playground.
@ ParseSyntaxOnly
Parse and perform semantic analysis.
@ TemplightDump
Dump template instantiations.
@ GenerateModuleInterface
Generate pre-compiled module from a standard C++ module interface unit.
@ EmitLLVM
Emit a .ll file.
@ PrintPreamble
Print the "preamble" of the input file.
@ MigrateSource
Run migrator.
@ InitOnly
Only execute frontend initialization.
@ ASTView
Parse ASTs and view them in Graphviz.
@ PluginAction
Run a plugin action,.
@ DumpRawTokens
Dump out raw tokens.
@ PrintDependencyDirectivesSourceMinimizerOutput
Print the output of the dependency directives source minimizer.
@ RewriteObjC
ObjC->C Rewriter.
@ RunPreprocessorOnly
Just lex, no output.
@ ModuleFileInfo
Dump information about a module file.
@ 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.
SanitizerMask parseSanitizerValue(StringRef Value, bool AllowGroups)
Parse a single value from a -fsanitize= or -fno-sanitize= value list.
const FunctionProtoType * T
AnalysisDiagClients
AnalysisDiagClients - Set of available diagnostic clients for rendering analysis results.
@ NUM_ANALYSIS_DIAG_CLIENTS
std::string getClangFullRepositoryVersion()
Retrieves the full repository version that is an amalgamation of the information in getClangRepositor...
int getLastArgIntValue(const llvm::opt::ArgList &Args, llvm::opt::OptSpecifier Id, int Default, DiagnosticsEngine *Diags=nullptr, unsigned Base=0)
Return the value of the last argument as an integer, or a default.
bool ParseDiagnosticArgs(DiagnosticOptions &Opts, llvm::opt::ArgList &Args, DiagnosticsEngine *Diags=nullptr, bool DefaultDiagColor=true)
Fill out Opts based on the options given in Args.
@ Success
Template argument deduction was successful.
AnalysisInliningMode
AnalysisInlineFunctionSelection - Set of inlining function selection heuristics.
Diagnostic wrappers for TextAPI types for error reporting.
__DEVICE__ _Tp arg(const std::complex< _Tp > &__c)
bool Internalize
If true, we use LLVM module internalizer.
bool PropagateAttrs
If true, we set attributes functions in the bitcode library according to our CodeGenOptions,...
std::string Filename
The filename of the bitcode file to link in.
unsigned LinkFlags
Bitwise combination of llvm::Linker::Flags, passed to the LLVM linker.
Dummy tag type whose instance can be passed into the constructor to prevent creation of the reference...
LangStandard - Information about the properties of a particular language standard.
static const LangStandard & getLangStandardForKind(Kind K)
const char * getName() const
getName - Get the name of this standard.
static Kind getLangKind(StringRef Name)
static ParsedSourceLocation FromString(StringRef Str)
Construct a parsed source location from a string; the Filename is empty on error.
std::string ToString() const
Serialize ParsedSourceLocation back to a string.
void clear(SanitizerMask K=SanitizerKind::All)
Disable the sanitizers specified in K.
bool empty() const
Returns true if no sanitizers are enabled.
SanitizerMask Mask
Bitmask of enabled sanitizers.