Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://clang.llvm.org/doxygen/CompilerInvocation_8cpp_source.html below:

clang: lib/Frontend/CompilerInvocation.cpp Source File

;

driver;

options;

(Arg.getAsInteger(10, Val))

llvm::createStringError(llvm::inconvertibleErrorCode(),

, Arg.data());

<

T> std::shared_ptr<T> make_shared_copy(

&

) {

std::make_shared<T>(

);

llvm::makeIntrusiveRefCnt<T>(

);

= make_shared_copy(

.getLangOpts());

= make_shared_copy(

.getTargetOpts());

= make_shared_copy(

.getHeaderSearchOpts());

= make_shared_copy(

.getPreprocessorOpts());

= makeIntrusiveRefCntCopy(

.getAnalyzerOpts());

= make_shared_copy(

.getFileSystemOpts());

<

T>

&ensureOwned(std::shared_ptr<T> &Storage) {

(Storage.use_count() > 1)

Storage = std::make_shared<T>(*Storage);

<

T>

(Storage.useCount() > 1)

Storage = llvm::makeIntrusiveRefCnt<T>(*Storage);

ensureOwned(

);

ensureOwned(

);

ensureOwned(

);

OptionStrTable[Offset];

(Args.hasArg(Opt))

(Args.hasArg(Opt))

SpellingOffset, Option::OptionClass,

Twine &Spelling, Option::OptionClass,

!std::is_same_v<T, uint64_t> && llvm::is_integral_or_enum<T>::value;

<

,

std::enable_if_t<!is_uint64_t_convertible<T>(),

> =

>

[

](OptSpecifier Opt,

,

ArgList &Args,

(Args.hasArg(Opt))

<

,

std::enable_if_t<is_uint64_t_convertible<T>(),

> =

>

OptSpecifier OtherOpt) {

[

, OtherValue,

OtherOpt](OptSpecifier Opt,

,

ArgList &Args,

(

Arg *A = Args.getLastArg(Opt, OtherOpt)) {

A->getOption().matches(Opt) ?

: OtherValue;

Option::OptionClass,

,

KeyPath) {

(KeyPath ==

)

Twine &Spelling,

Option::OptionClass OptClass,

,

Twine &

) {

Option::SeparateClass:

Option::JoinedOrSeparateClass:

Option::JoinedAndSeparateClass:

Option::JoinedClass:

Option::CommaJoinedClass:

Consumer(Spelling +

);

llvm_unreachable(

);

<

T>

Option::OptionClass OptClass,

TableIndex,

) {

TableIndex, Twine(

));

<

T>

Option::OptionClass OptClass,

TableIndex,

std::optional<SimpleEnumValue>

(

I = 0,

= Table.Size; I !=

; ++I)

(Name == Table.Table[I].Name)

Table.Table[I];

std::optional<SimpleEnumValue>

(

I = 0,

= Table.Size; I !=

; ++I)

Table.Table[I];

assert(TableIndex < SimpleEnumValueTablesSize);

SimpleEnumValueTable &Table = SimpleEnumValueTables[TableIndex];

*Arg = Args.getLastArg(Opt);

StringRef ArgValue = Arg->getValue();

MaybeEnumVal->Value;

Diags.

(diag::err_drv_invalid_value)

<< Arg->getAsString(Args) << ArgValue;

SpellingOffset,

Option::OptionClass OptClass,

TableIndex,

) {

assert(TableIndex < SimpleEnumValueTablesSize);

SimpleEnumValueTable &Table = SimpleEnumValueTables[TableIndex];

TableIndex, MaybeEnumVal->Name);

llvm_unreachable(

);

<

T>

SpellingOffset,

Option::OptionClass OptClass,

TableIndex,

) {

TableIndex,

(

));

*Arg = Args.getLastArg(Opt);

std::string(Arg->getValue());

<

IntTy>

*Arg = Args.getLastArg(Opt);

(StringRef(Arg->getValue()).getAsInteger(0, Res)) {

Diags.

(diag::err_drv_invalid_int_value)

<< Arg->getAsString(Args) << Arg->getValue();

std::optional<std::vector<std::string>>

Args.getAllArgValues(Opt);

SpellingOffset,

Option::OptionClass OptClass,

std::vector<std::string> &Values) {

Option::CommaJoinedClass: {

std::string CommaJoinedValue;

(!Values.empty()) {

CommaJoinedValue.append(Values.front());

(

std::string &

: llvm::drop_begin(Values, 1)) {

CommaJoinedValue.append(

);

CommaJoinedValue.append(

);

Option::OptionClass::JoinedClass, TableIndex,

Option::JoinedClass:

Option::SeparateClass:

Option::JoinedOrSeparateClass:

(

std::string &

: Values)

llvm_unreachable(

);

*Arg = Args.getLastArg(Opt);

llvm::Triple::normalize(Arg->getValue());

<

T,

U>

(

);

KeyPath |

;

<

T,

U, U Value>

CodeGenOpts.XRayInstrumentFunctions = LangOpts.XRayInstrument;

CodeGenOpts.XRayAlwaysEmitCustomEvents = LangOpts.XRayAlwaysEmitCustomEvents;

CodeGenOpts.XRayAlwaysEmitTypedEvents = LangOpts.XRayAlwaysEmitTypedEvents;

CodeGenOpts.DisableFree = FrontendOpts.

;

CodeGenOpts.ClearASTBeforeBackend =

;

LangOpts.ForceEmitVTables = CodeGenOpts.ForceEmitVTables;

LangOpts.SpeculativeLoadHardening = CodeGenOpts.SpeculativeLoadHardening;

llvm::Triple

(TargetOpts.

);

llvm::Triple::ArchType Arch =

.getArch();

(LangOpts.getExceptionHandling() !=

.isWindowsMSVCEnvironment())

Diags.

(diag::err_fe_invalid_exception_model)

<<

(LangOpts.getExceptionHandling()) <<

.str();

(LangOpts.AppleKext && !LangOpts.CPlusPlus)

Diags.

(diag::warn_c_kext);

(LangOpts.NewAlignOverride &&

!llvm::isPowerOf2_32(LangOpts.NewAlignOverride)) {

Arg *A = Args.getLastArg(OPT_fnew_alignment_EQ);

Diags.

(diag::err_fe_invalid_alignment)

<< A->getAsString(Args) << A->getValue();

LangOpts.NewAlignOverride = 0;

(LangOpts.CPlusPlus11) {

(Args.hasArg(OPT_fraw_string_literals, OPT_fno_raw_string_literals)) {

Args.claimAllArgs(OPT_fraw_string_literals, OPT_fno_raw_string_literals);

Diags.

(diag::warn_drv_fraw_string_literals_in_cxx11)

<<

(LangOpts.RawStringLiterals);

LangOpts.RawStringLiterals =

;

(LangOpts.SYCLIsDevice && LangOpts.SYCLIsHost)

Diags.

(diag::err_drv_argument_not_allowed_with) <<

<<

;

(Args.hasArg(OPT_fgnu89_inline) && LangOpts.CPlusPlus)

Diags.

(diag::err_drv_argument_not_allowed_with)

(Args.hasArg(OPT_hlsl_entrypoint) && !LangOpts.HLSL)

Diags.

(diag::err_drv_argument_not_allowed_with)

(Args.hasArg(OPT_fgpu_allow_device_init) && !LangOpts.HIP)

Diags.

(diag::warn_ignored_hip_only_option)

<< Args.getLastArg(OPT_fgpu_allow_device_init)->getAsString(Args);

(Args.hasArg(OPT_gpu_max_threads_per_block_EQ) && !LangOpts.HIP)

Diags.

(diag::warn_ignored_hip_only_option)

<< Args.getLastArg(OPT_gpu_max_threads_per_block_EQ)->getAsString(Args);

(Args.hasArg(OPT_ffp_eval_method_EQ)) {

(LangOpts.ApproxFunc)

Diags.

(diag::err_incompatible_fp_eval_method_options) << 0;

(LangOpts.AllowFPReassoc)

Diags.

(diag::err_incompatible_fp_eval_method_options) << 1;

(LangOpts.AllowRecip)

Diags.

(diag::err_incompatible_fp_eval_method_options) << 2;

(Args.getLastArg(OPT_cl_strict_aliasing) &&

Diags.

(diag::warn_option_invalid_ocl_version)

<< Args.getLastArg(OPT_cl_strict_aliasing)->getAsString(Args);

(Arg *A = Args.getLastArg(OPT_fdefault_calling_conv_EQ)) {

DefaultCC = LangOpts.getDefaultCallingConv();

Arch != llvm::Triple::x86;

Diags.

(diag::err_drv_argument_not_allowed_with)

<< A->getSpelling() <<

.getTriple();

DefaultOpt = 0;

!Args.hasArg(OPT_cl_opt_disable))

(Arg *A = Args.getLastArg(options::OPT_O_Group)) {

(A->getOption().matches(options::OPT_O0))

(A->getOption().matches(options::OPT_Ofast))

assert(A->getOption().matches(options::OPT_O));

StringRef S(A->getValue());

(S ==

|| S ==

)

(Arg *A = Args.getLastArg(options::OPT_O_Group)) {

(A->getOption().matches(options::OPT_O)) {

(A->getValue()[0]) {

llvm::opt::OptSpecifier OptSpecifier) {

Option::OptionClass::FlagClass, 0);

llvm::opt::OptSpecifier OptSpecifier,

Twine &

) {

CheckAgainstOriginalInvocation =

,

ForceRoundTrip =

) {

DoRoundTripDefault =

;

DoRoundTripDefault =

;

DoRoundTrip = DoRoundTripDefault;

(ForceRoundTrip) {

(

*Arg : CommandLineArgs) {

(Arg == StringRef(

))

(Arg == StringRef(

))

DoRoundTrip =

;

Parse(RealInvocation, CommandLineArgs, Diags, Argv0);

llvm::raw_string_ostream OS(Buffer);

(

*Arg : Args) {

llvm::sys::printArg(OS, Arg,

);

(!Parse(DummyInvocation, CommandLineArgs, DummyDiags, Argv0) ||

= Parse(RealInvocation, CommandLineArgs, Diags, Argv0);

Diags.

(diag::err_cc1_round_trip_fail_then_ok);

Diags.

(diag::note_cc1_round_trip_original)

<< SerializeArgs(CommandLineArgs);

llvm::BumpPtrAllocator Alloc;

llvm::StringSaver StringPool(Alloc);

SA = [&StringPool](

Twine &Arg) {

StringPool.save(Arg).data();

Generate(DummyInvocation, GeneratedArgs, SA);

Success2 = Parse(RealInvocation, GeneratedArgs, Diags, Argv0);

Diags.

(diag::err_cc1_round_trip_ok_then_fail);

Diags.

(diag::note_cc1_round_trip_generated)

<< 1 << SerializeArgs(GeneratedArgs);

(CheckAgainstOriginalInvocation)

ComparisonArgs.assign(CommandLineArgs.begin(), CommandLineArgs.end());

Generate(RealInvocation, ComparisonArgs, SA);

std::equal(A.begin(), A.end(), B.begin(), B.end(),

[](

*AElem,

*BElem) {

return StringRef(AElem) == StringRef(BElem);

(!

(GeneratedArgs, ComparisonArgs)) {

Diags.

(diag::err_cc1_round_trip_mismatch);

Diags.

(diag::note_cc1_round_trip_generated)

<< 1 << SerializeArgs(GeneratedArgs);

Diags.

(diag::note_cc1_round_trip_generated)

<< 2 << SerializeArgs(ComparisonArgs);

Diags.

(diag::remark_cc1_round_trip_generated)

<< 1 << SerializeArgs(GeneratedArgs);

Diags.

(diag::remark_cc1_round_trip_generated)

<< 2 << SerializeArgs(ComparisonArgs);

CreateFromArgsImpl(Invocation, CommandLineArgs, Diags, Argv0);

Args.push_back(

);

DummyInvocation1, DummyInvocation2, Args, Diags, Argv0,

OptSpecifier GroupWithValue,

std::vector<std::string> &Diagnostics) {

(

*A : Args.filtered(Group)) {

(A->getOption().getKind() == Option::FlagClass) {

Diagnostics.push_back(

std::string(A->getOption().getName().drop_front(1)));

}

(A->getOption().matches(GroupWithValue)) {

Diagnostics.push_back(

std::string(A->getOption().getName().drop_front(1).rtrim(

)));

Diagnostics.push_back(A->getValue());

std::vector<std::string> &Funcs) {

std::vector<std::string> Values = Args.getAllArgValues(OPT_fno_builtin_);

Funcs.insert(Funcs.end(), Values.begin(), BuiltinEnd);

llvm_unreachable(

);

llvm_unreachable(

);

llvm_unreachable(

);

llvm_unreachable(

);

CP.second ? OPT_analyzer_checker : OPT_analyzer_disable_checker;

(

&

: Opts.

)

SortedConfigOpts.emplace_back(

.getKey(),

.getValue());

llvm::sort(SortedConfigOpts, llvm::less_first());

(

&[Key,

] : SortedConfigOpts) {

Entry = ConfigOpts.

.find(Key);

(Entry != ConfigOpts.

.end() && Entry->getValue() ==

)

(Arg *A = Args.getLastArg(OPT_analyzer_constraints)) {

StringRef Name = A->getValue();

Diags.

(diag::err_drv_invalid_value)

<< A->getAsString(Args) << Name;

(

== AnalysisConstraints::Z3ConstraintsModel) {

Diags.

(diag::err_analyzer_not_built_with_z3);

(Arg *A = Args.getLastArg(OPT_analyzer_output)) {

StringRef Name = A->getValue();

Diags.

(diag::err_drv_invalid_value)

<< A->getAsString(Args) << Name;

(Arg *A = Args.getLastArg(OPT_analyzer_purge)) {

StringRef Name = A->getValue();

Diags.

(diag::err_drv_invalid_value)

<< A->getAsString(Args) << Name;

(Arg *A = Args.getLastArg(OPT_analyzer_inlining_mode)) {

StringRef Name = A->getValue();

Diags.

(diag::err_drv_invalid_value)

<< A->getAsString(Args) << Name;

(

Arg *A :

Args.filtered(OPT_analyzer_checker, OPT_analyzer_disable_checker)) {

IsEnabled = A->getOption().getID() == OPT_analyzer_checker;

StringRef CheckerAndPackageList = A->getValue();

CheckerAndPackageList.split(CheckersAndPackages,

);

(

StringRef &CheckerOrPackage : CheckersAndPackages)

(

*A : Args.filtered(OPT_analyzer_config)) {

StringRef configList = A->getValue();

configList.split(configVals,

);

(

&configVal : configVals) {

std::tie(key, val) = configVal.split(

);

diag::err_analyzer_config_no_value) << configVal;

(val.contains(

)) {

diag::err_analyzer_config_multiple_values)

Diags.

(diag::err_analyzer_config_unknown) << key;

Opts.

[key] = std::string(val);

(

i = 0; i < Args.getNumInputArgStrings(); ++i) {

os << Args.getArgString(i);

StringRef OptionName, StringRef DefaultVal) {

Config.insert({OptionName, std::string(DefaultVal)}).first->second;

StringRef &OptionField, StringRef Name,

StringRef DefaultVal) {

&OptionField, StringRef Name,

DefaultVal) {

PossiblyInvalidVal =

llvm::StringSwitch<std::optional<bool>>(

.Case(

,

)

.Case(

,

)

.Default(std::nullopt);

(!PossiblyInvalidVal) {

Diags->

(diag::err_analyzer_config_invalid_input)

<< Name <<

;

OptionField = DefaultVal;

OptionField = *PossiblyInvalidVal;

&OptionField, StringRef Name,

DefaultVal) {

OptionField = DefaultVal;

HasFailed =

(Config, Name, std::to_string(DefaultVal))

.getAsInteger(0, OptionField);

(Diags && HasFailed)

Diags->

(diag::err_analyzer_config_invalid_input)

<< Name <<

;

DefaultVal) {

(Parsed.has_value()) {

OptionField = Parsed.value();

(Diags && !Parsed.has_value())

Diags->

(diag::err_analyzer_config_invalid_input)

<< Name <<

;

OptionField = DefaultVal;

assert(AnOpts.UserMode ==

|| AnOpts.UserMode ==

);

InShallowMode = AnOpts.UserMode ==

;

(!AnOpts.RawSilencedCheckersAndPackages.empty()) {

std::vector<StringRef> Checkers =

std::vector<StringRef> Packages =

AnOpts.RawSilencedCheckersAndPackages.split(CheckersAndPackages,

);

(

StringRef &CheckerOrPackage : CheckersAndPackages) {

IsChecker = CheckerOrPackage.contains(

);

IsValidName = IsChecker

? llvm::is_contained(Checkers, CheckerOrPackage)

: llvm::is_contained(Packages, CheckerOrPackage);

Diags->

(diag::err_unknown_analyzer_checker_or_package)

<< CheckerOrPackage;

(AnOpts.ShouldTrackConditionsDebug && !AnOpts.ShouldTrackConditions)

Diags->

(diag::err_analyzer_config_invalid_input)

<<

<<

;

(!AnOpts.CTUDir.empty() && !llvm::sys::fs::is_directory(AnOpts.CTUDir))

Diags->

(diag::err_analyzer_config_invalid_input) <<

(!AnOpts.ModelPath.empty() &&

!llvm::sys::fs::is_directory(AnOpts.ModelPath))

Diags->

(diag::err_analyzer_config_invalid_input) <<

(

.hasValidPattern()) {

(Consumer, OPT_R_Joined, StringRef(

) + Name);

OptSpecifier OptEQ, StringRef Name) {

InitializeResultPattern = [&Diags, &Args, &

](

Arg *A,

StringRef Pattern) {

.Pattern = Pattern.str();

std::string RegexError;

.Regex = std::make_shared<llvm::Regex>(

.Pattern);

(!

.Regex->isValid(RegexError)) {

Diags.

(diag::err_drv_optimization_remark_pattern)

<< RegexError << A->getAsString(Args);

(Arg *A : Args) {

(A->getOption().matches(OPT_R_Joined)) {

StringRef

= A->getValue();

(

==

)

(

.split(

) == std::make_pair(StringRef(

), Name))

(

==

)

.Regex =

;

InitializeResultPattern(A,

);

}

(A->getOption().matches(OptEQ)) {

(!InitializeResultPattern(A, A->getValue()))

std::vector<std::string> &Levels,

(

&Level : Levels) {

llvm::StringSwitch<DiagnosticLevelMask>(Level)

Diags.

(diag::err_drv_invalid_value) << FlagName << Level;

std::vector<std::string> &Sanitizers,

(

&Sanitizer : Sanitizers) {

Diags.

(diag::err_drv_invalid_value) << FlagName << Sanitizer;

std::vector<std::string> &Sanitizers,

(

&Sanitizer : Sanitizers) {

Diags.

(diag::err_drv_invalid_value) << FlagName << Sanitizer;

llvm::SplitString(Bundle, BundleParts,

);

(

&B : BundleParts) {

.Report(diag::err_drv_invalid_value) << FlagName << Bundle;

llvm::raw_string_ostream OS(Buffer);

llvm::interleave(BundleParts, OS, [&OS](StringRef Part) { OS << Part; },

);

Twine &ProfileName,

llvm::vfs::FileSystem &FS,

ReaderOrErr = llvm::IndexedInstrProfReader::create(ProfileName, FS);

(

= ReaderOrErr.takeError()) {

);

llvm::handleAllErrors(std::move(

), [&](

llvm::ErrorInfoBase &EI) {

Diags.

(DiagID) << ProfileName.str() << EI.message();

std::unique_ptr<llvm::IndexedInstrProfReader> PGOReader =

std::move(ReaderOrErr.get());

(PGOReader->isIRLevelProfile() || PGOReader->hasMemoryProfile()) {

(PGOReader->hasCSIRLevelProfile())

llvm::Triple &Triple) {

assert(Triple.getArch() == llvm::Triple::aarch64);

.PointerAuthFunctionTypeDiscrimination ? Discrimination::Type

: Discrimination::None);

Key::ASDA,

.PointerAuthVTPtrAddressDiscrimination,

.PointerAuthVTPtrTypeDiscrimination ? Discrimination::Type

: Discrimination::None);

(

.PointerAuthTypeInfoVTPtrDiscrimination)

(

.PointerAuthInitFini) {

Key::ASIA,

.PointerAuthInitFiniAddressDiscrimination,

llvm::Triple &Triple,

(!LangOpts.PointerAuthCalls && !LangOpts.PointerAuthReturns &&

!LangOpts.PointerAuthAuthTraps && !LangOpts.PointerAuthIndirectGotos &&

!LangOpts.AArch64JumpTableHardening)

CompilerInvocationBase::GenerateCodeGenArgs(

&Opts,

llvm::Triple &

,

std::string &OutputFile,

(Opts.OptimizationLevel == 0)

(Consumer, OPT_O, Twine(Opts.OptimizationLevel));

(Opts.OptimizationLevel > 0) {

(Consumer, OPT_finline_hint_functions);

(Opts.DirectAccessExternalData &&

->PICLevel != 0)

(Consumer, OPT_fdirect_access_external_data);

(!Opts.DirectAccessExternalData &&

->PICLevel == 0)

(Consumer, OPT_fno_direct_access_external_data);

std::optional<StringRef> DebugInfoVal;

(Opts.DebugInfo) {

llvm::codegenoptions::DebugLineTablesOnly:

DebugInfoVal =

;

llvm::codegenoptions::DebugDirectivesOnly:

DebugInfoVal =

;

llvm::codegenoptions::DebugInfoConstructor:

DebugInfoVal =

;

llvm::codegenoptions::LimitedDebugInfo:

DebugInfoVal =

;

llvm::codegenoptions::FullDebugInfo:

DebugInfoVal =

;

llvm::codegenoptions::UnusedTypeInfo:

DebugInfoVal =

;

llvm::codegenoptions::NoDebugInfo:

DebugInfoVal = std::nullopt;

llvm::codegenoptions::LocTrackingOnly:

DebugInfoVal = std::nullopt;

(Consumer, OPT_debug_info_kind_EQ, *DebugInfoVal);

Prefix.first +

+ Prefix.second);

(Consumer, OPT_fcoverage_prefix_map_EQ,

Prefix.first +

+ Prefix.second);

(Opts.NewStructPathTBAA)

(Opts.OptimizeSize == 1)

(Opts.OptimizeSize == 2)

(Opts.UnrollLoops && Opts.OptimizationLevel <= 1)

(!Opts.UnrollLoops && Opts.OptimizationLevel > 1)

(Opts.DebugNameTable ==

(llvm::DICompileUnit::DebugNameTableKind::GNU))

(Opts.DebugNameTable ==

(

llvm::DICompileUnit::DebugNameTableKind::Default))

(Opts.DebugTemplateAlias)

TNK = Opts.getDebugSimpleTemplateNames();

(TNK != llvm::codegenoptions::DebugTemplateNamesKind::Full) {

(TNK == llvm::codegenoptions::DebugTemplateNamesKind::Simple)

(Consumer, OPT_gsimple_template_names_EQ,

);

(TNK == llvm::codegenoptions::DebugTemplateNamesKind::Mangled)

(Consumer, OPT_gsimple_template_names_EQ,

);

(Opts.TimePasses) {

(Opts.TimePassesPerRun)

(Consumer, OPT_ftime_report_EQ,

);

(Opts.PrepareForLTO && !Opts.PrepareForThinLTO)

(Opts.PrepareForThinLTO)

(Consumer, OPT_save_temps_EQ,

);

StringRef MemProfileBasename(

);

std::string InstrBundle =

(!InstrBundle.empty())

(Consumer, OPT_fxray_instrumentation_bundle, InstrBundle);

(Opts.CFProtectionReturn && Opts.CFProtectionBranch)

(Consumer, OPT_fcf_protection_EQ,

);

(Opts.CFProtectionReturn)

(Consumer, OPT_fcf_protection_EQ,

);

(Opts.CFProtectionBranch)

(Consumer, OPT_fcf_protection_EQ,

);

(Opts.CFProtectionBranch) {

(Opts.getCFBranchLabelScheme()) {

(Opts.FunctionReturnThunks)

(Consumer, OPT_mfunction_return_EQ,

);

Builtint = F.LinkFlags == llvm::Linker::Flags::LinkOnlyNeeded &&

F.PropagateAttrs && F.Internalize;

Builtint ? OPT_mlink_builtin_bitcode : OPT_mlink_bitcode_file,

(Opts.EmulatedTLS)

(Consumer, OPT_fdenormal_fp_math_f32_EQ,

.isPPC32() ? OPT_maix_struct_return : OPT_fpcc_struct_return;

.isPPC32() ? OPT_msvr4_struct_return : OPT_freg_struct_return;

(Opts.EnableAIXExtendedAltivecABI)

(Opts.XCOFFReadOnlyPointers)

(Consumer, OPT_fdiagnostics_hotness_threshold_EQ,

(Consumer, OPT_fdiagnostics_misexpect_tolerance_EQ,

(Consumer, OPT_fsanitize_recover_EQ, Sanitizer);

(Consumer, OPT_fsanitize_trap_EQ, Sanitizer);

(StringRef Sanitizer :

(Consumer, OPT_fsanitize_merge_handlers_EQ, Sanitizer);

(std::string Sanitizer : Values)

(Consumer, OPT_fsanitize_skip_hot_cutoff_EQ, Sanitizer);

(!Opts.EmitVersionIdentMetadata)

(Opts.FiniteLoops) {

CompilerInvocation::ParseCodeGenArgs(

&Opts, ArgList &Args,

llvm::Triple &

,

std::string &OutputFile,

MaxOptLevel = 3;

(OptimizationLevel > MaxOptLevel) {

Diags.

(diag::warn_drv_optimization_value)

<< Args.getLastArg(OPT_O)->getAsString(Args) <<

<< MaxOptLevel;

OptimizationLevel = MaxOptLevel;

Opts.OptimizationLevel = OptimizationLevel;

(Opts.OptimizationLevel == 0) {

}

(

Arg *A = Args.getLastArg(options::OPT_finline_functions,

options::OPT_finline_hint_functions,

options::OPT_fno_inline_functions,

options::OPT_fno_inline)) {

(A->getOption().matches(options::OPT_finline_functions))

(A->getOption().matches(options::OPT_finline_hint_functions))

Opts.DirectAccessExternalData =

Args.hasArg(OPT_fdirect_access_external_data) ||

(!Args.hasArg(OPT_fno_direct_access_external_data) &&

(Arg *A = Args.getLastArg(OPT_debug_info_kind_EQ)) {

llvm::StringSwitch<unsigned>(A->getValue())

.Case(

, llvm::codegenoptions::DebugLineTablesOnly)

.Case(

,

llvm::codegenoptions::DebugDirectivesOnly)

.Case(

, llvm::codegenoptions::DebugInfoConstructor)

.Case(

, llvm::codegenoptions::LimitedDebugInfo)

.Case(

, llvm::codegenoptions::FullDebugInfo)

.Case(

, llvm::codegenoptions::UnusedTypeInfo)

Diags.

(diag::err_drv_invalid_value) << A->getAsString(Args)

Opts.setDebugInfo(

llvm::codegenoptions::DebugInfoKind

(Val));

Args.getLastArg(OPT_fuse_ctor_homing, OPT_fno_use_ctor_homing)) {

(A->getOption().matches(OPT_fuse_ctor_homing) &&

Opts.getDebugInfo() == llvm::codegenoptions::LimitedDebugInfo)

Opts.setDebugInfo(llvm::codegenoptions::DebugInfoConstructor);

(A->getOption().matches(OPT_fno_use_ctor_homing) &&

Opts.getDebugInfo() == llvm::codegenoptions::DebugInfoConstructor)

Opts.setDebugInfo(llvm::codegenoptions::LimitedDebugInfo);

(

&Arg : Args.getAllArgValues(OPT_fdebug_prefix_map_EQ)) {

= StringRef(Arg).split(

);

(

&Arg : Args.getAllArgValues(OPT_fcoverage_prefix_map_EQ)) {

= StringRef(Arg).split(

);

llvm::Triple::ArchType DebugEntryValueArchs[] = {

llvm::Triple::x86, llvm::Triple::x86_64, llvm::Triple::aarch64,

llvm::Triple::arm, llvm::Triple::armeb, llvm::Triple::mips,

llvm::Triple::mipsel, llvm::Triple::mips64, llvm::Triple::mips64el};

llvm::is_contained(DebugEntryValueArchs,

.getArch()))

Opts.EmitCallSiteInfo =

;

Diags.

(diag::warn_ignoring_verify_debuginfo_preserve_export)

Opts.NewStructPathTBAA = !Args.hasArg(OPT_no_struct_path_tbaa) &&

Args.hasArg(OPT_new_struct_path_tbaa);

Opts.SimplifyLibCalls = !

->NoBuiltin;

(Opts.SimplifyLibCalls)

Args.hasFlag(OPT_funroll_loops, OPT_fno_unroll_loops,

(Opts.OptimizationLevel > 1));

std::string(Args.getLastArgValue(OPT_fbinutils_version_EQ));

Opts.DebugTemplateAlias = Args.hasArg(OPT_gtemplate_alias);

Opts.DebugNameTable =

(

Args.hasArg(OPT_ggnu_pubnames)

? llvm::DICompileUnit::DebugNameTableKind::GNU

: Args.hasArg(OPT_gpubnames)

? llvm::DICompileUnit::DebugNameTableKind::Default

: llvm::DICompileUnit::DebugNameTableKind::None);

(

Arg *A = Args.getLastArg(OPT_gsimple_template_names_EQ)) {

StringRef

= A->getValue();

(

!=

&&

!=

)

Diags.

(diag::err_drv_unsupported_option_argument)

<< A->getSpelling() << A->getValue();

Opts.setDebugSimpleTemplateNames(

StringRef(A->getValue()) ==

? llvm::codegenoptions::DebugTemplateNamesKind::Simple

: llvm::codegenoptions::DebugTemplateNamesKind::Mangled);

(

Arg *A = Args.getLastArg(OPT_ftime_report, OPT_ftime_report_EQ)) {

Opts.TimePasses =

;

(A->getOption().getID() == OPT_ftime_report_EQ) {

StringRef Val = A->getValue();

(Val ==

)

Opts.TimePassesPerRun =

;

(Val ==

)

Opts.TimePassesPerRun =

;

Diags.

(diag::err_drv_invalid_value)

<< A->getAsString(Args) << A->getValue();

Opts.PrepareForLTO =

;

Opts.PrepareForThinLTO =

;

(Arg *A = Args.getLastArg(OPT_flto_EQ)) {

Opts.PrepareForLTO =

;

StringRef S = A->getValue();

Opts.PrepareForThinLTO =

;

(S !=

)

Diags.

(diag::err_drv_invalid_value) << A->getAsString(Args) << S;

(Args.hasArg(OPT_funified_lto))

Opts.PrepareForThinLTO =

;

(Arg *A = Args.getLastArg(OPT_fthinlto_index_EQ)) {

Diags.

(diag::err_drv_argument_only_allowed_with)

<< A->getAsString(Args) <<

;

std::string(Args.getLastArgValue(OPT_fthinlto_index_EQ));

(Arg *A = Args.getLastArg(OPT_save_temps_EQ))

llvm::StringSwitch<std::string>(A->getValue())

.Case(

, OutputFile)

.Default(llvm::sys::path::filename(OutputFile).str());

*MemProfileBasename =

;

(Args.hasArg(OPT_fmemory_profile_EQ)) {

std::string(Args.getLastArgValue(OPT_fmemory_profile_EQ)));

llvm::sys::path::append(

, MemProfileBasename);

}

(Args.hasArg(OPT_fmemory_profile))

(Args.hasArg(OPT_coverage_version_EQ)) {

StringRef CoverageVersion = Args.getLastArgValue(OPT_coverage_version_EQ);

(CoverageVersion.size() != 4) {

Diags.

(diag::err_drv_invalid_value)

<< Args.getLastArg(OPT_coverage_version_EQ)->getAsString(Args)

(

&A : Args) {

(A->getOption().getID() == options::OPT_o ||

A->getOption().getID() == options::OPT_INPUT ||

A->getOption().getID() == options::OPT_x ||

A->getOption().getID() == options::OPT_fembed_bitcode ||

A->getOption().matches(options::OPT_W_Group))

A->render(Args, ASL);

(

&arg : ASL) {

StringRef ArgStr(arg);

Opts.

.insert(Opts.

.end(), ArgStr.begin(), ArgStr.end());

Opts.

.push_back(

);

XRayInstrBundles =

Args.getAllArgValues(OPT_fxray_instrumentation_bundle);

(XRayInstrBundles.empty())

(

&A : XRayInstrBundles)

(

Arg *A = Args.getLastArg(OPT_fcf_protection_EQ)) {

StringRef Name = A->getValue();

(Name ==

) {

Opts.CFProtectionReturn = 1;

Opts.CFProtectionBranch = 1;

}

(Name ==

)

Opts.CFProtectionReturn = 1;

(Name ==

)

Opts.CFProtectionBranch = 1;

(Name !=

)

Diags.

(diag::err_drv_invalid_value) << A->getAsString(Args) << Name;

(Opts.CFProtectionBranch &&

.isRISCV()) {

(

Arg *A = Args.getLastArg(OPT_mcf_branch_label_scheme_EQ)) {

llvm::StringSwitch<CFBranchLabelSchemeKind>(A->getValue())

Opts.setCFBranchLabelScheme(Scheme);

Diags.

(diag::err_drv_invalid_value)

<< A->getAsString(Args) << A->getValue();

(

Arg *A = Args.getLastArg(OPT_mfunction_return_EQ)) {

Val = llvm::StringSwitch<llvm::FunctionReturnThunksKind>(A->getValue())

.Case(

, llvm::FunctionReturnThunksKind::Keep)

.Case(

, llvm::FunctionReturnThunksKind::Extern)

.Default(llvm::FunctionReturnThunksKind::Invalid);

Diags.

(diag::err_drv_argument_not_allowed_with)

<< A->getSpelling() <<

.getTriple();

(Val == llvm::FunctionReturnThunksKind::Invalid)

Diags.

(diag::err_drv_invalid_value)

<< A->getAsString(Args) << A->getValue();

(Val == llvm::FunctionReturnThunksKind::Extern &&

Args.getLastArgValue(OPT_mcmodel_EQ) ==

)

Diags.

(diag::err_drv_argument_not_allowed_with)

<< A->getAsString(Args)

<< Args.getLastArg(OPT_mcmodel_EQ)->getAsString(Args);

Opts.FunctionReturnThunks =

(Val);

Args.filtered(OPT_mlink_bitcode_file, OPT_mlink_builtin_bitcode)) {

(A->getOption().matches(OPT_mlink_builtin_bitcode)) {

F.

= llvm::Linker::Flags::LinkOnlyNeeded;

(Arg *A = Args.getLastArg(OPT_fdenormal_fp_math_EQ)) {

StringRef Val = A->getValue();

Diags.

(diag::err_drv_invalid_value) << A->getAsString(Args) << Val;

(Arg *A = Args.getLastArg(OPT_fdenormal_fp_math_f32_EQ)) {

StringRef Val = A->getValue();

Diags.

(diag::err_drv_invalid_value) << A->getAsString(Args) << Val;

Args.getLastArg(OPT_fpcc_struct_return, OPT_freg_struct_return,

OPT_maix_struct_return, OPT_msvr4_struct_return)) {

Diags.

(diag::err_drv_unsupported_opt_for_target)

<< A->getSpelling() <<

.str();

Option &O = A->getOption();

(O.matches(OPT_fpcc_struct_return) ||

O.matches(OPT_maix_struct_return)) {

assert(O.matches(OPT_freg_struct_return) ||

O.matches(OPT_msvr4_struct_return));

(Arg *A = Args.getLastArg(OPT_mxcoff_roptr)) {

Diags.

(diag::err_drv_unsupported_opt_for_target)

<< A->getSpelling() <<

.str();

(!Args.hasFlag(OPT_fdata_sections, OPT_fno_data_sections,

))

Diags.

(diag::err_roptr_requires_data_sections);

Opts.XCOFFReadOnlyPointers =

;

(Arg *A = Args.getLastArg(OPT_mabi_EQ_quadword_atomics)) {

(!

.isOSAIX() ||

.isPPC32())

Diags.

(diag::err_drv_unsupported_opt_for_target)

<< A->getSpelling() <<

.str();

NeedLocTracking =

;

NeedLocTracking =

;

(Arg *A = Args.getLastArg(OPT_opt_record_passes)) {

NeedLocTracking =

;

(Arg *A = Args.getLastArg(OPT_opt_record_format)) {

NeedLocTracking =

;

Diags, Args, OPT_Rpass_analysis_EQ,

);

(Opts.DiagnosticsWithHotness && !UsingProfile &&

Diags.

(diag::warn_drv_diagnostics_hotness_requires_pgo)

<<

;

Args.getLastArg(options::OPT_fdiagnostics_hotness_threshold_EQ)) {

llvm::remarks::parseHotnessThresholdOption(

->getValue());

Diags.

(diag::err_drv_invalid_diagnotics_hotness_threshold)

<<

;

Diags.

(diag::warn_drv_diagnostics_hotness_requires_pgo)

<<

;

Args.getLastArg(options::OPT_fdiagnostics_misexpect_tolerance_EQ)) {

Diags.

(diag::err_drv_invalid_diagnotics_misexpect_tolerance)

<<

;

Diags.

(diag::warn_drv_diagnostics_misexpect_requires_pgo)

<<

;

(UsingSampleProfile)

NeedLocTracking =

;

NeedLocTracking =

;

(NeedLocTracking &&

Opts.getDebugInfo() == llvm::codegenoptions::NoDebugInfo)

Opts.setDebugInfo(llvm::codegenoptions::LocTrackingOnly);

Args.getAllArgValues(OPT_fsanitize_recover_EQ), Diags,

Args.getAllArgValues(OPT_fsanitize_trap_EQ), Diags,

Args.getAllArgValues(OPT_fsanitize_merge_handlers_EQ),

,

Args.getAllArgValues(OPT_fsanitize_skip_hot_cutoff_EQ), Diags);

Opts.EmitVersionIdentMetadata = Args.hasFlag(OPT_Qy, OPT_Qn,

);

(Args.hasArg(options::OPT_ffinite_loops))

(Args.hasArg(options::OPT_fno_finite_loops))

Opts.EmitIEEENaNCompliantInsts = Args.hasFlag(

options::OPT_mamdgpu_ieee, options::OPT_mno_amdgpu_ieee,

);

(!Opts.EmitIEEENaNCompliantInsts && !LangOptsRef.NoHonorNaNs)

Diags.

(diag::err_drv_amdgpu_ieee_without_no_honor_nans);

(

&Dep : Opts.

) {

(Dep.second) {

(Consumer, OPT_fdepfile_entry, Dep.first);

ShowLineMarkers) {

(Args.hasArg(OPT_show_includes)) {

(!Args.hasArg(OPT_fno_sanitize_ignorelist)) {

(

*A : Args.filtered(OPT_fsanitize_ignorelist_EQ)) {

StringRef Val = A->getValue();

(!Val.contains(

))

(

*A : Args.filtered(OPT_fsanitize_system_ignorelist_EQ)) {

StringRef Val = A->getValue();

(!Val.contains(

))

(

&

: Args.getAllArgValues(OPT_fprofile_list_EQ))

(

*A : Args.filtered(OPT_fdepfile_entry))

(

*A : Args.filtered(OPT_fmodule_file)) {

StringRef Val = A->getValue();

(!Val.contains(

))

Diags.

(diag::err_drv_print_header_env_var_combination_cc1)

<< Args.getLastArg(OPT_header_include_format_EQ)->getValue()

<< Args.getLastArg(OPT_header_include_filtering_EQ)->getValue();

}

= DefaultColor ? Colors_Auto : Colors_Off;

(

*A : Args) {

Option &O = A->getOption();

(O.matches(options::OPT_fcolor_diagnostics)) {

}

(O.matches(options::OPT_fno_color_diagnostics)) {

}

(O.matches(options::OPT_fdiagnostics_color_EQ)) {

StringRef

(A->getValue());

(

==

)

(

==

)

(

==

)

llvm::sys::Process::StandardErrHasColors());

(

&Prefix : VerifyPrefixes) {

BadChar = llvm::find_if(Prefix, [](

) {

(BadChar != Prefix.end() || !

(Prefix[0])) {

Diags.

(diag::err_drv_invalid_value) <<

<< Prefix;

Diags.

(diag::note_drv_verify_prefix_spelling);

CompilerInvocationBase::GenerateDiagnosticArgs(

DefaultDiagColor) {

(Consumer, OPT_diagnostic_serialized_file,

(Opts.ShowColors)

(Opts.VerifyDiagnostics &&

(Prefix !=

)

(Consumer, OPT_verify_ignore_unexpected);

(Consumer, OPT_verify_ignore_unexpected_EQ,

);

(Consumer, OPT_verify_ignore_unexpected_EQ,

);

(Consumer, OPT_verify_ignore_unexpected_EQ,

);

(Consumer, OPT_verify_ignore_unexpected_EQ,

);

(

==

)

(

==

||

==

)

Consumer(StringRef(

) +

);

StringRef IgnoredRemarks[] = {

,

,

,

,

,

};

(llvm::is_contained(IgnoredRemarks,

))

Consumer(StringRef(

) +

);

(Consumer, OPT_warning_suppression_mappings_EQ,

std::unique_ptr<DiagnosticOptions>

DiagOpts = std::make_unique<DiagnosticOptions>();

MissingArgIndex, MissingArgCount;

Argv.slice(1), MissingArgIndex, MissingArgCount);

(std::optional<std::string> NoColor =

llvm::sys::Process::GetEnv(

);

NoColor && !NoColor->empty()) {

DefaultDiagColor) {

std::optional<DiagnosticsEngine> IgnoringDiags;

Diags = &*IgnoringDiags;

llvm::sys::Process::UseANSIEscapeCodes(Opts.UseANSIEscapeCodes);

Args.getLastArg(OPT_diagnostic_serialized_file, OPT__serialize_diags))

Opts.VerifyDiagnostics = Args.hasArg(OPT_verify) || Args.hasArg(OPT_verify_EQ);

(Args.hasArg(OPT_verify))

Opts.VerifyDiagnostics =

;

,

Args.getAllArgValues(OPT_verify_ignore_unexpected_EQ), *Diags, DiagMask);

(Args.hasArg(OPT_verify_ignore_unexpected))

Opts.setVerifyIgnoreUnexpected(DiagMask);

Diags->

(diag::warn_ignoring_ftabstop_value)

(

Arg *A = Args.getLastArg(OPT_warning_suppression_mappings_EQ))

std::string &BlockName,

&MajorVersion,

&MinorVersion,

std::string &UserInfo) {

Arg.split(Args,

, 5);

(Args.size() < 5)

BlockName = std::string(Args[0]);

(Args[1].getAsInteger(10, MajorVersion))

;

(Args[2].getAsInteger(10, MinorVersion))

;

(Args[3].getAsInteger(2, Hashed))

;

(Args.size() > 4)

UserInfo = std::string(Args[4]);

std::pair<frontend::ActionKind, unsigned> Table[] = {

OPT_emit_reduced_module_interface},

OPT_print_dependency_directives_minimized_source},

std::optional<frontend::ActionKind>

(ActionOpt.second == Opt.getID())

ActionOpt.first;

std::nullopt;

std::optional<OptSpecifier>

(ActionOpt.first == ProgramAction)

OptSpecifier(ActionOpt.second);

std::nullopt;

std::optional<OptSpecifier> ProgramActionOpt =

std::function<void()> GenerateProgramAction = [&]() {

(!ProgramActionOpt) {

);

GenerateProgramAction = [&]() {

GenerateProgramAction = [&]() {

llvm_unreachable(

);

(Consumer, OPT_ast_dump_all_EQ, Format);

GenerateProgramAction = [&]() {

GenerateProgramAction();

(

&PluginArgs : Opts.

) {

(

&PluginArg : PluginArgs.second)

Opt.getPrefix() + Opt.getName() + PluginArgs.first,

Opt.getKind(), 0, PluginArg);

(

*TestExt = dyn_cast_or_null<TestModuleFileExtension>(Ext.get()))

(Consumer, OPT_ftest_module_file_extension_EQ, TestExt->str());

(

&Plugin : Opts.

)

(

&ModuleFile : Opts.

)

(Consumer, OPT_fmodule_file, ModuleFile);

(Consumer, OPT_aux_target_feature, Feature);

StringRef HeaderUnit =

;

HeaderUnit =

;

HeaderUnit =

;

HeaderUnit =

;

StringRef Header = IsHeader ?

:

;

Lang =

;

Lang =

;

Lang =

;

);

Lang + HeaderUnit + Header +

+ Preprocessed);

(

&Input : Opts.

)

Consumer(Input.getFile());

(

Arg *A = Args.getLastArg(OPT_Action_Group)) {

OptSpecifier Opt = OptSpecifier(A->getOption().getID());

assert(ProgramAction &&

);

(Opt == OPT_ast_dump_all_EQ || Opt == OPT_ast_dump_EQ)) {

Val = llvm::StringSwitch<unsigned>(A->getValue())

.Default(std::numeric_limits<unsigned>::max());

(Val != std::numeric_limits<unsigned>::max())

Diags.

(diag::err_drv_invalid_value)

<< A->getAsString(Args) << A->getValue();

Args.hasArg(OPT_interface_stub_version_EQ)

? Args.getLastArgValue(OPT_interface_stub_version_EQ)

(ArgStr ==

||

ArgStr ==

|| ArgStr ==

||

ArgStr ==

) {

std::string ErrorMessage =

+ ArgStr.str() +

Diags.

(diag::err_drv_invalid_value)

<<

}

(!ArgStr.starts_with(

)) {

std::string ErrorMessage =

+ ArgStr.str() +

;

Diags.

(diag::err_drv_invalid_value)

<<

(!A->getSpelling().starts_with(

)) {

Arg *SavedAction =

;

(

Arg *AA :

Args.filtered(OPT_Action_Group, OPT_main_file_name)) {

(AA->getOption().matches(OPT_main_file_name)) {

SavedAction =

;

}

(!SavedAction) {

(!A->getOption().matches(OPT_ast_dump_EQ))

Diags.

(diag::err_fe_invalid_multiple_actions)

<< SavedAction->getSpelling() << A->getSpelling();

(

Arg* A = Args.getLastArg(OPT_plugin)) {

Opts.

.emplace_back(A->getValue(0));

(

*AA : Args.filtered(OPT_plugin_arg))

Opts.

[AA->getValue(0)].emplace_back(AA->getValue(1));

(

std::string &Arg :

Args.getAllArgValues(OPT_ftest_module_file_extension_EQ)) {

std::string BlockName;

MajorVersion;

MinorVersion;

std::string UserInfo;

MinorVersion, Hashed, UserInfo)) {

Diags.

(diag::err_test_module_file_extension_format) << Arg;

std::make_shared<TestModuleFileExtension>(

BlockName, MajorVersion, MinorVersion, Hashed, UserInfo));

(

Arg *A = Args.getLastArg(OPT_code_completion_at)) {

Diags.

(diag::err_drv_invalid_value)

<< A->getAsString(Args) << A->getValue();

Opts.

= Args.getAllArgValues(OPT_load);

Opts.

= Args.hasArg(OPT_ast_dump, OPT_ast_dump_EQ);

Opts.

= Args.hasArg(OPT_ast_dump_all, OPT_ast_dump_all_EQ);

(

*A : Args.filtered(OPT_fmodule_file)) {

StringRef Val = A->getValue();

(!Val.contains(

))

Diags.

(diag::err_drv_argument_only_allowed_with) <<

(Args.hasArg(OPT_fclangir) || Args.hasArg(OPT_emit_cir))

(Args.hasArg(OPT_aux_target_cpu))

Opts.

= std::string(Args.getLastArgValue(OPT_aux_target_cpu));

(Args.hasArg(OPT_aux_target_feature))

(

Arg *A = Args.getLastArg(OPT_x)) {

StringRef XValue = A->getValue();

Preprocessed = XValue.consume_back(

);

= XValue.consume_back(

);

XValue !=

&& XValue.consume_back(

);

(IsHeader || Preprocessed) {

(XValue.consume_back(

))

(XValue.consume_back(

))

(XValue.consume_back(

))

IsHeaderFile = IsHeader && !Preprocessed && !

&&

DashX = llvm::StringSwitch<InputKind>(XValue)

DashX = llvm::StringSwitch<InputKind>(XValue)

DashX = llvm::StringSwitch<InputKind>(XValue)

.Cases(

,

,

,

Diags.

(diag::err_drv_invalid_value)

<< A->getAsString(Args) << A->getValue();

IsHeaderFile =

;

}

(IsHeaderFile)

std::vector<std::string> Inputs = Args.getAllArgValues(OPT_INPUT);

Inputs.push_back(

);

Diags.

(diag::err_drv_header_unit_extra_inputs) << Inputs[1];

(

i = 0, e = Inputs.size(); i != e; ++i) {

StringRef(Inputs[i]).rsplit(

).second);

IsSystem =

;

Opts.

.emplace_back(std::move(Inputs[i]), IK, IsSystem);

Opts.

= DashX;

std::string ClangExecutable =

llvm::sys::fs::getMainExecutable(Argv0, MainAddr);

(Consumer, OPT_fmodules_ignore_macro, Macro.val());

std::optional<bool> IsFramework,

std::optional<bool> IgnoreSysRoot) {

llvm::is_contained(Groups, Entry.

) &&

(!IsFramework || (Entry.

== *IsFramework)) &&

(!IgnoreSysRoot || (Entry.

== *IgnoreSysRoot));

(; It < End && Matches(*It, {

}, std::nullopt,

);

OptSpecifier Opt = [It, Matches]() {

llvm_unreachable(

);

It->Group ==

? OPT_iwithprefix : OPT_iwithprefixbefore;

(; It < End && Matches(*It, {

},

,

); ++It)

(; It < End && Matches(*It, {

},

,

); ++It)

(; It < End && Matches(*It, {

},

, std::nullopt);

(Consumer, It->IgnoreSysRoot ? OPT_isystem : OPT_iwithsysroot,

(; It < End && Matches(*It, {

},

,

); ++It)

(Consumer, OPT_iframeworkwithsysroot, It->Path);

(Consumer, OPT_cxx_isystem, It->Path);

(Consumer, OPT_objc_isystem, It->Path);

(Consumer, OPT_objcxx_isystem, It->Path);

? OPT_internal_isystem

: OPT_internal_externc_isystem;

assert(It == End &&

);

OptSpecifier Opt =

.IsSystemHeader ? OPT_system_header_prefix

: OPT_no_system_header_prefix;

std::string &WorkingDir) {

(

Arg *A = Args.getLastArg(OPT_stdlib_EQ))

Opts.

= (strcmp(A->getValue(),

) == 0);

(!(

.empty() || llvm::sys::path::is_absolute(

))) {

(WorkingDir.empty())

llvm::sys::fs::make_absolute(

);

llvm::sys::fs::make_absolute(WorkingDir,

);

llvm::sys::path::remove_dots(

);

(

*A : Args.filtered(OPT_fmodule_file)) {

StringRef Val = A->getValue();

(Val.contains(

)) {

Split = Val.split(

);

std::string(Split.first), std::string(Split.second));

(

*A : Args.filtered(OPT_fprebuilt_module_path))

(

*A : Args.filtered(OPT_fmodules_ignore_macro)) {

StringRef MacroDef = A->getValue();

llvm::CachedHashString(MacroDef.split(

).first));

IsSysrootSpecified =

Args.hasArg(OPT__sysroot_EQ) || Args.hasArg(OPT_isysroot);

PrefixHeaderPath = [IsSysrootSpecified,

&Opts](

llvm::opt::Arg *A,

IsFramework =

) -> std::string {

assert(A->getNumValues() &&

);

(IsSysrootSpecified && !IsFramework && A->getValue()[0] ==

) {

llvm::sys::path::append(Buffer, Opts.

,

llvm::StringRef(A->getValue()).substr(1));

std::string(Buffer);

A->getValue();

(

*A : Args.filtered(OPT_I, OPT_F)) {

IsFramework = A->getOption().matches(OPT_F);

IsFramework,

);

StringRef Prefix =

;

(

*A :

Args.filtered(OPT_iprefix, OPT_iwithprefix, OPT_iwithprefixbefore)) {

(A->getOption().matches(OPT_iprefix))

Prefix = A->getValue();

(A->getOption().matches(OPT_iwithprefix))

(

*A : Args.filtered(OPT_idirafter))

(

*A : Args.filtered(OPT_iquote))

(

*A : Args.filtered(OPT_isystem, OPT_iwithsysroot)) {

(A->getOption().matches(OPT_iwithsysroot)) {

(

*A : Args.filtered(OPT_iframework))

(

*A : Args.filtered(OPT_iframeworkwithsysroot))

(

*A : Args.filtered(OPT_c_isystem))

(

*A : Args.filtered(OPT_cxx_isystem))

(

*A : Args.filtered(OPT_objc_isystem))

(

*A : Args.filtered(OPT_objcxx_isystem))

(

*A :

Args.filtered(OPT_internal_isystem, OPT_internal_externc_isystem)) {

(A->getOption().matches(OPT_internal_externc_isystem))

Opts.

(A->getValue(), Group,

,

);

(

*A :

Args.filtered(OPT_system_header_prefix, OPT_no_system_header_prefix))

A->getValue(), A->getOption().matches(OPT_system_header_prefix));

(

*A : Args.filtered(OPT_ivfsoverlay, OPT_vfsoverlay))

(Consumer, OPT_fapinotes_swift_version,

(

Arg *A = Args.getLastArg(OPT_fapinotes_swift_version)) {

diags.

(diag::err_drv_invalid_value)

<< A->getAsString(Args) << A->getValue();

(

Arg *A : Args.filtered(OPT_iapinotes_modules))

(Opts.PointerAuthIntrinsics)

(Opts.PointerAuthCalls)

(Opts.PointerAuthReturns)

(Opts.PointerAuthIndirectGotos)

(Consumer, OPT_fptrauth_indirect_gotos);

(Opts.PointerAuthAuthTraps)

(Opts.PointerAuthVTPtrAddressDiscrimination)

(Consumer, OPT_fptrauth_vtable_pointer_address_discrimination);

(Opts.PointerAuthVTPtrTypeDiscrimination)

(Consumer, OPT_fptrauth_vtable_pointer_type_discrimination);

(Opts.PointerAuthTypeInfoVTPtrDiscrimination)

(Consumer, OPT_fptrauth_type_info_vtable_pointer_discrimination);

(Opts.PointerAuthFunctionTypeDiscrimination)

(Consumer, OPT_fptrauth_function_pointer_type_discrimination);

(Opts.PointerAuthInitFini)

(Opts.PointerAuthInitFiniAddressDiscrimination)

(Consumer, OPT_fptrauth_init_fini_address_discrimination);

(Opts.PointerAuthELFGOT)

(Opts.AArch64JumpTableHardening)

(Consumer, OPT_faarch64_jump_table_hardening);

Opts.PointerAuthIntrinsics = Args.hasArg(OPT_fptrauth_intrinsics);

Opts.PointerAuthCalls = Args.hasArg(OPT_fptrauth_calls);

Opts.PointerAuthReturns = Args.hasArg(OPT_fptrauth_returns);

Opts.PointerAuthIndirectGotos = Args.hasArg(OPT_fptrauth_indirect_gotos);

Opts.PointerAuthAuthTraps = Args.hasArg(OPT_fptrauth_auth_traps);

Opts.PointerAuthVTPtrAddressDiscrimination =

Args.hasArg(OPT_fptrauth_vtable_pointer_address_discrimination);

Opts.PointerAuthVTPtrTypeDiscrimination =

Args.hasArg(OPT_fptrauth_vtable_pointer_type_discrimination);

Opts.PointerAuthTypeInfoVTPtrDiscrimination =

Args.hasArg(OPT_fptrauth_type_info_vtable_pointer_discrimination);

Opts.PointerAuthFunctionTypeDiscrimination =

Args.hasArg(OPT_fptrauth_function_pointer_type_discrimination);

Opts.PointerAuthInitFini = Args.hasArg(OPT_fptrauth_init_fini);

Opts.PointerAuthInitFiniAddressDiscrimination =

Args.hasArg(OPT_fptrauth_init_fini_address_discrimination);

Opts.PointerAuthELFGOT = Args.hasArg(OPT_fptrauth_elf_got);

Opts.AArch64JumpTableHardening =

Args.hasArg(OPT_faarch64_jump_table_hardening);

llvm_unreachable(

);

llvm_unreachable(

);

;

;

;

llvm_unreachable(

);

CompilerInvocationBase::GenerateLangArgs(

&Opts,

llvm::Triple &

,

(Opts.ObjCAutoRefCount)

(Opts.PICLevel != 0)

(Consumer, OPT_pic_level, Twine(Opts.PICLevel));

(Consumer, OPT_fsanitize_EQ, Sanitizer);

OptSpecifier StdOpt;

LangStandard::lang_opencl10:

LangStandard::lang_opencl11:

LangStandard::lang_opencl12:

LangStandard::lang_opencl20:

LangStandard::lang_opencl30:

LangStandard::lang_openclcpp10:

LangStandard::lang_openclcpp2021:

StdOpt = OPT_cl_std_EQ;

StdOpt = OPT_std_EQ;

(Opts.IncludeDefaultHeader)

(Consumer, OPT_finclude_default_header);

(Opts.DeclareOpenCLBuiltins)

(Consumer, OPT_fdeclare_opencl_builtins);

(Opts.ObjCAutoRefCount == 1)

(Opts.ObjCWeakRuntime)

(Consumer, OPT_fobjc_runtime_has_weak);

(Opts.ObjCSubscriptingLegacyRuntime)

(Consumer, OPT_fobjc_subscripting_legacy_runtime);

(Opts.GNUCVersion != 0) {

Major = Opts.GNUCVersion / 100 / 100;

Minor = (Opts.GNUCVersion / 100) % 100;

Patch = Opts.GNUCVersion % 100;

Twine(Major) +

+ Twine(Minor) +

+ Twine(Patch));

(Opts.IgnoreXCOFFVisibility)

(Consumer, OPT_mignore_xcoff_visibility);

(Opts.PointerOverflowDefined)

(Opts.MSCompatibilityVersion != 0) {

Major = Opts.MSCompatibilityVersion / 10000000;

Minor = (Opts.MSCompatibilityVersion / 100000) % 100;

Subminor = Opts.MSCompatibilityVersion % 100000;

(Consumer, OPT_fms_compatibility_version,

Twine(Major) +

+ Twine(Minor) +

+ Twine(Subminor));

((!Opts.GNUMode && !Opts.MSVCCompat && !Opts.CPlusPlus17 && !Opts.C23) ||

(!Opts.Trigraphs)

(

.isOSzOS() && !Opts.ZOSExt)

(Opts.ZOSExt)

(Opts.Blocks && !(Opts.OpenCL && Opts.OpenCLVersion == 200))

(Opts.ConvergentFunctions)

(Consumer, OPT_fconvergent_functions);

(Consumer, OPT_fno_convergent_functions);

(Opts.NoBuiltin && !Opts.Freestanding)

(!Opts.NoBuiltin)

(Opts.LongDoubleSize == 128)

(Opts.LongDoubleSize == 64)

(Opts.LongDoubleSize == 80)

(Opts.OpenMP && !Opts.OpenMPSimd) {

(Opts.OpenMP != 51)

(Consumer, OPT_fopenmp_version_EQ, Twine(Opts.OpenMP));

(!Opts.OpenMPUseTLS)

(Opts.OpenMPIsTargetDevice)

(Consumer, OPT_fopenmp_is_target_device);

(Opts.OpenMPIRBuilder)

(Consumer, OPT_fopenmp_enable_irbuilder);

(Opts.OpenMPSimd) {

(Opts.OpenMP != 51)

(Consumer, OPT_fopenmp_version_EQ, Twine(Opts.OpenMP));

(Opts.OpenMPThreadSubscription)

(Consumer, OPT_fopenmp_assume_threads_oversubscription);

(Opts.OpenMPTeamSubscription)

(Consumer, OPT_fopenmp_assume_teams_oversubscription);

(Opts.OpenMPTargetDebug != 0)

(Consumer, OPT_fopenmp_target_debug_EQ,

Twine(Opts.OpenMPTargetDebug));

(Opts.OpenMPCUDANumSMs != 0)

(Consumer, OPT_fopenmp_cuda_number_of_sm_EQ,

Twine(Opts.OpenMPCUDANumSMs));

(Opts.OpenMPCUDABlocksPerSM != 0)

(Consumer, OPT_fopenmp_cuda_blocks_per_sm_EQ,

Twine(Opts.OpenMPCUDABlocksPerSM));

(Opts.OpenMPCUDAReductionBufNum != 1024)

(Consumer, OPT_fopenmp_cuda_teams_reduction_recs_num_EQ,

Twine(Opts.OpenMPCUDAReductionBufNum));

std::string Targets;

llvm::raw_string_ostream OS(Targets);

[&OS](

llvm::Triple &

) { OS << T.str(); },

);

(Consumer, OPT_fopenmp_targets_EQ, Targets);

(Opts.OpenMPCUDAMode)

(Consumer, OPT_openacc_macro_override,

(Consumer, OPT_ffp_contract,

);

(Consumer, OPT_ffp_contract,

);

(Consumer, OPT_fsanitize_EQ, Sanitizer);

(Consumer, OPT_fsanitize_ignorelist_EQ, F);

(Opts.getClangABICompat()) {

(Consumer, OPT_fclang_abi_compat_EQ,

);

(Consumer, OPT_fclang_abi_compat_EQ,

);

(Consumer, OPT_fclang_abi_compat_EQ,

);

(Consumer, OPT_fclang_abi_compat_EQ,

);

(Consumer, OPT_fclang_abi_compat_EQ,

);

(Consumer, OPT_fclang_abi_compat_EQ,

);

(Consumer, OPT_fclang_abi_compat_EQ,

);

(Consumer, OPT_fclang_abi_compat_EQ,

);

(Consumer, OPT_fclang_abi_compat_EQ,

);

(Consumer, OPT_fclang_abi_compat_EQ,

);

(Consumer, OPT_fclang_abi_compat_EQ,

);

(Consumer, OPT_fclang_abi_compat_EQ,

);

(Opts.getSignReturnAddressScope() ==

(Consumer, OPT_msign_return_address_EQ,

);

(Opts.getSignReturnAddressScope() ==

(Consumer, OPT_msign_return_address_EQ,

);

(Opts.getSignReturnAddressKey() ==

(Consumer, OPT_msign_return_address_key_EQ,

);

(Opts.RelativeCXXABIVTables)

(Consumer, OPT_fexperimental_relative_cxx_abi_vtables);

(Consumer, OPT_fno_experimental_relative_cxx_abi_vtables);

(Consumer, OPT_fno_file_reproducible);

(Consumer, OPT_fmacro_prefix_map_EQ, MP.first +

+ MP.second);

CompilerInvocation::ParseLangArgs(

&Opts, ArgList &Args,

std::vector<std::string> &Includes,

(Args.hasArg(OPT_fobjc_arc))

Opts.ObjCAutoRefCount = 1;

Opts.PIE = Args.hasArg(OPT_pic_is_pie);

(

Arg *A = Args.getLastArg(OPT_std_EQ)) {

Diags.

(diag::err_drv_invalid_value)

<< A->getAsString(Args) << A->getValue();

(

KindValue = 0;

= Diags.

(diag::note_drv_use_standard);

<<

.getName() <<

.getDescription();

NumAliases = 0;

Diags.

(diag::err_drv_argument_not_allowed_with)

(

Arg *A = Args.getLastArg(OPT_cl_std_EQ)) {

= llvm::StringSwitch<LangStandard::Kind>(A->getValue())

.Cases(

,

, LangStandard::lang_opencl10)

.Cases(

,

, LangStandard::lang_opencl10)

.Cases(

,

, LangStandard::lang_opencl11)

.Cases(

,

, LangStandard::lang_opencl12)

.Cases(

,

, LangStandard::lang_opencl20)

.Cases(

,

, LangStandard::lang_opencl30)

.Cases(

,

, LangStandard::lang_openclcpp10)

.Cases(

,

, LangStandard::lang_openclcpp10)

.Cases(

,

, LangStandard::lang_openclcpp2021)

Diags.

(diag::err_drv_invalid_value)

<< A->getAsString(Args) << A->getValue();

LangStd = OpenCLLangStd;

Opts.IncludeDefaultHeader = Args.hasArg(OPT_finclude_default_header);

Opts.DeclareOpenCLBuiltins = Args.hasArg(OPT_fdeclare_opencl_builtins);

(

Arg *A = Args.getLastArg(OPT_fcf_protection_EQ)) {

StringRef Name = A->getValue();

(Name ==

|| Name ==

) {

Opts.CFProtectionBranch = 1;

(Opts.CFProtectionBranch) {

(

Arg *A = Args.getLastArg(OPT_mcf_branch_label_scheme_EQ)) {

llvm::StringSwitch<CFBranchLabelSchemeKind>(A->getValue())

Opts.setCFBranchLabelScheme(Scheme);

((Args.hasArg(OPT_fsycl_is_device) || Args.hasArg(OPT_fsycl_is_host)) &&

!Args.hasArg(OPT_sycl_std_EQ)) {

(Arg *arg = Args.getLastArg(OPT_fobjc_runtime_EQ)) {

StringRef value =

->getValue();

Diags.

(diag::err_drv_unknown_objc_runtime) << value;

(Args.hasArg(OPT_fobjc_gc_only))

(Args.hasArg(OPT_fobjc_gc))

(Args.hasArg(OPT_fobjc_arc)) {

Opts.ObjCAutoRefCount = 1;

Diags.

(diag::err_arc_unsupported_on_runtime);

(Args.hasArg(OPT_fobjc_runtime_has_weak))

Opts.ObjCWeakRuntime = 1;

(

weakArg = Args.getLastArg(OPT_fobjc_weak, OPT_fno_objc_weak)) {

(!weakArg->getOption().matches(OPT_fobjc_weak)) {

assert(!Opts.ObjCWeak);

Diags.

(diag::err_objc_weak_with_gc);

}

(!Opts.ObjCWeakRuntime) {

Diags.

(diag::err_objc_weak_unsupported);

}

(Opts.ObjCAutoRefCount) {

Opts.ObjCWeak = Opts.ObjCWeakRuntime;

(Args.hasArg(OPT_fobjc_subscripting_legacy_runtime))

Opts.ObjCSubscriptingLegacyRuntime =

(Arg *A = Args.getLastArg(options::OPT_fgnuc_version_EQ)) {

VersionTuple GNUCVer;

= GNUCVer.tryParse(A->getValue());

Major = GNUCVer.getMajor();

Minor = GNUCVer.getMinor().value_or(0);

Patch = GNUCVer.getSubminor().value_or(0);

(

|| GNUCVer.getBuild() || Minor >= 100 || Patch >= 100) {

Diags.

(diag::err_drv_invalid_value)

<< A->getAsString(Args) << A->getValue();

Opts.GNUCVersion = Major * 100 * 100 + Minor * 100 + Patch;

(

.isOSAIX() && (Args.hasArg(OPT_mignore_xcoff_visibility)))

Opts.IgnoreXCOFFVisibility = 1;

(Args.hasArg(OPT_ftrapv)) {

std::string(Args.getLastArgValue(OPT_ftrapv_handler));

(Args.hasArg(OPT_fwrapv))

(Args.hasArg(OPT_fwrapv_pointer))

Opts.PointerOverflowDefined =

;

Opts.MSCompatibilityVersion = 0;

(

Arg *A = Args.getLastArg(OPT_fms_compatibility_version)) {

(VT.tryParse(A->getValue()))

Diags.

(diag::err_drv_invalid_value) << A->getAsString(Args)

Opts.MSCompatibilityVersion = VT.getMajor() * 10000000 +

VT.getMinor().value_or(0) * 100000 +

VT.getSubminor().value_or(0);

(!Opts.GNUMode && !Opts.MSVCCompat && !Opts.CPlusPlus17 && !Opts.C23) ||

Args.hasFlag(OPT_ftrigraphs, OPT_fno_trigraphs, Opts.Trigraphs);

Args.hasFlag(OPT_fzos_extensions, OPT_fno_zos_extensions,

.isOSzOS());

Opts.Blocks = Args.hasArg(OPT_fblocks) || (Opts.OpenCL

&& Opts.OpenCLVersion == 200);

HasConvergentOperations = Opts.OpenMPIsTargetDevice || Opts.OpenCL ||

Opts.CUDAIsDevice || Opts.SYCLIsDevice ||

Opts.HLSL ||

.isAMDGPU() ||

.isNVPTX();

Opts.ConvergentFunctions =

Args.hasFlag(OPT_fconvergent_functions, OPT_fno_convergent_functions,

HasConvergentOperations);

Opts.NoBuiltin = Args.hasArg(OPT_fno_builtin) || Opts.Freestanding;

(!Opts.NoBuiltin)

(Arg *A = Args.getLastArg(options::OPT_LongDouble_Group)) {

(A->getOption().matches(options::OPT_mlong_double_64))

Opts.LongDoubleSize = 64;

(A->getOption().matches(options::OPT_mlong_double_80))

Opts.LongDoubleSize = 80;

(A->getOption().matches(options::OPT_mlong_double_128))

Opts.LongDoubleSize = 128;

Opts.LongDoubleSize = 0;

(Opts.FastRelaxedMath || Opts.CLUnsafeMath)

(Arg *A = Args.getLastArg(OPT_mrtd)) {

Diags.

(diag::err_drv_argument_not_allowed_with)

<< A->getSpelling() <<

;

(

.getArch()) {

llvm::Triple::x86:

llvm::Triple::m68k:

Diags.

(diag::err_drv_argument_not_allowed_with)

<< A->getSpelling() <<

.getTriple();

Opts.OpenMP = Args.hasArg(OPT_fopenmp) ? 51 : 0;

IsSimdSpecified =

Args.hasFlag(options::OPT_fopenmp_simd, options::OPT_fno_openmp_simd,

Opts.OpenMPSimd = !Opts.OpenMP && IsSimdSpecified;

Opts.OpenMP && !Args.hasArg(options::OPT_fnoopenmp_use_tls);

Opts.OpenMPIsTargetDevice =

Opts.OpenMP && Args.hasArg(options::OPT_fopenmp_is_target_device);

Opts.OpenMPIRBuilder =

Opts.OpenMP && Args.hasArg(options::OPT_fopenmp_enable_irbuilder);

IsTargetSpecified =

Opts.OpenMPIsTargetDevice || Args.hasArg(options::OPT_fopenmp_targets_EQ);

(Opts.OpenMP || Opts.OpenMPSimd) {

Args, OPT_fopenmp_version_EQ,

(IsSimdSpecified || IsTargetSpecified) ? 51 : Opts.OpenMP, Diags))

Opts.OpenMP = Version;

(!Opts.OpenMPIsTargetDevice) {

(

.getArch()) {

llvm::Triple::nvptx:

llvm::Triple::nvptx64:

Diags.

(diag::err_drv_omp_host_target_not_supported) <<

.str();

((Opts.OpenMPIsTargetDevice && (

.isNVPTX() ||

.isAMDGCN())) ||

Opts.OpenCLCPlusPlus) {

Opts.Exceptions = 0;

Opts.CXXExceptions = 0;

(Opts.OpenMPIsTargetDevice &&

.isNVPTX()) {

Opts.OpenMPCUDANumSMs =

Opts.OpenMPCUDANumSMs, Diags);

Opts.OpenMPCUDABlocksPerSM =

Opts.OpenMPCUDABlocksPerSM, Diags);

Args, options::OPT_fopenmp_cuda_teams_reduction_recs_num_EQ,

Opts.OpenMPCUDAReductionBufNum, Diags);

(Opts.OpenMPIsTargetDevice && (Args.hasArg(OPT_fopenmp_target_debug) ||

Args.hasArg(OPT_fopenmp_target_debug_EQ))) {

Args, OPT_fopenmp_target_debug_EQ, Opts.OpenMPTargetDebug, Diags);

(!Opts.OpenMPTargetDebug && Args.hasArg(OPT_fopenmp_target_debug))

Opts.OpenMPTargetDebug = 1;

(Opts.OpenMPIsTargetDevice) {

(Args.hasArg(OPT_fopenmp_assume_teams_oversubscription))

Opts.OpenMPTeamSubscription =

;

(Args.hasArg(OPT_fopenmp_assume_threads_oversubscription))

Opts.OpenMPThreadSubscription =

;

(Arg *A = Args.getLastArg(options::OPT_fopenmp_targets_EQ)) {

ArchPtrSize { Arch16Bit, Arch32Bit, Arch64Bit };

getArchPtrSize = [](

llvm::Triple &

) {

(

.isArch16Bit())

(

.isArch32Bit())

assert(

.isArch64Bit() &&

);

(

i = 0; i < A->getNumValues(); ++i) {

llvm::Triple TT(A->getValue(i));

(TT.getArch() == llvm::Triple::UnknownArch ||

!(TT.getArch() == llvm::Triple::aarch64 || TT.isPPC() ||

TT.getArch() == llvm::Triple::spirv64 ||

TT.getArch() == llvm::Triple::systemz ||

TT.getArch() == llvm::Triple::loongarch64 ||

TT.getArch() == llvm::Triple::nvptx ||

TT.getArch() == llvm::Triple::nvptx64 ||

TT.getArch() == llvm::Triple::amdgcn ||

TT.getArch() == llvm::Triple::x86 ||

TT.getArch() == llvm::Triple::x86_64))

Diags.

(diag::err_drv_invalid_omp_target) << A->getValue(i);

(getArchPtrSize(

) != getArchPtrSize(TT))

Diags.

(diag::err_drv_incompatible_omp_arch)

<< A->getValue(i) <<

.str();

(Arg *A = Args.getLastArg(options::OPT_fopenmp_host_ir_file_path)) {

Diags.

(diag::err_drv_omp_host_ir_file_not_found)

Opts.OpenMPCUDAMode = Opts.OpenMPIsTargetDevice &&

(

.isNVPTX() ||

.isAMDGCN()) &&

Args.hasArg(options::OPT_fopenmp_cuda_mode);

(Args.hasArg(options::OPT_fopenacc)) {

Opts.OpenACC =

;

(Arg *A = Args.getLastArg(options::OPT_openacc_macro_override))

Opts.Optimize = Opt != 0;

Opts.OptimizeSize = OptSize != 0;

Opts.NoInlineDefine = !Opts.Optimize;

(Arg *InlineArg = Args.getLastArg(

options::OPT_finline_functions, options::OPT_finline_hint_functions,

options::OPT_fno_inline_functions, options::OPT_fno_inline))

(InlineArg->getOption().matches(options::OPT_fno_inline))

Opts.NoInlineDefine =

;

(Arg *A = Args.getLastArg(OPT_ffp_contract)) {

StringRef Val = A->getValue();

(Val ==

)

(Val ==

)

(Val ==

)

Diags.

(diag::err_drv_invalid_value) << A->getAsString(Args) << Val;

Args.getLastArg(OPT_fsanitize_undefined_ignore_overflow_pattern_EQ)) {

(

i = 0, n = A->getNumValues(); i != n; ++i) {

llvm::StringSwitch<unsigned>(A->getValue(i))

.Case(

,

.Case(

,

.Case(

,

Opts.

= Args.getAllArgValues(OPT_fsanitize_ignorelist_EQ);

std::vector<std::string> systemIgnorelists =

Args.getAllArgValues(OPT_fsanitize_system_ignorelist_EQ);

systemIgnorelists.begin(),

systemIgnorelists.end());

(Arg *A = Args.getLastArg(OPT_fclang_abi_compat_EQ)) {

StringRef Ver = A->getValue();

std::pair<StringRef, StringRef> VerParts = Ver.split(

);

Major, Minor = 0;

(!VerParts.first.starts_with(

) &&

!VerParts.first.getAsInteger(10, Major) && 3 <= Major &&

Major <= MAX_CLANG_ABI_COMPAT_VERSION &&

? VerParts.second.size() == 1 &&

!VerParts.second.getAsInteger(10, Minor)

: VerParts.first.size() == Ver.size() || VerParts.second ==

)) {

(Major == 3 && Minor <= 8)

(Major <= 4)

(Major <= 6)

(Major <= 7)

(Major <= 9)

(Major <= 11)

(Major <= 12)

(Major <= 14)

(Major <= 15)

(Major <= 17)

(Major <= 18)

(Major <= 19)

}

(Ver !=

) {

Diags.

(diag::err_drv_invalid_value)

<< A->getAsString(Args) << A->getValue();

(Arg *A = Args.getLastArg(OPT_msign_return_address_EQ)) {

StringRef SignScope = A->getValue();

(SignScope.equals_insensitive(

))

Opts.setSignReturnAddressScope(

(SignScope.equals_insensitive(

))

Opts.setSignReturnAddressScope(

(SignScope.equals_insensitive(

))

Opts.setSignReturnAddressScope(

Diags.

(diag::err_drv_invalid_value)

<< A->getAsString(Args) << SignScope;

(Arg *A = Args.getLastArg(OPT_msign_return_address_key_EQ)) {

StringRef SignKey = A->getValue();

(!SignScope.empty() && !SignKey.empty()) {

(SignKey ==

)

Opts.setSignReturnAddressKey(

(SignKey ==

)

Opts.setSignReturnAddressKey(

Diags.

(diag::err_drv_invalid_value)

<< A->getAsString(Args) << SignKey;

StringRef

= Args.getLastArgValue(OPT_fcxx_abi_EQ);

Diags.

(diag::err_unsupported_cxx_abi) <<

<<

.str();

Opts.RelativeCXXABIVTables =

Args.hasFlag(options::OPT_fexperimental_relative_cxx_abi_vtables,

options::OPT_fno_experimental_relative_cxx_abi_vtables,

HasRTTI = !Args.hasArg(options::OPT_fno_rtti);

Opts.OmitVTableRTTI =

Args.hasFlag(options::OPT_fexperimental_omit_vtable_rtti,

options::OPT_fno_experimental_omit_vtable_rtti,

);

(Opts.OmitVTableRTTI && HasRTTI)

Diags.

(diag::err_drv_using_omit_rtti_component_without_no_rtti);

(

&A : Args.getAllArgValues(OPT_fmacro_prefix_map_EQ)) {

= StringRef(A).split(

);

{std::string(

.first), std::string(

.second)});

!Args.getLastArg(OPT_fno_file_reproducible) &&

(Args.getLastArg(OPT_ffile_compilation_dir_EQ) ||

Args.getLastArg(OPT_fmacro_prefix_map_EQ) ||

Args.getLastArg(OPT_ffile_reproducible));

(Arg *A = Args.getLastArg(options::OPT_mvscale_min_EQ)) {

(StringRef(A->getValue()).getAsInteger(10, VScaleMin) || VScaleMin == 0)

Diags.

(diag::err_cc1_unbounded_vscale_min);

(

Arg *A = Args.getLastArg(OPT_frandomize_layout_seed_file_EQ)) {

std::ifstream SeedFile(A->getValue(0));

(!SeedFile.is_open())

Diags.

(diag::err_drv_cannot_open_randomize_layout_seed_file)

(

Arg *A = Args.getLastArg(OPT_frandomize_layout_seed_EQ))

(

.isDXIL() ||

.isSPIRVLogical()) {

{ OS, Environment };

ExpectedOS =

.isSPIRVLogical() ? VulkanEnv : ShaderModel;

(

.getOSName().empty()) {

Diags.

(diag::err_drv_hlsl_bad_shader_required_in_target)

<< ExpectedOS << OS <<

.str();

}

(

.getEnvironmentName().empty()) {

Diags.

(diag::err_drv_hlsl_bad_shader_required_in_target)

}

(!

.isShaderStageEnvironment()) {

Diags.

(diag::err_drv_hlsl_bad_shader_unsupported)

(!

.isShaderModelOS() ||

.getOSVersion() == VersionTuple(0)) {

Diags.

(diag::err_drv_hlsl_bad_shader_unsupported)

<< ShaderModel <<

.getOSName() <<

.str();

(Args.getLastArg(OPT_fnative_half_type)) {

(!(Opts.

>= LangStandard::lang_hlsl2018 &&

.getOSVersion() >= VersionTuple(6, 2)))

Diags.

(diag::err_drv_hlsl_16bit_types_unsupported)

<<

<<

<<

.getName()

<<

.getOSVersion().getAsString();

}

(

.isSPIRVLogical()) {

(!

.isVulkanOS() ||

.getVulkanVersion() == VersionTuple(0)) {

Diags.

(diag::err_drv_hlsl_bad_shader_unsupported)

<< VulkanEnv <<

.getOSName() <<

.str();

(Args.getLastArg(OPT_fnative_half_type)) {

(!(Opts.

>= LangStandard::lang_hlsl2018))

Diags.

(diag::err_drv_hlsl_16bit_types_unsupported)

<<

<<

<<

.getName();

llvm_unreachable(

);

Diags.

(diag::err_drv_hlsl_unsupported_target) <<

.str();

(Opts.

< LangStandard::lang_hlsl202x) {

Diags.

(diag::warn_hlsl_langstd_minimal)

llvm_unreachable(

);

(Consumer, OPT_pch_through_hdrstop_use);

(Consumer, OPT_error_on_deserialized_pch_decl,

);

(

&M : Opts.

) {

(M.first ==

&& !M.second &&

!CodeGenOpts.CFProtectionReturn && CodeGenOpts.CFProtectionBranch)

(M.first ==

&& !M.second && CodeGenOpts.CFProtectionReturn &&

!CodeGenOpts.CFProtectionBranch)

(M.first ==

&& !M.second && CodeGenOpts.CFProtectionReturn &&

CodeGenOpts.CFProtectionBranch)

(Consumer, M.second ? OPT_U : OPT_D, M.first);

(

&I : Opts.

) {

(LangOpts.OpenCL && LangOpts.IncludeDefaultHeader &&

((LangOpts.DeclareOpenCLBuiltins && I ==

) ||

I ==

))

(LangOpts.HLSL && I ==

)

(Consumer, OPT_remap_file, RF.first +

+ RF.second);

(Consumer, OPT_fdefine_target_os_macros);

(Consumer, OPT_embed_dir_EQ, EmbedEntry);

Opts.

= Args.hasArg(OPT_pch_through_hdrstop_create) ||

Args.hasArg(OPT_pch_through_hdrstop_use);

(

*A : Args.filtered(OPT_error_on_deserialized_pch_decl))

(

Arg *A = Args.getLastArg(OPT_preamble_bytes_EQ)) {

StringRef

(A->getValue());

Comma =

.find(

);

EndOfLine = 0;

(Comma == StringRef::npos ||

.substr(0, Comma).getAsInteger(10, Bytes) ||

.substr(Comma + 1).getAsInteger(10, EndOfLine))

Diags.

(diag::err_drv_preamble_format);

(

Arg *A = Args.getLastArg(OPT_fcf_protection_EQ)) {

StringRef Name = A->getValue();

(Name ==

)

(Name ==

)

(Name ==

)

(

*A : Args.filtered(OPT_D, OPT_U)) {

(A->getOption().matches(OPT_D))

(

*A : Args.filtered(OPT_include))

Opts.

.emplace_back(A->getValue());

(

*A : Args.filtered(OPT_chain_include))

(

*A : Args.filtered(OPT_remap_file)) {

std::pair<StringRef, StringRef> Split = StringRef(A->getValue()).split(

);

(Split.second.empty()) {

Diags.

(diag::err_drv_invalid_remap_file) << A->getAsString(Args);

(

Arg *A = Args.getLastArg(OPT_source_date_epoch)) {

StringRef Epoch = A->getValue();

uint64_t MaxTimestamp =

std::min<uint64_t>(std::numeric_limits<time_t>::max(), 253402300799);

(Epoch.getAsInteger(10,

) ||

> MaxTimestamp) {

Diags.

(diag::err_fe_invalid_source_date_epoch)

<< Epoch << MaxTimestamp;

(

*A : Args.filtered(OPT_embed_dir_EQ)) {

StringRef Val = A->getValue();

Args.hasFlag(OPT_fdefine_target_os_macros,

Opts.

= Args.hasArg(OPT_dM) || Args.hasArg(OPT_dD);

(Consumer, OPT_darwin_target_variant_sdk_version_EQ,

(Arg *A = Args.getLastArg(options::OPT_target_sdk_version_EQ)) {

llvm::VersionTuple Version;

(Version.tryParse(A->getValue()))

Diags.

(diag::err_drv_invalid_value)

<< A->getAsString(Args) << A->getValue();

Args.getLastArg(options::OPT_darwin_target_variant_sdk_version_EQ)) {

llvm::VersionTuple Version;

(Version.tryParse(A->getValue()))

Diags.

(diag::err_drv_invalid_value)

<< A->getAsString(Args) << A->getValue();

CompilerInvocation::CreateFromArgsImpl(

MissingArgIndex, MissingArgCount;

InputArgList Args = Opts.ParseArgs(CommandLineArgs, MissingArgIndex,

MissingArgCount, VisibilityMask);

(MissingArgCount)

Diags.

(diag::err_drv_missing_argument)

<< Args.getArgString(MissingArgIndex) << MissingArgCount;

(

*A : Args.filtered(OPT_UNKNOWN)) {

ArgString = A->getAsString(Args);

std::string Nearest;

(Opts.findNearest(ArgString, Nearest, VisibilityMask) > 1)

Diags.

(diag::err_drv_unknown_argument) << ArgString;

Diags.

(diag::err_drv_unknown_argument_with_suggestion)

<< ArgString << Nearest;

(

==

&&

(

.OpenMPIsTargetDevice)

!

.Sanitize.has(SanitizerKind::Address) &&

!

.Sanitize.has(SanitizerKind::KernelAddress) &&

!

.Sanitize.has(SanitizerKind::Memory) &&

!

.Sanitize.has(SanitizerKind::KernelMemory);

Diags.

(diag::err_fe_dependency_file_requires_MT);

Diags.

(diag::warn_drv_fine_grained_bitfield_accesses_ignored);

Diags, llvm::vfs::getRealFileSystem());

*Argv0) {

CreateFromArgsImpl(Invocation, CommandLineArgs, Diags, Argv0);

Args.push_back(

);

Invocation, DummyInvocation, CommandLineArgs, Diags, Argv0);

llvm::HashBuilder<llvm::MD5, llvm::endianness::native> HBuilder;