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

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

clang: lib/Parse/ParseOpenMP.cpp Source File

;

llvm::omp;

OpenMPDirectiveKindEx {

OMPD_cancellation = llvm::omp::Directive_enumSize + 1,

OMPD_distribute_parallel,

OMPD_teams_distribute_parallel,

OMPD_target_teams_distribute_parallel,

OpenMPDirectiveKindExWrapper {

(OpenMPDirectiveKindExWrapper

)

{

(OpenMPDirectiveKindExWrapper

)

{

DeclDirectiveListParserHelper final {

Res =

->getActions().OpenMP().ActOnOpenMPIdExpression(

->getCurScope(), SS, NameInfo, Kind);

Identifiers.push_back(Res.

());

OpenMPDirectiveKindExWrapper DKind = getOpenMPDirectiveKind(S);

(DKind != OMPD_unknown)

llvm::StringSwitch<OpenMPDirectiveKindExWrapper>(S)

.Case(

, OMPD_cancellation)

.Case(

, OMPD_data)

.Case(

, OMPD_declare)

.Case(

, OMPD_end)

.Case(

, OMPD_enter)

.Case(

, OMPD_exit)

.Case(

, OMPD_point)

.Case(

, OMPD_reduction)

.Case(

, OMPD_update)

.Case(

, OMPD_mapper)

.Case(

, OMPD_variant)

.Case(

, OMPD_begin)

.Default(OMPD_unknown);

OpenMPDirectiveKindExWrapper F[][3] = {

{OMPD_begin, OMPD_declare, OMPD_begin_declare},

{OMPD_begin, OMPD_assumes, OMPD_begin_assumes},

{OMPD_end, OMPD_declare, OMPD_end_declare},

{OMPD_end, OMPD_assumes, OMPD_end_assumes},

{OMPD_cancellation, OMPD_point, OMPD_cancellation_point},

{OMPD_declare, OMPD_reduction, OMPD_declare_reduction},

{OMPD_declare, OMPD_mapper, OMPD_declare_mapper},

{OMPD_declare, OMPD_simd, OMPD_declare_simd},

{OMPD_declare, OMPD_target, OMPD_declare_target},

{OMPD_declare, OMPD_variant, OMPD_declare_variant},

{OMPD_begin_declare, OMPD_target, OMPD_begin_declare_target},

{OMPD_begin_declare, OMPD_variant, OMPD_begin_declare_variant},

{OMPD_end_declare, OMPD_variant, OMPD_end_declare_variant},

{OMPD_distribute, OMPD_parallel, OMPD_distribute_parallel},

{OMPD_distribute_parallel, OMPD_for, OMPD_distribute_parallel_for},

{OMPD_distribute_parallel_for, OMPD_simd,

OMPD_distribute_parallel_for_simd},

{OMPD_distribute, OMPD_simd, OMPD_distribute_simd},

{OMPD_end_declare, OMPD_target, OMPD_end_declare_target},

{OMPD_target, OMPD_data, OMPD_target_data},

{OMPD_target, OMPD_enter, OMPD_target_enter},

{OMPD_target, OMPD_exit, OMPD_target_exit},

{OMPD_target, OMPD_update, OMPD_target_update},

{OMPD_target_enter, OMPD_data, OMPD_target_enter_data},

{OMPD_target_exit, OMPD_data, OMPD_target_exit_data},

{OMPD_for, OMPD_simd, OMPD_for_simd},

{OMPD_parallel, OMPD_for, OMPD_parallel_for},

{OMPD_parallel_for, OMPD_simd, OMPD_parallel_for_simd},

{OMPD_parallel, OMPD_loop, OMPD_parallel_loop},

{OMPD_parallel, OMPD_sections, OMPD_parallel_sections},

{OMPD_taskloop, OMPD_simd, OMPD_taskloop_simd},

{OMPD_target, OMPD_parallel, OMPD_target_parallel},

{OMPD_target, OMPD_simd, OMPD_target_simd},

{OMPD_target_parallel, OMPD_loop, OMPD_target_parallel_loop},

{OMPD_target_parallel, OMPD_for, OMPD_target_parallel_for},

{OMPD_target_parallel_for, OMPD_simd, OMPD_target_parallel_for_simd},

{OMPD_teams, OMPD_distribute, OMPD_teams_distribute},

{OMPD_teams_distribute, OMPD_simd, OMPD_teams_distribute_simd},

{OMPD_teams_distribute, OMPD_parallel, OMPD_teams_distribute_parallel},

{OMPD_teams_distribute_parallel, OMPD_for,

OMPD_teams_distribute_parallel_for},

{OMPD_teams_distribute_parallel_for, OMPD_simd,

OMPD_teams_distribute_parallel_for_simd},

{OMPD_teams, OMPD_loop, OMPD_teams_loop},

{OMPD_target, OMPD_teams, OMPD_target_teams},

{OMPD_target_teams, OMPD_distribute, OMPD_target_teams_distribute},

{OMPD_target_teams, OMPD_loop, OMPD_target_teams_loop},

{OMPD_target_teams_distribute, OMPD_parallel,

OMPD_target_teams_distribute_parallel},

{OMPD_target_teams_distribute, OMPD_simd,

OMPD_target_teams_distribute_simd},

{OMPD_target_teams_distribute_parallel, OMPD_for,

OMPD_target_teams_distribute_parallel_for},

{OMPD_target_teams_distribute_parallel_for, OMPD_simd,

OMPD_target_teams_distribute_parallel_for_simd},

{OMPD_master, OMPD_taskloop, OMPD_master_taskloop},

{OMPD_masked, OMPD_taskloop, OMPD_masked_taskloop},

{OMPD_master_taskloop, OMPD_simd, OMPD_master_taskloop_simd},

{OMPD_masked_taskloop, OMPD_simd, OMPD_masked_taskloop_simd},

{OMPD_parallel, OMPD_master, OMPD_parallel_master},

{OMPD_parallel, OMPD_masked, OMPD_parallel_masked},

{OMPD_parallel_master, OMPD_taskloop, OMPD_parallel_master_taskloop},

{OMPD_parallel_masked, OMPD_taskloop, OMPD_parallel_masked_taskloop},

{OMPD_parallel_master_taskloop, OMPD_simd,

OMPD_parallel_master_taskloop_simd},

{OMPD_parallel_masked_taskloop, OMPD_simd,

OMPD_parallel_masked_taskloop_simd}};

{ CancellationPoint = 0, DeclareReduction = 1, TargetData = 2 };

Tok =

.getCurToken();

OpenMPDirectiveKindExWrapper DKind =

?

(OMPD_unknown)

(DKind == OMPD_unknown)

(

&I : F) {

Tok =

.getPreprocessor().LookAhead(0);

OpenMPDirectiveKindExWrapper SDKind =

?

(OMPD_unknown)

(SDKind == OMPD_unknown)

(SDKind == I[1]) {

(DKind) < llvm::omp::Directive_enumSize

Tok =

.getCurToken();

&Actions =

.getActions();

WithOperator =

;

(Tok.

(tok::kw_operator)) {

Tok =

.getCurToken();

WithOperator =

;

tok::identifier:

.Diag(Tok.

(), diag::err_omp_expected_reduction_identifier);

.SkipUntil(tok::colon, tok::r_paren, tok::annot_pragma_openmp_end,

: DeclNames.getCXXOperatorName(OOK);

(

.expectAndConsume(

diag::err_expected_lparen_after,

getOpenMPDirectiveName(OMPD_declare_reduction).data())) {

(Name.isEmpty() && Tok.

(tok::annot_pragma_openmp_end))

IsCorrect = !ExpectAndConsume(tok::colon);

(!IsCorrect && Tok.

(tok::annot_pragma_openmp_end))

IsCorrect = IsCorrect && !Name.isEmpty();

(Tok.

(tok::colon) || Tok.

(tok::annot_pragma_openmp_end)) {

(!IsCorrect && Tok.

(tok::annot_pragma_openmp_end))

(!ReductionType.

()) {

ReductionTypes.push_back(

(tok::comma, tok::colon, tok::annot_pragma_openmp_end,

(Tok.

(tok::colon) || Tok.

(tok::annot_pragma_openmp_end))

(ExpectAndConsume(tok::comma)) {

(Tok.

(tok::annot_pragma_openmp_end)) {

}

(Tok.

(tok::annot_pragma_openmp_end));

(ReductionTypes.empty()) {

(!IsCorrect && Tok.

(tok::annot_pragma_openmp_end))

(ExpectAndConsume(tok::colon))

(Tok.

(tok::annot_pragma_openmp_end)) {

I = 0,

= ReductionTypes.size();

(

*

: DRD.get()) {

TentativeParsingAction TPA(*

);

, CombinerResult.

());

Tok.

(tok::annot_pragma_openmp_end)) {

IsCorrect = !

.consumeClose() && IsCorrect && CombinerResult.

();

(Tok.

(tok::annot_pragma_openmp_end)) {

(Tok.

(tok::identifier) &&

tok::annot_pragma_openmp_end);

!

.expectAndConsume(diag::err_expected_lparen_after,

) &&

(Tok.

(tok::annot_pragma_openmp_end)) {

(Tok.

(tok::identifier) &&

ParseOpenMPReductionInitializerForDecl(OmpPrivParm);

, InitializerResult.

(), OmpPrivParm);

(InitializerResult.

() && Tok.

(tok::r_paren) &&

Tok.

(tok::annot_pragma_openmp_end)) {

!

.consumeClose() && IsCorrect && !InitializerResult.

();

Parser::ParseOpenMPReductionInitializerForDecl(

*OmpPrivParm) {

(isTokenEqualOrEqualTypo()) {

(Tok.

(tok::code_completion)) {

(

.isInvalid()) {

}

(Tok.

(tok::l_paren)) {

RunSignatureHelp = [

, OmpPrivParm, LParLoc, &Exprs]() {

OmpPrivParm->

(), Exprs, LParLoc,

);

CalledSignatureHelp =

;

PreferredType;

(ParseExpressionList(Exprs, [&] {

PreferredType.enterFunctionArgument(Tok.

(),

(!

.consumeClose())

RLoc =

.getCloseLocation();

(Tok, diag::warn_cxx98_compat_generalized_initializer_lists);

(

.isInvalid()) {

IsCorrect =

;

(

.expectAndConsume(diag::err_expected_lparen_after,

getOpenMPDirectiveName(OMPD_declare_mapper).data())) {

(Tok.

(tok::identifier) && Tok.

(tok::kw_default)) {

ExpectAndConsume(tok::colon);

(!IsCorrect && Tok.

(tok::annot_pragma_openmp_end))

(MapperType.

())

IsCorrect &= !

.consumeClose();

ParseScope OMPDirectiveScope(

, ScopeFlags);

(Tok.

(tok::annot_pragma_openmp_end)) {

ParseOpenMPClause(OMPD_declare_mapper, CKind, Clauses.empty());

Clauses.push_back(Clause);

(Tok.

(tok::comma))

(Clauses.empty()) {

(Tok, diag::err_omp_expected_clause)

<< getOpenMPDirectiveName(OMPD_declare_mapper);

OMPDirectiveScope.Exit();

Parser::DeclSpecContext DSC = Parser::DeclSpecContext::DSC_type_specifier;

ParseSpecifierQualifierList(DS, AS, DSC);

ParseDeclarator(DeclaratorInfo);

= DeclaratorInfo.getSourceRange();

(DeclaratorInfo.getIdentifier() ==

) {

FNContextRAII final {

HasFunScope =

;

FNContextRAII() =

;

FNContextRAII(

FNContextRAII &) =

;

FNContextRAII &operator=(

FNContextRAII &) =

;

&Actions =

.getActions();

.ReenterTemplateScopes(Scopes,

);

.getActions().ActOnExitFunctionContext();

&Tok =

.getCurToken();

IsError =

;

(Tok.

(tok::annot_pragma_openmp_end)) {

(Tok.

(tok::identifier))

OMPDeclareSimdDeclAttr::BranchStateTy Out;

StringRef ClauseName = II->

();

(OMPDeclareSimdDeclAttr::ConvertStrToBranchStateTy(ClauseName, Out)) {

(BS != OMPDeclareSimdDeclAttr::BS_Undefined && BS != Out) {

.Diag(Tok, diag::err_omp_declare_simd_inbranch_notinbranch)

<< OMPDeclareSimdDeclAttr::ConvertBranchStateTyToStr(BS) << BSRange;

}

(ClauseName ==

) {

.Diag(Tok, diag::err_omp_more_one_clause)

<< getOpenMPDirectiveName(OMPD_declare_simd) << ClauseName << 0;

SimdLen =

.ParseOpenMPParensExpr(ClauseName, RLoc);

(CKind == OMPC_uniform || CKind == OMPC_aligned ||

CKind == OMPC_linear) {

(CKind == OMPC_aligned) {

}

(CKind == OMPC_linear) {

.ExtraModifier = OMPC_LINEAR_val;

(

.ParseOpenMPVarList(OMPD_declare_simd,

getOpenMPClauseKind(ClauseName), *Vars,

))

(CKind == OMPC_aligned) {

Alignments.append(Aligneds.size() - Alignments.size(),

.DepModOrTailExpr);

}

(CKind == OMPC_linear) {

assert(0 <=

.ExtraModifier &&

);

(

.getActions().OpenMP().CheckOpenMPLinearModifier(

.ExtraModifierLoc))

.ExtraModifier = OMPC_LINEAR_val;

LinModifiers.append(Linears.size() - LinModifiers.size(),

.ExtraModifier);

Steps.append(Linears.size() - Steps.size(),

.DepModOrTailExpr);

(Tok.

(tok::comma))

PP.EnterTokenStream(Toks,

,

FNContextRAII FnContext(*

, Ptr);

OMPDeclareSimdDeclAttr::BranchStateTy BS =

OMPDeclareSimdDeclAttr::BS_Undefined;

Alignments, Linears, LinModifiers, Steps);

skipUntilPragmaOpenMPEnd(OMPD_declare_simd);

Ptr, BS, Simdlen.

(), Uniforms, Aligneds, Alignments, Linears,

CONTEXT_SELECTOR_SET_LVL = 0,

CONTEXT_SELECTOR_LVL = 1,

CONTEXT_TRAIT_LVL = 2,

StringRef stringLiteralParser(

&

) {

Res =

.ParseStringLiteralExpression(

);

StringRef getNameFromIdOrString(

&

,

&Tok,

(Tok.

(tok::identifier) || Tok.

(tok::kw_for)) {

StringRef Name =

.getPreprocessor().getSpelling(Tok, Buffer);

(void)

.ConsumeToken();

stringLiteralParser(

);

diag::warn_omp_declare_variant_string_literal_or_identifier)

checkForDuplicates(

&

, StringRef Name,

llvm::StringMap<SourceLocation> &Seen,

Res = Seen.try_emplace(Name, NameLoc);

.Diag(NameLoc, diag::warn_omp_declare_variant_ctx_mutiple_use)

.Diag(Res.first->getValue(), diag::note_omp_declare_variant_ctx_used_here)

llvm::omp::TraitSet

,

llvm::StringMap<SourceLocation> &Seen) {

TIProperty.

= TraitProperty::invalid;

StringRef Name = getNameFromIdOrString(*

, Tok, CONTEXT_TRAIT_LVL);

<< CONTEXT_TRAIT_LVL << listOpenMPContextTraitProperties(

,

);

TIProperty.

= getOpenMPContextTraitPropertyKind(

,

, Name);

(TIProperty.

!= TraitProperty::invalid) {

(checkForDuplicates(*

, Name, NameLoc, Seen, CONTEXT_TRAIT_LVL))

TIProperty.

= TraitProperty::invalid;

(NameLoc, diag::warn_omp_declare_variant_ctx_not_a_property)

<< Name << getOpenMPContextTraitSelectorName(

)

<< getOpenMPContextTraitSetName(

);

TraitSet SetForName = getOpenMPContextTraitSetKind(Name);

(SetForName != TraitSet::invalid) {

(NameLoc, diag::note_omp_declare_variant_ctx_is_a)

<< Name << CONTEXT_SELECTOR_SET_LVL << CONTEXT_TRAIT_LVL;

(NameLoc, diag::note_omp_declare_variant_ctx_try)

<< Name <<

<<

;

TraitSelector SelectorForName = getOpenMPContextTraitSelectorKind(Name);

(SelectorForName != TraitSelector::invalid) {

(NameLoc, diag::note_omp_declare_variant_ctx_is_a)

<< Name << CONTEXT_SELECTOR_LVL << CONTEXT_TRAIT_LVL;

AllowsTraitScore =

;

RequiresProperty =

;

isValidTraitSelectorForTraitSet(

SelectorForName, getOpenMPContextTraitSetForSelector(SelectorForName),

AllowsTraitScore, RequiresProperty);

(NameLoc, diag::note_omp_declare_variant_ctx_try)

<< getOpenMPContextTraitSetName(

getOpenMPContextTraitSetForSelector(SelectorForName))

<< Name << (RequiresProperty ?

:

);

(

&PotentialSet :

{TraitSet::construct, TraitSet::user, TraitSet::implementation,

TraitProperty PropertyForName =

getOpenMPContextTraitPropertyKind(PotentialSet,

, Name);

(PropertyForName == TraitProperty::invalid)

(NameLoc, diag::note_omp_declare_variant_ctx_try)

<< getOpenMPContextTraitSetName(

getOpenMPContextTraitSetForProperty(PropertyForName))

<< getOpenMPContextTraitSelectorName(

getOpenMPContextTraitSelectorForProperty(PropertyForName))

<< (

+ Name +

).str();

(NameLoc, diag::note_omp_declare_variant_ctx_options)

<< CONTEXT_TRAIT_LVL << listOpenMPContextTraitProperties(

,

);

llvm::StringMap<SourceLocation> &Seen) {

assert(TISelector.

==

llvm::omp::TraitSelector::implementation_extension &&

);

(TIProperty.

== TraitProperty::invalid)

(TIProperty.

==

TraitProperty::implementation_extension_disable_implicit_base)

(TIProperty.

==

TraitProperty::implementation_extension_allow_templates)

(TIProperty.

==

TraitProperty::implementation_extension_bind_to_declaration)

llvm::omp::TraitProperty::implementation_extension_match_all ||

llvm::omp::TraitProperty::implementation_extension_match_any ||

llvm::omp::TraitProperty::implementation_extension_match_none);

(IsMatchExtension(TIProperty)) {

(IsMatchExtension(SeenProp)) {

.Diag(

, diag::err_omp_variant_ctx_second_match_extension);

StringRef SeenName = llvm::omp::getOpenMPContextTraitPropertyName(

.Diag(SeenLoc, diag::note_omp_declare_variant_ctx_used_here)

<< CONTEXT_TRAIT_LVL << SeenName;

llvm_unreachable(

);

llvm::omp::TraitSet

,

llvm::StringMap<SourceLocation> &Seen) {

assert(TISelector.

!= TraitSelector::user_condition &&

);

parseOMPTraitPropertyKind(TIProperty,

, TISelector.

, Seen);

(TISelector.

== llvm::omp::TraitSelector::implementation_extension)

TIProperty.

= TraitProperty::invalid;

(TIProperty.

== TraitProperty::invalid) {

(Tok.

(), diag::note_omp_declare_variant_ctx_continue_here)

<< CONTEXT_TRAIT_LVL;

(isValidTraitPropertyForTraitSetAndSelector(TIProperty.

,

TISelector.

.push_back(TIProperty);

(PropertyLoc, diag::warn_omp_ctx_incompatible_property_for_selector)

<< getOpenMPContextTraitPropertyName(TIProperty.

,

<< getOpenMPContextTraitSelectorName(TISelector.

)

<< getOpenMPContextTraitSetName(

);

(PropertyLoc, diag::note_omp_ctx_compatible_set_and_selector_for_property)

<< getOpenMPContextTraitPropertyName(TIProperty.

,

<< getOpenMPContextTraitSelectorName(

getOpenMPContextTraitSelectorForProperty(TIProperty.

))

<< getOpenMPContextTraitSetName(

getOpenMPContextTraitSetForProperty(TIProperty.

));

(Tok.

(), diag::note_omp_declare_variant_ctx_continue_here)

<< CONTEXT_TRAIT_LVL;

llvm::omp::TraitSet

,

llvm::StringMap<SourceLocation> &Seen) {

TISelector.

= TraitSelector::invalid;

StringRef Name = getNameFromIdOrString(*

, Tok, CONTEXT_SELECTOR_LVL);

(Tok.

(), diag::note_omp_declare_variant_ctx_options)

<< CONTEXT_SELECTOR_LVL << listOpenMPContextTraitSelectors(

);

TISelector.

= getOpenMPContextTraitSelectorKind(Name);

(TISelector.

!= TraitSelector::invalid) {

(checkForDuplicates(*

, Name, NameLoc, Seen, CONTEXT_SELECTOR_LVL))

TISelector.

= TraitSelector::invalid;

(NameLoc, diag::warn_omp_declare_variant_ctx_not_a_selector)

<< Name << getOpenMPContextTraitSetName(

);

TraitSet SetForName = getOpenMPContextTraitSetKind(Name);

(SetForName != TraitSet::invalid) {

(NameLoc, diag::note_omp_declare_variant_ctx_is_a)

<< Name << CONTEXT_SELECTOR_SET_LVL << CONTEXT_SELECTOR_LVL;

(NameLoc, diag::note_omp_declare_variant_ctx_try)

<< Name <<

<<

;

(

&PotentialSet :

{TraitSet::construct, TraitSet::user, TraitSet::implementation,

TraitSet::device}) {

TraitProperty PropertyForName = getOpenMPContextTraitPropertyKind(

PotentialSet, TraitSelector::invalid, Name);

(PropertyForName == TraitProperty::invalid)

(NameLoc, diag::note_omp_declare_variant_ctx_is_a)

<< Name << CONTEXT_TRAIT_LVL << CONTEXT_SELECTOR_LVL;

(NameLoc, diag::note_omp_declare_variant_ctx_try)

<< getOpenMPContextTraitSetName(

getOpenMPContextTraitSetForProperty(PropertyForName))

<< getOpenMPContextTraitSelectorName(

getOpenMPContextTraitSelectorForProperty(PropertyForName))

<< (

+ Name +

).str();

(NameLoc, diag::note_omp_declare_variant_ctx_options)

<< CONTEXT_SELECTOR_LVL << listOpenMPContextTraitSelectors(

);

StringRef SelectorName =

.getPreprocessor().getSpelling(

.getCurToken(), Buffer);

(SelectorName !=

)

(void)

.ConsumeToken();

ScoreExpr =

.ParseOpenMPParensExpr(SelectorName, RLoc);

(

.getCurToken().is(tok::colon))

(

)

.ConsumeAnyToken();

.Diag(

.getCurToken(), diag::warn_omp_declare_variant_expected)

<<

;

Parser::parseOMPContextSelector(

llvm::StringMap<SourceLocation> &SeenSelectors) {

OuterPC = ParenCount;

FinishSelector = [OuterPC,

]() ->

{

(!

({tok::r_brace, tok::r_paren, tok::comma,

tok::annot_pragma_openmp_end},

(Tok.

(tok::r_paren) && OuterPC > ParenCount)

(

)ConsumeParen();

(OuterPC <= ParenCount) {

(!Tok.

(tok::comma) && !Tok.

(tok::r_paren)) {

(Tok.

(), diag::note_omp_declare_variant_ctx_continue_here)

<< CONTEXT_SELECTOR_LVL;

parseOMPTraitSelectorKind(TISelector,

, SeenSelectors);

(TISelector.

== TraitSelector::invalid)

FinishSelector();

AllowsTraitScore =

;

RequiresProperty =

;

(!isValidTraitSelectorForTraitSet(TISelector.

,

, AllowsTraitScore,

RequiresProperty)) {

(SelectorLoc, diag::warn_omp_ctx_incompatible_selector_for_set)

<< getOpenMPContextTraitSelectorName(TISelector.

)

<< getOpenMPContextTraitSetName(

);

(SelectorLoc, diag::note_omp_ctx_compatible_set_for_selector)

<< getOpenMPContextTraitSelectorName(TISelector.

)

<< getOpenMPContextTraitSetName(

getOpenMPContextTraitSetForSelector(TISelector.

))

<< RequiresProperty;

FinishSelector();

(!RequiresProperty) {

{getOpenMPContextTraitPropertyForSelector(TISelector.

),

getOpenMPContextTraitSelectorName(TISelector.

)});

(!Tok.

(tok::l_paren)) {

(SelectorLoc, diag::warn_omp_ctx_selector_without_properties)

<< getOpenMPContextTraitSelectorName(TISelector.

)

<< getOpenMPContextTraitSetName(

);

FinishSelector();

(TISelector.

== TraitSelector::user_condition) {

FinishSelector();

{TraitProperty::user_condition_unknown,

});

tok::annot_pragma_openmp_end);

(void)BDT.consumeOpen();

(!AllowsTraitScore && !Score.

()) {

(ScoreLoc, diag::warn_omp_ctx_incompatible_score_for_property)

<< getOpenMPContextTraitSelectorName(TISelector.

)

<< getOpenMPContextTraitSetName(

) << Score.

();

(ScoreLoc, diag::warn_omp_ctx_incompatible_score_for_property)

<< getOpenMPContextTraitSelectorName(TISelector.

)

<< getOpenMPContextTraitSetName(

) <<

;

llvm::StringMap<SourceLocation> SeenProperties;

parseOMPContextProperty(TISelector,

, SeenProperties);

Parser::parseOMPTraitSetKind(

&TISet,

llvm::StringMap<SourceLocation> &Seen) {

TISet.

= TraitSet::invalid;

StringRef Name = getNameFromIdOrString(*

, Tok, CONTEXT_SELECTOR_SET_LVL);

(Tok.

(), diag::note_omp_declare_variant_ctx_options)

<< CONTEXT_SELECTOR_SET_LVL << listOpenMPContextTraitSets();

TISet.

= getOpenMPContextTraitSetKind(Name);

(TISet.

!= TraitSet::invalid) {

(checkForDuplicates(*

, Name, NameLoc, Seen,

CONTEXT_SELECTOR_SET_LVL))

TISet.

= TraitSet::invalid;

(NameLoc, diag::warn_omp_declare_variant_ctx_not_a_set) << Name;

TraitSelector SelectorForName = getOpenMPContextTraitSelectorKind(Name);

(SelectorForName != TraitSelector::invalid) {

(NameLoc, diag::note_omp_declare_variant_ctx_is_a)

<< Name << CONTEXT_SELECTOR_LVL << CONTEXT_SELECTOR_SET_LVL;

AllowsTraitScore =

;

RequiresProperty =

;

isValidTraitSelectorForTraitSet(

SelectorForName, getOpenMPContextTraitSetForSelector(SelectorForName),

AllowsTraitScore, RequiresProperty);

(NameLoc, diag::note_omp_declare_variant_ctx_try)

<< getOpenMPContextTraitSetName(

getOpenMPContextTraitSetForSelector(SelectorForName))

<< Name << (RequiresProperty ?

:

);

(

&PotentialSet :

{TraitSet::construct, TraitSet::user, TraitSet::implementation,

TraitSet::device}) {

TraitProperty PropertyForName = getOpenMPContextTraitPropertyKind(

PotentialSet, TraitSelector::invalid, Name);

(PropertyForName == TraitProperty::invalid)

(NameLoc, diag::note_omp_declare_variant_ctx_is_a)

<< Name << CONTEXT_TRAIT_LVL << CONTEXT_SELECTOR_SET_LVL;

(NameLoc, diag::note_omp_declare_variant_ctx_try)

<< getOpenMPContextTraitSetName(

getOpenMPContextTraitSetForProperty(PropertyForName))

<< getOpenMPContextTraitSelectorName(

getOpenMPContextTraitSelectorForProperty(PropertyForName))

<< (

+ Name +

).str();

(NameLoc, diag::note_omp_declare_variant_ctx_options)

<< CONTEXT_SELECTOR_SET_LVL << listOpenMPContextTraitSets();

Parser::parseOMPContextSelectorSet(

&TISet, llvm::StringMap<SourceLocation> &SeenSets) {

OuterBC = BraceCount;

FinishSelectorSet = [

, OuterBC]() ->

{

(!

({tok::comma, tok::r_brace, tok::r_paren,

tok::annot_pragma_openmp_end},

(Tok.

(tok::r_brace) && OuterBC > BraceCount)

(

)ConsumeBrace();

(OuterBC <= BraceCount) {

(!Tok.

(tok::comma) && !Tok.

(tok::r_brace)) {

(Tok.

(), diag::note_omp_declare_variant_ctx_continue_here)

<< CONTEXT_SELECTOR_SET_LVL;

parseOMPTraitSetKind(TISet, SeenSets);

(TISet.

== TraitSet::invalid)

FinishSelectorSet();

<< (

+ getOpenMPContextTraitSetName(TISet.

) +

(Tok.

(tok::l_brace)) {

(void)ConsumeBrace();

<< (

+

getOpenMPContextTraitSetName(TISet.

) +

)

llvm::StringMap<SourceLocation> SeenSelectors;

parseOMPContextSelector(TISelector, TISet.

, SeenSelectors);

(TISelector.

!= TraitSelector::invalid &&

TISet.

.push_back(TISelector);

(Tok.

(tok::r_brace)) {

(void)ConsumeBrace();

<< (

+

getOpenMPContextTraitSetName(TISet.

) +

)

llvm::StringMap<SourceLocation> SeenSets;

parseOMPContextSelectorSet(TISet, SeenSets);

(TISet.

!= TraitSet::invalid && !TISet.

.empty())

TI.

.push_back(TISet);

PP.EnterTokenStream(Toks,

,

FNContextRAII FnContext(*

, Ptr);

getOpenMPDirectiveName(OMPD_declare_variant), RLoc,

(!AssociatedFunction.

()) {

(!Tok.

(tok::annot_pragma_openmp_end))

(void)ConsumeAnnotationToken();

Actions.

().getOMPTraitInfoForSurroundingScope();

(Tok.

(tok::annot_pragma_openmp_end)) {

(Tok.

(), diag::err_omp_declare_variant_wrong_clause)

IsError =

;

(Tok.

(tok::annot_pragma_openmp_end)) {

(!isAllowedClauseForDirective(OMPD_declare_variant, CKind,

(Tok.

(), diag::err_omp_declare_variant_wrong_clause)

IsError = parseOMPDeclareVariantMatchClause(

, TI, ParentTI);

OMPC_adjust_args: {

llvm::append_range(

.ExtraModifier == OMPC_ADJUST_ARGS_nothing

: AdjustNeedDevicePtr,

OMPC_append_args:

(!AppendArgs.empty()) {

(AppendArgsLoc, diag::err_omp_more_one_clause)

<< getOpenMPDirectiveName(OMPD_declare_variant)

<< getOpenMPClauseName(CKind) << 0;

IsError = parseOpenMPAppendArgs(AppendArgs);

llvm_unreachable(

);

(void)ConsumeAnnotationToken();

(Tok.

(tok::comma))

std::optional<std::pair<FunctionDecl *, Expr *>> DeclVarData =

Ptr, AssociatedFunction.

(), TI, AppendArgs.size(),

(DeclVarData && !TI.

.empty())

DeclVarData->first, DeclVarData->second, TI, AdjustNothing,

AdjustNeedDevicePtr, AppendArgs, AdjustArgsLoc, AppendArgsLoc,

(void)ConsumeAnnotationToken();

Parser::parseOpenMPAppendArgs(

HasError =

;

(

.expectAndConsume(diag::err_expected_lparen_after,

getOpenMPClauseName(OMPC_append_args).data()))

tok::annot_pragma_openmp_end);

(IT.expectAndConsume(diag::err_expected_lparen_after,

))

(ParseOMPInteropInfo(InteropInfo, OMPC_append_args))

InteropInfos.push_back(InteropInfo);

(Tok.

(tok::comma))

(!HasError && InteropInfos.empty()) {

(tok::comma, tok::r_paren, tok::annot_pragma_openmp_end,

HasError =

.consumeClose() || HasError;

(CKind != OMPC_match) {

(Tok.

(), diag::err_omp_declare_variant_wrong_clause)

(

.expectAndConsume(diag::err_expected_lparen_after,

getOpenMPClauseName(OMPC_match).data()))

parseOMPContextSelectors(

, TI);

(void)

.consumeClose();

MergedSet =

;

(

.Kind != ParentSet.

)

MergedSelector =

;

MergedSelector =

;

MergedProperty =

;

(

.Kind == llvm::omp::TraitSelector::user_condition) {

(

, diag::err_omp_declare_variant_nested_user_condition);

}

(

.ScoreOrCondition !=

(

, diag::err_omp_declare_variant_duplicate_nested_trait)

<< getOpenMPContextTraitPropertyName(

<< getOpenMPContextTraitSelectorName(ParentSelector.

)

<< getOpenMPContextTraitSetName(ParentSet.

);

(!MergedProperty)

.Properties.push_back(ParentProperty);

(!MergedSelector)

.Selectors.push_back(ParentSelector);

TI.

.push_back(ParentSet);

std::bitset<llvm::omp::Clause_enumSize + 1> SeenClauses;

(Tok.

(tok::annot_pragma_openmp_end)) {

ParseOpenMPClause(DKind, CKind, !SeenClauses[

(CKind)]);

(tok::comma, tok::identifier, tok::annot_pragma_openmp_end,

SeenClauses[

(CKind)] =

;

(Clause !=

)

Clauses.push_back(Clause);

(Tok.

(tok::annot_pragma_openmp_end)) {

(Tok.

(tok::comma))

SkippedClauses =

;

SkipBraces = [&](llvm::StringRef Spelling,

IssueNote) {

tok::annot_pragma_openmp_end);

(

.expectAndConsume(diag::err_expected_lparen_after, Spelling.data()))

(IssueNote &&

.getCloseLocation().isValid())

(

.getCloseLocation(),

diag::note_omp_assumption_clause_continue_here);

MatchACMClause = [&](StringRef RawString) {

llvm::StringSwitch<int> SS(RawString);

ACMIdx = 0;

(

AssumptionClauseMappingInfo &ACMI : AssumptionClauseMappings) {

(ACMI.StartsWith)

SS.StartsWith(ACMI.Identifier, ACMIdx++);

SS.Case(ACMI.Identifier, ACMIdx++);

SS.Default(-1);

(Tok.

(tok::annot_pragma_openmp_end)) {

Idx = MatchACMClause(II->

());

NextIsLPar = Tok.

(tok::l_paren);

(StartLoc, diag::warn_omp_unknown_assumption_clause_missing_id)

<< llvm::omp::getOpenMPDirectiveName(DKind)

<< llvm::omp::getAllAssumeClauseOptions() << NextIsLPar;

SkipBraces(II ? II->

() :

,

);

SkippedClauses =

;

AssumptionClauseMappingInfo &ACMI = AssumptionClauseMappings[Idx];

(ACMI.HasDirectiveList || ACMI.HasExpression) {

SkippedClauses =

;

SkipBraces(II->

(),

);

diag::warn_omp_unknown_assumption_clause_without_args)

SkipBraces(II->

(),

);

assert(II &&

);

std::string Assumption = II->

().str();

(ACMI.StartsWith)

Assumption =

+ Assumption.substr(ACMI.Identifier.size());

Assumption =

+ Assumption;

Assumptions.push_back(Assumption);

(

, diag::err_expected_begin_assumes);

SimpleClauseData {

std::optional<SimpleClauseData>

&Tok =

.getCurToken();

(

.expectAndConsume(diag::err_expected_lparen_after,

getOpenMPClauseName(Kind).data()))

std::nullopt;

Kind, Tok.

() ?

:

.getPreprocessor().getSpelling(Tok),

(Tok.

(tok::r_paren) && Tok.

(tok::comma) &&

Tok.

(tok::annot_pragma_openmp_end))

.ConsumeAnyToken();

(!

.consumeClose())

RLoc =

.getCloseLocation();

Parser::ParseOMPDeclareTargetClauses(

RequiresToOrLinkOrIndirectClause =

;

HasToOrLinkOrIndirectClause =

;

(Tok.

(tok::annot_pragma_openmp_end)) {

OMPDeclareTargetDeclAttr::MapTypeTy MT = OMPDeclareTargetDeclAttr::MT_To;

HasIdentifier = Tok.

(tok::identifier);

(HasIdentifier) {

RequiresToOrLinkOrIndirectClause =

;

StringRef ClauseName = II->

();

IsDeviceTypeClause =

getOpenMPClauseKind(ClauseName) == OMPC_device_type;

IsIndirectClause =

().OpenMP >= 51 &&

getOpenMPClauseKind(ClauseName) == OMPC_indirect;

(DTCI.

&& IsIndirectClause) {

(Tok, diag::err_omp_more_one_clause)

<< getOpenMPDirectiveName(OMPD_declare_target)

<< getOpenMPClauseName(OMPC_indirect) << 0;

IsToEnterOrLinkClause =

OMPDeclareTargetDeclAttr::ConvertStrToMapTypeTy(ClauseName, MT);

assert((!IsDeviceTypeClause || !IsToEnterOrLinkClause) &&

);

(

().OpenMP >= 52 && ClauseName ==

) {

(Tok, diag::err_omp_declare_target_unexpected_to_clause);

(

().OpenMP <= 51 && ClauseName ==

) {

(Tok, diag::err_omp_declare_target_unexpected_enter_clause);

(!IsDeviceTypeClause && !IsIndirectClause &&

DTCI.

== OMPD_begin_declare_target) {

(Tok, diag::err_omp_declare_target_unexpected_clause)

<< ClauseName << (

().OpenMP >= 51 ? 3 : 0);

(!IsDeviceTypeClause && !IsToEnterOrLinkClause && !IsIndirectClause) {

? diag::err_omp_declare_target_unexpected_clause_52

: diag::err_omp_declare_target_unexpected_clause)

(IsToEnterOrLinkClause || IsIndirectClause)

HasToOrLinkOrIndirectClause =

;

(IsIndirectClause) {

(!ParseOpenMPIndirectClause(DTCI,

))

(IsDeviceTypeClause) {

std::optional<SimpleClauseData> DevTypeData =

(DeviceTypeLoc.

()) {

(DevTypeData->Loc,

diag::warn_omp_more_one_device_type_clause);

OMPC_DEVICE_TYPE_any:

DTCI.

= OMPDeclareTargetDeclAttr::DT_Any;

OMPC_DEVICE_TYPE_host:

DTCI.

= OMPDeclareTargetDeclAttr::DT_Host;

OMPC_DEVICE_TYPE_nohost:

DTCI.

= OMPDeclareTargetDeclAttr::DT_NoHost;

llvm_unreachable(

);

DeviceTypeLoc = DevTypeData->Loc;

(DTCI.

== OMPD_declare_target || HasIdentifier) {

&&Callback = [

, MT, &DTCI](

&SS,

(NameInfo.

(), diag::err_omp_declare_target_multiple)

(ParseOpenMPSimpleVarList(OMPD_declare_target, Callback,

(Tok.

(tok::l_paren)) {

diag::err_omp_begin_declare_target_unexpected_implicit_to_clause);

(!HasIdentifier && Tok.

(tok::annot_pragma_openmp_end)) {

? diag::err_omp_declare_target_wrong_clause_after_implicit_enter

: diag::err_omp_declare_target_wrong_clause_after_implicit_to);

(Tok.

(tok::comma))

(DTCI.

&& DTCI.

!= OMPDeclareTargetDeclAttr::DT_Any)

(DeviceTypeLoc, diag::err_omp_declare_target_indirect_device_type);

(DTCI.

== OMPD_declare_target && RequiresToOrLinkOrIndirectClause &&

!HasToOrLinkOrIndirectClause)

? diag::err_omp_declare_target_missing_enter_or_link_clause

: diag::err_omp_declare_target_missing_to_or_link_clause)

(Tok.

(tok::annot_pragma_openmp_end))

(Tok, diag::warn_omp_extra_tokens_at_eol)

<< getOpenMPDirectiveName(DKind);

(Tok.

(tok::annot_pragma_openmp_end))

SkipUntilOpenMPEnd) {

DiagSelection = ExpectedKind == OMPD_end_declare_target ? 0 : 1;

(FoundKind == ExpectedKind) {

skipUntilPragmaOpenMPEnd(ExpectedKind);

(FoundLoc, diag::err_expected_end_declare_target_or_variant)

(BeginLoc, diag::note_matching)

<< (

+ getOpenMPDirectiveName(BeginKind) +

).str();

(SkipUntilOpenMPEnd)

parseOMPEndDirective(BeginDKind, OMPD_end_declare_target, EndDKind, DKLoc,

(Tok.

(tok::annot_pragma_openmp_end))

ConsumeAnnotationToken();

assert(Tok.

(tok::annot_pragma_openmp, tok::annot_attr_openmp) &&

);

TentativeParsingAction TPA(*

);

= ConsumeAnnotationToken();

(DKind == OMPD_declare_reduction || DKind == OMPD_declare_mapper) {

Toks.push_back(Tok);

(Cnt && Tok.

(tok::eof)) {

(Tok.

(tok::annot_pragma_openmp, tok::annot_attr_openmp))

(Tok.

(tok::annot_pragma_openmp_end))

Toks.push_back(Tok);

*LP =

LateParsedPragma(

, AS);

getCurrentClass().LateParsedDeclarations.push_back(LP);

= ConsumeAnnotationToken();

OMPD_threadprivate: {

DeclDirectiveListParserHelper Helper(

, DKind);

(!ParseOpenMPSimpleVarList(DKind, Helper,

skipUntilPragmaOpenMPEnd(DKind);

ConsumeAnnotationToken();

, Helper.getIdentifiers());

OMPD_allocate: {

DeclDirectiveListParserHelper Helper(

, DKind);

(!ParseOpenMPSimpleVarList(DKind, Helper,

(Tok.

(tok::annot_pragma_openmp_end)) {

std::bitset<llvm::omp::Clause_enumSize + 1> SeenClauses;

(Tok.

(tok::annot_pragma_openmp_end)) {

*Clause = ParseOpenMPClause(OMPD_allocate, CKind,

!SeenClauses[

(CKind)]);

(tok::comma, tok::identifier, tok::annot_pragma_openmp_end,

SeenClauses[

(CKind)] =

;

(Clause !=

)

Clauses.push_back(Clause);

(Tok.

(tok::annot_pragma_openmp_end)) {

(Tok.

(tok::comma))

skipUntilPragmaOpenMPEnd(DKind);

ConsumeAnnotationToken();

, Helper.getIdentifiers(), Clauses);

OMPD_requires: {

llvm::SmallBitVector SeenClauses(llvm::omp::Clause_enumSize + 1);

(Tok.

(tok::annot_pragma_openmp_end)) {

(Tok, diag::err_omp_expected_clause)

<< getOpenMPDirectiveName(OMPD_requires);

(Tok.

(tok::annot_pragma_openmp_end)) {

*Clause = ParseOpenMPClause(OMPD_requires, CKind,

!SeenClauses[

(CKind)]);

(tok::comma, tok::identifier, tok::annot_pragma_openmp_end,

SeenClauses[

(CKind)] =

;

(Clause !=

)

Clauses.push_back(Clause);

(Tok.

(tok::annot_pragma_openmp_end)) {

(Tok.

(tok::comma))

(Clauses.empty()) {

(Tok, diag::err_omp_expected_clause)

<< getOpenMPDirectiveName(OMPD_requires);

ConsumeAnnotationToken();

ConsumeAnnotationToken();

ParseOpenMPClauses(DKind, Clauses, StartLoc);

OMPD_begin_assumes:

OMPD_end_assumes:

OMPD_declare_reduction:

(

Res = ParseOpenMPDeclareReductionDirective(AS)) {

skipUntilPragmaOpenMPEnd(OMPD_declare_reduction);

ConsumeAnnotationToken();

OMPD_declare_mapper: {

(

Res = ParseOpenMPDeclareMapperDirective(AS)) {

ConsumeAnnotationToken();

OMPD_begin_declare_variant: {

Actions.

().getOMPTraitInfoForSurroundingScope();

(parseOMPDeclareVariantMatchClause(

, TI, ParentTI)) {

(void)ConsumeAnnotationToken();

skipUntilPragmaOpenMPEnd(OMPD_begin_declare_variant);

VariantMatchInfo VMI;

std::function<void(StringRef)> DiagUnknownTrait =

[

,

](StringRef ISATrait) {

(

, diag::warn_unknown_declare_variant_isa_trait) << ISATrait;

ASTCtx, std::move(DiagUnknownTrait),

(isVariantApplicableInContext(VMI, OMPCtx,

)) {

Nesting = 1;

(DK == OMPD_end_declare_variant)

(DK == OMPD_begin_declare_variant)

(!Nesting || isEofOrEom())

parseOMPEndDirective(OMPD_begin_declare_variant, OMPD_end_declare_variant,

DK,

, DKLoc,

);

OMPD_end_declare_variant: {

(

, diag::err_expected_begin_declare_variant);

OMPD_declare_variant:

OMPD_declare_simd: {

Toks.push_back(Tok);

(Tok.

(tok::annot_pragma_openmp_end)) {

Toks.push_back(Tok);

Toks.push_back(Tok);

(Tok.

(tok::annot_pragma_openmp, tok::annot_attr_openmp)) {

Ptr = ParseOpenMPDeclarativeDirectiveWithExtDecl(AS, Attrs, Delayed,

}

(Tok.

(tok::r_brace) && !isEofOrEom()) {

MaybeParseCXX11Attributes(Attrs);

Ptr = ParseExternalDeclaration(Attrs, EmptyDeclSpecAttrs, &PDS);

ParseCXXClassMemberDeclarationWithPragmas(AS, Attrs,

, Tag);

(

, diag::err_omp_decl_in_declare_simd_variant)

<< (DKind == OMPD_declare_simd ? 0 : 1);

(DKind == OMPD_declare_simd)

ParseOMPDeclareSimdClauses(Ptr, Toks,

);

assert(DKind == OMPD_declare_variant &&

);

ParseOMPDeclareVariantClauses(Ptr, Toks,

);

OMPD_begin_declare_target:

OMPD_declare_target: {

HasClauses = Tok.

(tok::annot_pragma_openmp_end);

ParseOMPDeclareTargetClauses(DTCI);

HasImplicitMappings = DKind == OMPD_begin_declare_target ||

(HasImplicitMappings) {

Decls.push_back(It.first);

OMPD_end_declare_target: {

(Tok, diag::err_omp_unexpected_directive)

<< 1 << getOpenMPDirectiveName(DKind);

ParseOMPEndDeclareTargetDirective(DTCI.

, DKind, DTCI.

);

(Tok, diag::err_omp_unexpected_directive)

<< 1 << getOpenMPDirectiveName(DKind);

(Tok, diag::err_omp_unknown_directive);

(getDirectiveCategory(DKind)) {

Category::Executable:

Category::Meta:

Category::Subsidiary:

Category::Utility:

(Tok, diag::err_omp_unexpected_directive)

<< 1 << getOpenMPDirectiveName(DKind);

Category::Declarative:

Category::Informational:

(Tok.

(tok::annot_pragma_openmp_end))

Parser::ParseOpenMPExecutableDirective(

ReadDirectiveWithinMetadirective) {

HasAssociatedStatement =

;

Assoc = getDirectiveAssociation(DKind);

(DKind != OMPD_ordered && DKind != OMPD_section &&

(Assoc == Association::None || Assoc == Association::Separating)) {

((StmtCtx & ParsedStmtContext::AllowStandaloneOpenMPDirectives) ==

ParsedStmtContext()) {

(Tok, diag::err_omp_immediate_directive)

<< getOpenMPDirectiveName(DKind) << 0;

(DKind == OMPD_error) {

(tok::annot_pragma_openmp_end);

HasAssociatedStatement =

;

llvm::SmallBitVector SeenClauses(llvm::omp::Clause_enumSize + 1);

ImplicitClauseAllowed =

;

(DKind == OMPD_flush || DKind == OMPD_depobj) {

ImplicitClauseAllowed =

;

(DKind == OMPD_critical) {

tok::annot_pragma_openmp_end);

(!

.consumeOpen()) {

(Tok, diag::err_omp_expected_identifier_for_critical);

}

(DKind == OMPD_cancellation_point || DKind == OMPD_cancel) {

(Tok.

(tok::annot_pragma_openmp_end))

ParseScope OMPDirectiveScope(

, ScopeFlags);

(Tok.

(tok::annot_pragma_openmp_end)) {

(ReadDirectiveWithinMetadirective && Tok.

(tok::r_paren)) {

(Tok.

(tok::annot_pragma_openmp_end))

HasImplicitClause =

;

(ImplicitClauseAllowed && Tok.

(tok::l_paren)) {

HasImplicitClause =

;

(HasImplicitClause) {

assert(CKind == OMPC_unknown &&

);

(DKind == OMPD_flush) {

assert(DKind == OMPD_depobj &&

);

CKind = OMPC_depobj;

ImplicitClauseAllowed =

;

HasImplicitClause =

;

ParseOpenMPClause(DKind, CKind, !SeenClauses[

(CKind)]);

SeenClauses[

(CKind)] =

;

Clauses.push_back(Clause);

(Tok.

(tok::comma))

ConsumeAnnotationToken();

(DKind == OMPD_ordered) {

(

CK : {OMPC_depend, OMPC_doacross}) {

(SeenClauses[

(CK)]) {

((StmtCtx & ParsedStmtContext::AllowStandaloneOpenMPDirectives) ==

ParsedStmtContext()) {

(

, diag::err_omp_immediate_directive)

<< getOpenMPDirectiveName(DKind) << 1 << getOpenMPClauseName(CK);

HasAssociatedStatement =

;

(DKind == OMPD_tile && !SeenClauses[

(OMPC_sizes)]) {

(

, diag::err_omp_required_clause)

<< getOpenMPDirectiveName(OMPD_tile) <<

;

(HasAssociatedStatement) {

AssociatedStmt = ParseStatement();

}

(DKind == OMPD_target_update || DKind == OMPD_target_enter_data ||

DKind == OMPD_target_exit_data) {

DKind, DirName, CancelRegion, Clauses, AssociatedStmt.

(),

, EndLoc);

OMPDirectiveScope.Exit();

Parser::ParseOpenMPInformationalDirective(

ReadDirectiveWithinMetadirective) {

);

HasAssociatedStatement =

;

llvm::SmallBitVector SeenClauses(llvm::omp::Clause_enumSize + 1);

ParseScope OMPDirectiveScope(

, ScopeFlags);

(Tok.

(tok::annot_pragma_openmp_end)) {

(ReadDirectiveWithinMetadirective && Tok.

(tok::r_paren)) {

(Tok.

(tok::annot_pragma_openmp_end))

ParseOpenMPClause(DKind, CKind, !SeenClauses[

(CKind)]);

SeenClauses[

(CKind)] =

;

Clauses.push_back(Clause);

(Tok.

(tok::comma))

ConsumeAnnotationToken();

(HasAssociatedStatement) {

AssociatedStmt = ParseStatement();

DKind, DirName, Clauses, AssociatedStmt.

(),

, EndLoc);

OMPDirectiveScope.Exit();

Parser::ParseOpenMPDeclarativeOrExecutableDirective(

ParsedStmtContext StmtCtx,

ReadDirectiveWithinMetadirective) {

(!ReadDirectiveWithinMetadirective)

assert(Tok.

(tok::annot_pragma_openmp, tok::annot_attr_openmp) &&

);

: ConsumeAnnotationToken();

(ReadDirectiveWithinMetadirective && DKind == OMPD_unknown) {

(Tok, diag::err_omp_unknown_directive);

IsExecutable = [&]() {

(DKind == OMPD_error)

Res = getDirectiveCategory(DKind);

Res == Category::Executable || Res == Category::Subsidiary;

= ParseOpenMPExecutableDirective(

StmtCtx, DKind,

, ReadDirectiveWithinMetadirective);

assert(!

.isUnset() &&

);

(ReadDirectiveWithinMetadirective && Tok.

(tok::r_paren))

(Tok.

(tok::annot_pragma_openmp_end))

skipUntilPragmaOpenMPEnd(DKind);

(Tok.

(tok::annot_pragma_openmp_end))

ConsumeAnnotationToken();

OMPD_metadirective: {

TentativeParsingAction TPA(*

);

tok::annot_pragma_openmp_end);

(Tok.

(tok::annot_pragma_openmp_end)) {

(

.expectAndConsume(diag::err_expected_lparen_after,

getOpenMPClauseName(CKind).data()))

(CKind == OMPC_when) {

parseOMPContextSelectors(

, TI);

(TI.

.size() == 0) {

(Tok, diag::err_omp_expected_context_selector) <<

;

(Tok.

(tok::colon))

(Tok, diag::err_omp_expected_colon) <<

;

(Tok.

(tok::r_paren) || paren != 0) {

(Tok.

(tok::l_paren))

(Tok.

(tok::r_paren))

(Tok.

(tok::annot_pragma_openmp_end)) {

(Tok, diag::err_omp_expected_punc)

<< getOpenMPClauseName(CKind) << 0;

(Tok.

(tok::r_paren))

VariantMatchInfo VMI;

VMIs.push_back(VMI);

std::function<void(StringRef)> DiagUnknownTrait =

[

,

](StringRef ISATrait) {

(

, diag::warn_unknown_declare_variant_isa_trait) << ISATrait;

BestIdx = getBestVariantMatchForContext(VMIs, OMPCtx);

(Tok.

(tok::annot_pragma_openmp_end)) {

(Idx++ != BestIdx) {

(Tok.

(tok::r_paren) || paren != 0) {

(Tok.

(tok::l_paren))

(Tok.

(tok::r_paren))

(Tok.

(tok::r_paren))

(CKind == OMPC_when) {

parseOMPContextSelectors(

, TI);

(Tok.

(tok::r_paren)) {

(tok::annot_pragma_openmp_end);

= ParseOpenMPDeclarativeOrExecutableDirective(

OMPD_threadprivate: {

((StmtCtx & ParsedStmtContext::AllowStandaloneOpenMPDirectives) ==

ParsedStmtContext()) {

(Tok, diag::err_omp_immediate_directive)

<< getOpenMPDirectiveName(DKind) << 0;

DeclDirectiveListParserHelper Helper(

, DKind);

(!ParseOpenMPSimpleVarList(DKind, Helper,

skipUntilPragmaOpenMPEnd(DKind);

, Helper.getIdentifiers());

(tok::annot_pragma_openmp_end);

OMPD_allocate: {

((StmtCtx & ParsedStmtContext::AllowStandaloneOpenMPDirectives) ==

ParsedStmtContext()) {

(Tok, diag::err_omp_immediate_directive)

<< getOpenMPDirectiveName(DKind) << 0;

DeclDirectiveListParserHelper Helper(

, DKind);

(!ParseOpenMPSimpleVarList(DKind, Helper,

(Tok.

(tok::annot_pragma_openmp_end)) {

llvm::SmallBitVector SeenClauses(llvm::omp::Clause_enumSize + 1);

(Tok.

(tok::annot_pragma_openmp_end)) {

*Clause = ParseOpenMPClause(OMPD_allocate, CKind,

!SeenClauses[

(CKind)]);

(tok::comma, tok::identifier, tok::annot_pragma_openmp_end,

SeenClauses[

(CKind)] =

;

(Clause !=

)

Clauses.push_back(Clause);

(Tok.

(tok::annot_pragma_openmp_end)) {

(Tok.

(tok::comma))

skipUntilPragmaOpenMPEnd(DKind);

, Helper.getIdentifiers(), Clauses);

(tok::annot_pragma_openmp_end);

OMPD_declare_reduction:

ParseOpenMPDeclareReductionDirective(

)) {

skipUntilPragmaOpenMPEnd(OMPD_declare_reduction);

(tok::annot_pragma_openmp_end);

OMPD_declare_mapper: {

ParseOpenMPDeclareMapperDirective(

)) {

ConsumeAnnotationToken();

(tok::annot_pragma_openmp_end);

OMPD_declare_target: {

HasClauses = Tok.

(tok::annot_pragma_openmp_end);

ParseOMPDeclareTargetClauses(DTCI);

HasImplicitMappings =

(HasImplicitMappings) {

(Tok, diag::err_omp_unexpected_directive)

<< 1 << getOpenMPDirectiveName(DKind);

(tok::annot_pragma_openmp_end);

OMPD_declare_simd:

OMPD_begin_declare_target:

OMPD_end_declare_target:

OMPD_begin_declare_variant:

OMPD_end_declare_variant:

OMPD_declare_variant:

(Tok, diag::err_omp_unexpected_directive)

<< 1 << getOpenMPDirectiveName(DKind);

(tok::annot_pragma_openmp_end);

= ParseOpenMPInformationalDirective(

StmtCtx, DKind,

, ReadDirectiveWithinMetadirective);

);

(Tok, diag::err_omp_unknown_directive);

(tok::annot_pragma_openmp_end);

Parser::ParseOpenMPSimpleVarList(

AllowScopeSpecifier) {

(

.expectAndConsume(diag::err_expected_lparen_after,

getOpenMPDirectiveName(Kind).data()))

IsCorrect =

;

NoIdentIsFound =

;

(Tok.

(tok::r_paren) && Tok.

(tok::annot_pragma_openmp_end)) {

PrevTok = Tok;

NoIdentIsFound =

;

ParseOptionalCXXScopeSpecifier(SS,

,

(tok::comma, tok::r_paren, tok::annot_pragma_openmp_end,

,

,

,

,

,

, Name)) {

(tok::comma, tok::r_paren, tok::annot_pragma_openmp_end,

}

(Tok.

(tok::comma) && Tok.

(tok::r_paren) &&

Tok.

(tok::annot_pragma_openmp_end)) {

(tok::comma, tok::r_paren, tok::annot_pragma_openmp_end,

(Tok.

(tok::comma)) {

(NoIdentIsFound) {

(Tok, diag::err_expected) << tok::identifier;

IsCorrect = !

.consumeClose() && IsCorrect;

*Parser::ParseOpenMPSizesClause() {

(ParseOpenMPExprListClause(OMPC_sizes, ClauseNameLoc, OpenLoc, CloseLoc,

*Parser::ParseOpenMPPermutationClause() {

(ParseOpenMPExprListClause(OMPC_permutation, ClauseNameLoc, OpenLoc,

(

.expectAndConsume(diag::err_expected_lparen_after,

))

? ParseCXXIdExpression()

: tryParseCXXIdExpression(SS,

,

(Allocator.isInvalid()) {

(tok::comma, tok::r_paren, tok::annot_pragma_openmp_end,

.Allocator = Allocator.get();

(Tok.

(tok::l_paren)) {

tok::annot_pragma_openmp_end);

(tok::comma, tok::r_paren, tok::annot_pragma_openmp_end,

.AllocatorTraits = AllocatorTraits.

();

.LParenLoc =

.getOpenLocation();

.RParenLoc =

.getCloseLocation();

(Tok.

(tok::comma) && Tok.

(tok::r_paren))

(Tok, diag::err_omp_expected_punc) <<

<< 0;

(Tok.

(tok::comma))

}

(Tok.

(tok::r_paren) && Tok.

(tok::annot_pragma_openmp_end));

,

.getOpenLocation(),

.getCloseLocation(),

);

OMPClauseKind = CKind;

ErrorFound =

;

WrongDirective =

;

(CKind != OMPC_unknown &&

!isAllowedClauseForDirective(DKind, CKind,

().OpenMP)) {

(Tok, diag::err_omp_unexpected_clause)

<< getOpenMPClauseName(CKind) << getOpenMPDirectiveName(DKind);

WrongDirective =

;

OMPC_num_threads:

OMPC_grainsize:

OMPC_num_tasks:

OMPC_allocator:

OMPC_novariants:

OMPC_nocontext:

OMPC_ompx_dyn_cgroup_mem:

(Tok, diag::err_omp_more_one_clause)

<< getOpenMPDirectiveName(DKind) << getOpenMPClauseName(CKind) << 0;

((CKind == OMPC_ordered || CKind == OMPC_partial) &&

Clause = ParseOpenMPClause(CKind, WrongDirective);

(CKind == OMPC_grainsize || CKind == OMPC_num_tasks)

Clause = ParseOpenMPSingleExprWithArgClause(DKind, CKind, WrongDirective);

Clause = ParseOpenMPSingleExprClause(CKind, WrongDirective);

OMPC_proc_bind:

OMPC_atomic_default_mem_order:

(Tok, diag::err_omp_more_one_clause)

<< getOpenMPDirectiveName(DKind) << getOpenMPClauseName(CKind) << 0;

Clause = ParseOpenMPSimpleClause(CKind, WrongDirective);

OMPC_dist_schedule:

OMPC_defaultmap:

((

().OpenMP < 50 || CKind != OMPC_defaultmap) &&

(CKind != OMPC_order ||

().OpenMP >= 51) && !FirstClause) {

(Tok, diag::err_omp_more_one_clause)

<< getOpenMPDirectiveName(DKind) << getOpenMPClauseName(CKind) << 0;

Clause = ParseOpenMPSingleExprWithArgClause(DKind, CKind, WrongDirective);

Clause = ParseOpenMPSingleExprClause(CKind, WrongDirective);

OMPC_mergeable:

OMPC_unified_address:

OMPC_unified_shared_memory:

OMPC_reverse_offload:

OMPC_dynamic_allocators:

(Tok, diag::err_omp_more_one_clause)

<< getOpenMPDirectiveName(DKind) << getOpenMPClauseName(CKind) << 0;

Clause = ParseOpenMPClause(CKind, WrongDirective);

(Tok, diag::err_omp_more_one_clause)

<< getOpenMPDirectiveName(DKind) << getOpenMPClauseName(CKind) << 0;

Clause = (DKind == OMPD_depobj)

? ParseOpenMPSimpleClause(CKind, WrongDirective)

: ParseOpenMPClause(CKind, WrongDirective);

OMPC_num_teams:

OMPC_thread_limit:

(Tok, diag::err_omp_more_one_clause)

<< getOpenMPDirectiveName(DKind) << getOpenMPClauseName(CKind) << 0;

OMPC_firstprivate:

OMPC_lastprivate:

OMPC_reduction:

OMPC_task_reduction:

OMPC_in_reduction:

OMPC_copyprivate:

OMPC_use_device_ptr:

OMPC_use_device_addr:

OMPC_is_device_ptr:

OMPC_has_device_addr:

OMPC_nontemporal:

OMPC_inclusive:

OMPC_exclusive:

(

().OpenMP >= 52 && DKind == OMPD_ordered &&

CKind == OMPC_depend)

(Tok, diag::warn_omp_depend_in_ordered_deprecated);

Clause = ParseOpenMPVarListClause(DKind, CKind, WrongDirective);

(Tok, diag::err_omp_more_one_clause)

<< getOpenMPDirectiveName(DKind) << getOpenMPClauseName(CKind) << 0;

Clause = ParseOpenMPSizesClause();

OMPC_permutation:

(Tok, diag::err_omp_more_one_clause)

<< getOpenMPDirectiveName(DKind) << getOpenMPClauseName(CKind) << 0;

Clause = ParseOpenMPPermutationClause();

OMPC_uses_allocators:

Clause = ParseOpenMPUsesAllocatorClause(DKind);

(DKind != OMPD_interop) {

(Tok, diag::err_omp_more_one_clause)

<< getOpenMPDirectiveName(DKind) << getOpenMPClauseName(CKind) << 0;

Clause = ParseOpenMPClause(CKind, WrongDirective);

Clause = ParseOpenMPInteropClause(CKind, WrongDirective);

OMPC_device_type:

skipUntilPragmaOpenMPEnd(DKind);

OMPC_threadprivate:

(!WrongDirective)

(Tok, diag::err_omp_unexpected_clause)

<< getOpenMPClauseName(CKind) << getOpenMPDirectiveName(DKind);

OMPC_contains: {

(DK == OMPD_unknown) {

skipUntilPragmaOpenMPEnd(OMPD_assume);

(Tok, diag::err_omp_unexpected_clause)

<< getOpenMPClauseName(CKind) << getOpenMPDirectiveName(DKind);

DKVec.push_back(DK);

(Tok, diag::err_omp_unexpected_clause)

<< getOpenMPClauseName(CKind) << getOpenMPDirectiveName(DKind);

CKind, DKVec,

, LLoc, RLoc);

OMPC_no_openmp:

OMPC_no_openmp_routines:

OMPC_no_parallelism: {

(Tok, diag::err_omp_more_one_clause)

<< getOpenMPDirectiveName(DKind) << getOpenMPClauseName(CKind) << 0;

OMPC_ompx_attribute:

Clause = ParseOpenMPOMPXAttributesClause(WrongDirective);

OMPC_ompx_bare:

(DKind == llvm::omp::Directive::OMPD_target) {

(Tok, diag::err_omp_unexpected_clause)

<< getOpenMPClauseName(CKind) << getOpenMPDirectiveName(DKind);

WrongDirective =

;

(Tok, diag::note_ompx_bare_clause)

<< getOpenMPClauseName(CKind) <<

;

(!ErrorFound && !

().OpenMPExtensions) {

(Tok, diag::err_omp_unexpected_clause_extension_only)

<< getOpenMPClauseName(CKind) << getOpenMPDirectiveName(DKind);

Clause = ParseOpenMPClause(CKind, WrongDirective);

ErrorFound ? nullptr : Clause;

IsAddressOfOperand) {

(

.expectAndConsume(diag::err_expected_lparen_after, ClauseName.data()))

ParseCastExpression(AnyCastExpr, IsAddressOfOperand,

));

(!

.consumeClose())

RLoc =

.getCloseLocation();

Parser::ParseOpenMPIndirectClause(

(Tok.

(tok::l_paren)) {

(

.isInvalid())

(

.isInvalid())

HasError =

;

IsTarget =

;

IsTargetSync =

;

(Tok.

(tok::identifier)) {

PreferTypeAllowed =

== OMPC_init &&

(Tok, diag::warn_omp_more_one_interop_type) <<

;

(Tok, diag::warn_omp_more_one_interop_type) <<

;

IsTargetSync =

;

PreferTypeAllowed) {

tok::annot_pragma_openmp_end);

(PT.expectAndConsume(diag::err_expected_lparen_after,

))

(Tok.

(tok::r_paren)) {

LHS = ParseCastExpression(AnyCastExpr);

(tok::comma, tok::r_paren, tok::annot_pragma_openmp_end,

(Tok.

(tok::comma))

(Tok, diag::err_omp_expected_interop_type);

(!Tok.

(tok::comma))

(!HasError && !IsTarget && !IsTargetSync) {

(Tok, diag::err_omp_expected_interop_type);

(Kind == OMPC_init) {

(Tok.

(tok::colon) && (IsTarget || IsTargetSync))

(Tok, diag::warn_pragma_expected_colon) <<

;

(Tok.

(tok::colon))

(

.expectAndConsume(diag::err_expected_lparen_after,

getOpenMPClauseName(Kind).data()))

InteropError =

;

(Kind == OMPC_init)

InteropError = ParseOMPInteropInfo(InteropInfo, OMPC_init);

(!InteropVarExpr.

()) {

(tok::comma, tok::r_paren, tok::annot_pragma_openmp_end,

(!

.consumeClose())

RLoc =

.getCloseLocation();

(ParseOnly || !InteropVarExpr.

() || InteropError)

(Kind == OMPC_init)

InteropVarExpr.

(), InteropInfo,

,

.getOpenLocation(), VarLoc,

(Kind == OMPC_use)

InteropVarExpr.

(),

,

.getOpenLocation(), VarLoc, RLoc);

(Kind == OMPC_destroy)

InteropVarExpr.

(),

,

.getOpenLocation(), VarLoc, RLoc);

llvm_unreachable(

);

*Parser::ParseOpenMPOMPXAttributesClause(

ParseOnly) {

(

.expectAndConsume(diag::err_expected_lparen_after,

getOpenMPClauseName(OMPC_ompx_attribute).data()))

ParseAttributes(PAKM_GNU | PAKM_CXX11, ParsedAttrs);

(

.consumeClose())

(PA.getKind()) {

ParsedAttr::AT_AMDGPUFlatWorkGroupSize:

(!PA.checkExactlyNumArgs(Actions, 2))

PA, PA.getArgAsExpr(0), PA.getArgAsExpr(1)))

ParsedAttr::AT_AMDGPUWavesPerEU:

(!PA.checkAtLeastNumArgs(Actions, 1) ||

!PA.checkAtMostNumArgs(Actions, 2))

PA, PA.getArgAsExpr(0),

PA.getNumArgs() > 1 ? PA.getArgAsExpr(1) :

))

ParsedAttr::AT_CUDALaunchBounds:

(!PA.checkAtLeastNumArgs(Actions, 1) ||

!PA.checkAtMostNumArgs(Actions, 2))

PA, PA.getArgAsExpr(0),

PA.getNumArgs() > 1 ? PA.getArgAsExpr(1) :

,

PA.getNumArgs() > 2 ? PA.getArgAsExpr(2) :

))

(

, diag::warn_omp_invalid_attribute_for_ompx_attributes) << PA;

Attrs,

,

.getOpenLocation(),

.getCloseLocation());

(!Val || ParseOnly)

(

().OpenMP < 51 && Kind == OMPC_default &&

(

DefaultKind

(Val->Type) == OMP_DEFAULT_private ||

DefaultKind

(Val->Type) ==

OMP_DEFAULT_firstprivate)) {

(Val->LOpen, diag::err_omp_invalid_dsa)

<< getOpenMPClauseName(

DefaultKind

(Val->Type) ==

: OMPC_firstprivate)

<< getOpenMPClauseName(OMPC_default) <<

;

Kind, Val->Type, Val->TypeLoc, Val->LOpen, Val->Loc, Val->RLoc);

(

.expectAndConsume(diag::err_expected_lparen_after,

getOpenMPClauseName(Kind).data()))

(Kind == OMPC_schedule) {

{ Modifier1, Modifier2, ScheduleKind, NumberOfElements };

Arg.resize(NumberOfElements);

KLoc.resize(NumberOfElements);

Arg[Modifier1] = KindModifier;

(Tok.

(tok::r_paren) && Tok.

(tok::comma) &&

Tok.

(tok::annot_pragma_openmp_end))

(Tok.

(tok::comma)) {

(Tok.

(tok::r_paren) && Tok.

(tok::comma) &&

Tok.

(tok::annot_pragma_openmp_end))

(Tok.

(tok::colon))

(Tok, diag::warn_pragma_expected_colon) <<

;

Arg[ScheduleKind] = KindModifier;

(Tok.

(tok::r_paren) && Tok.

(tok::comma) &&

Tok.

(tok::annot_pragma_openmp_end))

((Arg[ScheduleKind] == OMPC_SCHEDULE_static ||

Arg[ScheduleKind] == OMPC_SCHEDULE_dynamic ||

Arg[ScheduleKind] == OMPC_SCHEDULE_guided) &&

Tok.

(tok::comma))

}

(Kind == OMPC_dist_schedule) {

(Tok.

(tok::r_paren) && Tok.

(tok::comma) &&

Tok.

(tok::annot_pragma_openmp_end))

(Arg.back() == OMPC_DIST_SCHEDULE_static && Tok.

(tok::comma))

}

(Kind == OMPC_defaultmap) {

Arg.push_back(Modifier);

(Tok.

(tok::r_paren) && Tok.

(tok::comma) &&

Tok.

(tok::annot_pragma_openmp_end))

(Tok.

(tok::colon))

(Tok, diag::warn_pragma_expected_colon) <<

;

(Tok.

(tok::r_paren) && Tok.

(tok::comma) &&

Tok.

(tok::annot_pragma_openmp_end))

}

(Kind == OMPC_order) {

{ Modifier, OrderKind, NumberOfElements };

Arg.resize(NumberOfElements);

KLoc.resize(NumberOfElements);

Arg[Modifier] = KindModifier;

(Tok.

(tok::r_paren) && Tok.

(tok::comma) &&

Tok.

(tok::annot_pragma_openmp_end))

(Tok.

(tok::colon))

(Tok, diag::warn_pragma_expected_colon) <<

;

Arg[OrderKind] = KindModifier;

(Tok.

(tok::r_paren) && Tok.

(tok::comma) &&

Tok.

(tok::annot_pragma_openmp_end))

}

(Kind == OMPC_device) {

KLoc.emplace_back();

}

(Kind == OMPC_grainsize) {

Arg.push_back(Modifier);

(Modifier == OMPC_GRAINSIZE_strict) {

(Tok, diag::err_modifier_expected_colon) <<

;

KLoc.emplace_back();

KLoc.emplace_back();

}

(Kind == OMPC_num_tasks) {

Arg.push_back(Modifier);

(Modifier == OMPC_NUMTASKS_strict) {

(Tok, diag::err_modifier_expected_colon) <<

;

KLoc.emplace_back();

KLoc.emplace_back();

assert(Kind == OMPC_if);

TentativeParsingAction TPA(*

);

(DK != OMPD_unknown) {

Arg.back() =

(OMPD_unknown);

NeedAnExpression = (

== OMPC_schedule && DelimLoc.

()) ||

(Kind == OMPC_dist_schedule && DelimLoc.

()) ||

Kind == OMPC_if || Kind == OMPC_device ||

Kind == OMPC_grainsize || Kind == OMPC_num_tasks;

(NeedAnExpression) {

(!

.consumeClose())

RLoc =

.getCloseLocation();

(NeedAnExpression && Val.

())

Kind, Arg, Val.

(),

,

.getOpenLocation(), KLoc, DelimLoc, RLoc);

(ReductionIdScopeSpec.

()) {

(

.getCurToken().getKind()) {

.ParseUnqualifiedId(

ReductionIdScopeSpec,

,

,

, ReductionId);

Tok =

.getCurToken();

(!Tok.

(tok::identifier))

TypeModifier;

(

.expectAndConsume(diag::err_expected_lparen_after,

)) {

(tok::colon, tok::r_paren, tok::annot_pragma_openmp_end,

ParseOptionalCXXScopeSpecifier(

.ReductionOrMapperIdScopeSpec,

(Tok.

(tok::identifier) && Tok.

(tok::kw_default)) {

(tok::colon, tok::r_paren, tok::annot_pragma_openmp_end,

.consumeClose();

HasMapType =

;

StringRef PreMapName =

;

(TypeModifier == OMPC_MAP_MODIFIER_always ||

TypeModifier == OMPC_MAP_MODIFIER_close ||

TypeModifier == OMPC_MAP_MODIFIER_present ||

TypeModifier == OMPC_MAP_MODIFIER_ompx_hold) {

.MapTypeModifiers.push_back(TypeModifier);

<<

;

}

(TypeModifier == OMPC_MAP_MODIFIER_mapper) {

.MapTypeModifiers.push_back(TypeModifier);

(Tok.

(tok::comma) && Tok.

(tok::colon) &&

(

.MapTypeModifiersLoc.back(), diag::err_omp_missing_comma)

<<

;

.ExtraModifier = MapKind;

(Tok, diag::err_omp_more_one_map_type);

(PreMapLoc, diag::note_previous_map_type_specified_here)

(Tok.

(tok::comma)) {

(Tok, diag::err_omp_map_type_modifier_missing);

(Tok, diag::err_omp_unknown_map_type_modifier)

(

().OpenMP >= 60 && !HasMapType) {

(!Tok.

(tok::colon)) {

(Tok, diag::err_omp_unknown_map_type);

Tok =

.getCurToken();

(!Tok.

(tok::identifier, tok::kw_delete))

(MapType == OMPC_MAP_to || MapType == OMPC_MAP_from ||

MapType == OMPC_MAP_tofrom || MapType == OMPC_MAP_alloc ||

MapType == OMPC_MAP_delete || MapType == OMPC_MAP_release)

Tok =

.getCurToken();

(Tok.

(tok::colon)) {

.Diag(Tok, diag::err_omp_map_type_missing);

.Diag(Tok, diag::err_omp_unknown_map_type);

Parser::ParseOpenMPIteratorsExpr() {

assert(Tok.

(tok::identifier) && PP.

(Tok) ==

&&

);

(

.expectAndConsume(diag::err_expected_lparen_after,

))

(Tok.

(tok::r_paren) && Tok.

(tok::annot_pragma_openmp_end)) {

(Tok.

(tok::identifier) ||

().isNot(tok::equal)) {

IteratorType = TR.

();

(Tok.

(tok::identifier)) {

(Tok, diag::err_expected_unqualified_id) << 0;

(Tok.

(tok::equal))

(Tok, diag::err_omp_expected_equal_in_iterator);

LHS = ParseCastExpression(AnyCastExpr);

(Tok.

(tok::colon))

LHS = ParseCastExpression(AnyCastExpr);

(Tok.

(tok::colon)) {

LHS = ParseCastExpression(AnyCastExpr);

(Tok.

(tok::comma) && Tok.

(tok::r_paren))

(Tok, diag::err_omp_expected_punc_after_iterator);

(Tok.

(tok::comma))

.DeclIdentLoc = IdLoc;

.Type = IteratorType;

.AssignLoc = AssignLoc;

.ColonLoc = ColonLoc;

.SecColonLoc = SecColonLoc;

.Range.Begin =

.get();

.Range.End = End.get();

.Range.Step = Step.

();

(!

.consumeClose())

RLoc =

.getCloseLocation();

(Kind != OMPC_depend || LangOpts.OpenMP < 51)

(Tok.

(tok::identifier) &&

(

.ExtraModifier == OMPC_DEPEND_outallmemory ||

.ExtraModifier == OMPC_DEPEND_inoutallmemory)

(Tok, diag::warn_omp_more_one_omp_all_memory);

(

.ExtraModifier != OMPC_DEPEND_out &&

.ExtraModifier != OMPC_DEPEND_inout)

(Tok, diag::err_omp_requires_out_inout_depend_type);

.ExtraModifier =

.ExtraModifier == OMPC_DEPEND_out

? OMPC_DEPEND_outallmemory

: OMPC_DEPEND_inoutallmemory;

&Actions =

.getActions();

.DepModOrTailExpr = Tail.

();

CurTok =

.getCurToken();

(CurTok.

(tok::r_paren) && CurTok.

(tok::comma)) {

.Diag(CurTok, diag::err_expected_punc) <<

;

&Tok =

.getCurToken();

AllocatorSeen =

;

AlignSeen =

;

(

.getLangOpts().OpenMP < 51)

.ParseAssignmentExpression();

.ParseAssignmentExpression();

(Tok.

(tok::l_paren)) {

(CurrentModifier) {

OMPC_ALLOCATE_allocator: {

(AllocatorSeen) {

.Diag(Tok, diag::err_omp_duplicate_modifier)

<< getOpenMPClauseName(Kind);

.AllocClauseModifiers.push_back(CurrentModifier);

.AllocClauseModifiersLoc.push_back(CurrentModifierLoc);

tok::annot_pragma_openmp_end);

Tail =

.ParseAssignmentExpression();

AllocatorSeen =

;

OMPC_ALLOCATE_align: {

.Diag(Tok, diag::err_omp_duplicate_modifier)

<< getOpenMPClauseName(Kind);

.AllocClauseModifiers.push_back(CurrentModifier);

.AllocClauseModifiersLoc.push_back(CurrentModifierLoc);

Val =

.ParseOpenMPParensExpr(getOpenMPClauseName(Kind), RLoc);

.AllocateAlignment = Val.

();

llvm_unreachable(

);

.Diag(Tok, diag::err_expected) << tok::l_paren;

(Tok.

(tok::comma))

.Diag(Tok, diag::err_omp_expected_modifier) << getOpenMPClauseName(Kind);

}

(!AllocatorSeen || !AlignSeen);

InvalidReductionId =

;

IsInvalidMapperModifier =

;

(

.expectAndConsume(diag::err_expected_lparen_after,

getOpenMPClauseName(Kind).data()))

HasIterator =

;

InvalidIterator =

;

NeedRParenForLinear =

;

tok::annot_pragma_openmp_end);

(Kind == OMPC_reduction || Kind == OMPC_task_reduction ||

Kind == OMPC_in_reduction) {

(Kind == OMPC_reduction &&

().OpenMP >= 50 &&

(Tok.

(tok::identifier) || Tok.

(tok::kw_default)) &&

.ExtraModifier =

assert(Tok.

(tok::comma) &&

);

ParseOptionalCXXScopeSpecifier(

.ReductionOrMapperIdScopeSpec,

*

,

.ReductionOrMapperIdScopeSpec, UnqualifiedReductionId);

(InvalidReductionId) {

(tok::colon, tok::r_paren, tok::annot_pragma_openmp_end,

(Tok.

(tok::colon))

(Tok, diag::warn_pragma_expected_colon) <<

;

(!InvalidReductionId)

.ReductionOrMapperId =

}

(Kind == OMPC_depend || Kind == OMPC_doacross) {

(Tok.

(tok::identifier) && PP.

(Tok) ==

) {

HasIterator =

;

IteratorRes = ParseOpenMPIteratorsExpr();

.DepModOrTailExpr = IteratorRes.

();

ExpectAndConsume(tok::comma);

Kind, Tok.

(tok::identifier) ? PP.

(Tok) :

,

(Kind == OMPC_doacross &&

(tok::colon, tok::r_paren, tok::annot_pragma_openmp_end,

(DKind == OMPD_ordered && Kind == OMPC_depend &&

.ExtraModifier == OMPC_DEPEND_source) {

(Tok.

(tok::colon)) {

}

(Kind != OMPC_doacross || Tok.

(tok::r_paren)) {

(Tok, DKind == OMPD_ordered ? diag::warn_pragma_expected_colon_r_paren

: diag::warn_pragma_expected_colon)

<< (Kind == OMPC_depend ?

:

);

(Kind == OMPC_doacross) {

(Tok.

(tok::identifier) &&

.ExtraModifier =

.ExtraModifier == OMPC_DOACROSS_source

? OMPC_DOACROSS_source_omp_cur_iteration

: OMPC_DOACROSS_sink_omp_cur_iteration;

(

.ExtraModifier == OMPC_DOACROSS_sink_omp_cur_iteration) {

(Tok.

(tok::minus)) {

(Tok, diag::err_omp_sink_and_source_iteration_not_allowd)

<< getOpenMPClauseName(Kind) << 0 << 0;

(Tok.

(tok::numeric_constant) ||

(

, diag::err_omp_sink_and_source_iteration_not_allowd)

<< getOpenMPClauseName(Kind) << 0 << 0;

(

.ExtraModifier == OMPC_DOACROSS_source_omp_cur_iteration) {

(Tok.

(tok::r_paren)) {

(Tok, diag::err_omp_sink_and_source_iteration_not_allowd)

<< getOpenMPClauseName(Kind) << 1 << 1;

(Kind == OMPC_doacross &&

(

.ExtraModifier == OMPC_DOACROSS_source ||

.ExtraModifier == OMPC_DOACROSS_source_omp_cur_iteration ||

.ExtraModifier == OMPC_DOACROSS_sink_omp_cur_iteration)) {

}

(Kind == OMPC_linear) {

.ExtraModifier = OMPC_LINEAR_val;

(Tok.

(tok::identifier) && PP.

(0).

(tok::l_paren)) {

.ExtraModifier =

NeedRParenForLinear =

;

(

.ExtraModifierLoc, diag::err_omp_deprecate_old_syntax)

<<

<< getOpenMPClauseName(Kind)

<<

;

}

(Kind == OMPC_lastprivate) {

Tok.

(tok::identifier) && PP.

(0).

(tok::colon)) {

.ExtraModifier =

assert(Tok.

(tok::colon) &&

);

}

(Kind == OMPC_map) {

(Tok.

(tok::identifier) && PP.

(Tok) ==

) {

HasIterator =

;

.MapTypeModifiers.push_back(OMPC_MAP_MODIFIER_iterator);

IteratorRes = ParseOpenMPIteratorsExpr();

.IteratorExpr = IteratorRes.

();

ExpectAndConsume(tok::comma);

(Tok, diag::err_omp_unknown_map_type_modifier)

InvalidIterator =

;

TentativeParsingAction TPA(*

);

ColonPresent =

;

(

(tok::colon, tok::r_paren, tok::annot_pragma_openmp_end,

(Tok.

(tok::colon))

ColonPresent =

;

(Tok, diag::err_omp_map_modifier_specification_list);

(

().OpenMP < 60 && !IsInvalidMapperModifier)

.ExtraModifier = OMPC_MAP_tofrom;

(DKind == OMPD_target_enter_data)

.ExtraModifier = OMPC_MAP_to;

(DKind == OMPD_target_exit_data)

.ExtraModifier = OMPC_MAP_from;

.IsMapTypeImplicit =

;

(Tok.

(tok::colon))

}

(Kind == OMPC_to || Kind == OMPC_from) {

(Tok.

(tok::identifier)) {

.MotionModifiers.push_back(Modifier);

(Modifier == OMPC_MOTION_MODIFIER_mapper) {

(IsInvalidMapperModifier)

(Tok.

(tok::comma))

(!

.MotionModifiers.empty() && Tok.

(tok::colon)) {

(!IsInvalidMapperModifier) {

(Tok, diag::warn_pragma_expected_colon) <<

;

(Tok, diag::warn_pragma_expected_colon) <<

;

(tok::colon, tok::r_paren, tok::annot_pragma_openmp_end,

((!

.MotionModifiers.empty() ||

().OpenMP >= 51) &&

Tok.

(tok::colon))

}

(Kind == OMPC_allocate ||

(Kind == OMPC_affinity && Tok.

(tok::identifier) &&

TentativeParsingAction TPA(*

);

(Kind == OMPC_allocate) {

HasIterator =

;

Tail = ParseOpenMPIteratorsExpr();

(Tok.

(tok::colon)) {

(Kind == OMPC_allocate &&

.AllocClauseModifiers.size()) {

(tok::r_paren, tok::annot_pragma_openmp_end,

(Tok, diag::err_modifier_expected_colon) <<

;

(tok::comma, tok::r_paren, tok::annot_pragma_openmp_end,

}

(Kind == OMPC_adjust_args) {

Kind, Tok.

(tok::identifier) ? PP.

(Tok) :

,

(Tok, diag::err_omp_unknown_adjust_args_op);

(Tok.

(tok::colon))

ExpectAndConsume(tok::colon, diag::warn_pragma_expected_colon,

(Kind != OMPC_reduction && Kind != OMPC_task_reduction &&

Kind != OMPC_in_reduction && Kind != OMPC_depend &&

Kind != OMPC_doacross && Kind != OMPC_map && Kind != OMPC_adjust_args) ||

(Kind == OMPC_reduction && !InvalidReductionId) ||

(Kind == OMPC_adjust_args &&

MayHaveTail = (Kind == OMPC_linear || Kind == OMPC_aligned);

(IsComma || (Tok.

(tok::r_paren) && Tok.

(tok::colon) &&

Tok.

(tok::annot_pragma_openmp_end))) {

Vars.push_back(VarExpr.

());

(tok::comma, tok::r_paren, tok::annot_pragma_openmp_end,

IsComma = Tok.

(tok::comma);

(Tok.

(tok::r_paren) &&

Tok.

(tok::annot_pragma_openmp_end) &&

(!MayHaveTail || Tok.

(tok::colon)))

(Tok, diag::err_omp_expected_punc)

<< ((Kind == OMPC_flush) ? getOpenMPDirectiveName(OMPD_flush)

: getOpenMPClauseName(Kind))

<< (Kind == OMPC_flush);

(NeedRParenForLinear)

MustHaveTail = MayHaveTail && Tok.

(tok::colon);

StepFound =

;

ModifierFound =

;

(

().OpenMP >= 52 && Kind == OMPC_linear) {

(Tok.

(tok::r_paren)) {

(Tok.

(tok::identifier)) {

(LinKind == OMPC_LINEAR_step) {

(Tok, diag::err_omp_multiple_step_or_linear_modifier) << 0;

tok::annot_pragma_openmp_end);

(StepModifierLoc, diag::err_expected_lparen_after) <<

;

.StepModifierLoc = StepModifierLoc;

}

(LinKind >= 0 && LinKind < OMPC_LINEAR_step) {

(Tok, diag::err_omp_multiple_step_or_linear_modifier) << 1;

.ExtraModifier = LinKind;

ModifierFound =

;

(Tok.

(tok::comma))

(Tok.

(tok::r_paren) || Tok.

(tok::annot_pragma_openmp_end))

(!StepFound && !ModifierFound)

(ELoc, diag::err_expected_expression);

.DepModOrTailExpr = Tail.

();

(tok::comma, tok::r_paren, tok::annot_pragma_openmp_end,

(!

.consumeClose())

.RLoc =

.getCloseLocation();

(Kind != OMPC_depend && Kind != OMPC_doacross && Kind != OMPC_map &&

(MustHaveTail && !

.DepModOrTailExpr && StepFound) ||

InvalidReductionId || IsInvalidMapperModifier || InvalidIterator;

assert(getOpenMPClauseName(Kind) == PP.

(Tok) &&

);

(

.consumeOpen()) {

(Tok, diag::err_expected) << tok::l_paren;

Exprs.push_back(Val.

());

=

.consumeClose();

OpenLoc =

.getOpenLocation();

CloseLoc =

.getCloseLocation();

Defines the clang::ASTContext interface.

This file defines OpenMP AST classes for clauses.

Defines some OpenMP-specific enums and functions.

static OpenMPDirectiveKindExWrapper parseOpenMPDirectiveKind(Parser &P)

static OpenMPMapModifierKind isMapModifier(Parser &P)

Checks if the token is a valid map-type-modifier.

static std::optional< SimpleClauseData > parseOpenMPSimpleClause(Parser &P, OpenMPClauseKind Kind)

static unsigned getOpenMPDirectiveKindEx(StringRef S)

static bool checkExtensionProperty(Parser &P, SourceLocation Loc, OMPTraitProperty &TIProperty, OMPTraitSelector &TISelector, llvm::StringMap< SourceLocation > &Seen)

static ExprResult parseOpenMPAllocateClauseModifiers(Parser &P, OpenMPClauseKind Kind, SemaOpenMP::OpenMPVarListDataTy &Data)

Parse 'allocate' clause modifiers.

static DeclarationName parseOpenMPReductionId(Parser &P)

static ExprResult parseContextScore(Parser &P)

Parse optional 'score' '(' <expr> ')' ':'.

static bool ParseReductionId(Parser &P, CXXScopeSpec &ReductionIdScopeSpec, UnqualifiedId &ReductionId)

static bool parseStepSize(Parser &P, SemaOpenMP::OpenMPVarListDataTy &Data, OpenMPClauseKind CKind, SourceLocation ELoc)

Parse step size expression.

static void parseMapType(Parser &P, SemaOpenMP::OpenMPVarListDataTy &Data)

Parse map-type in map clause.

static bool parseDeclareSimdClauses(Parser &P, OMPDeclareSimdDeclAttr::BranchStateTy &BS, ExprResult &SimdLen, SmallVectorImpl< Expr * > &Uniforms, SmallVectorImpl< Expr * > &Aligneds, SmallVectorImpl< Expr * > &Alignments, SmallVectorImpl< Expr * > &Linears, SmallVectorImpl< unsigned > &LinModifiers, SmallVectorImpl< Expr * > &Steps)

Parses clauses for 'declare simd' directive.

static OpenMPMapClauseKind isMapType(Parser &P)

Checks if the token is a valid map-type.

This file declares semantic analysis functions specific to AMDGPU.

This file declares facilities that support code completion.

This file declares semantic analysis for OpenMP constructs and clauses.

This file defines OpenMP AST classes for executable directives and clauses.

Defines the clang::TokenKind enum and support functions.

Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...

DeclarationNameTable DeclarationNames

OMPTraitInfo & getNewOMPTraitInfo()

Return a new OMPTraitInfo object owned by this context.

RAII class that helps handle the parsing of an open/close delimiter pair, such as braces { ....

Represents a C++ nested-name-specifier or a global scope specifier.

bool isEmpty() const

No scope specifier.

ColonProtectionRAIIObject - This sets the Parser::ColonIsSacred bool and restores it when destroyed.

Captures information about "declaration specifiers".

static const TST TST_unspecified

Decl - This represents one declaration (or definition), e.g.

bool isFunctionOrFunctionTemplate() const

Whether this declaration is a function or function template.

SourceLocation getLocation() const

DeclContext * getDeclContext()

The name of a declaration.

Information about one declarator, including the parsed type information and the identifier.

RAII object that enters a new expression evaluation context.

bool isValueDependent() const

Determines whether the value of this expression depends on.

bool isTypeDependent() const

Determines whether the type of this expression depends on.

bool containsUnexpandedParameterPack() const

Whether this expression contains an unexpanded parameter pack (for C++11 variadic templates).

bool isInstantiationDependent() const

Whether this expression is instantiation-dependent, meaning that it depends in some way on.

One of these records is kept for each identifier that is lexed.

bool isStr(const char(&Str)[StrLen]) const

Return true if this is the identifier for the specified string.

StringRef getName() const

Return the actual identifier string.

IdentifierInfo & get(StringRef Name)

Return the identifier token info for the specified named identifier.

Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...

This represents a decl that may have a name.

bool isCXXInstanceMember() const

Determine whether the given declaration is an instance member of a C++ class.

This is a basic class for representing single OpenMP clause.

Helper data structure representing the traits in a match clause of an declare variant or metadirectiv...

void getAsVariantMatchInfo(ASTContext &ASTCtx, llvm::omp::VariantMatchInfo &VMI) const

Create a variant match info object from this trait info object.

llvm::SmallVector< OMPTraitSet, 2 > Sets

The outermost level of selector sets.

Wrapper for void* pointer.

RAII object that makes sure paren/bracket/brace count is correct after declaration/statement parsing,...

ParsedAttr - Represents a syntactic attribute.

static const ParsedAttributesView & none()

ParsedAttributes - A collection of parsed attributes.

Introduces zero or more scopes for parsing.

ParseScope - Introduces a new scope for parsing.

Parser - This implements a parser for the C family of languages.

bool ParseOpenMPVarList(OpenMPDirectiveKind DKind, OpenMPClauseKind Kind, SmallVectorImpl< Expr * > &Vars, SemaOpenMP::OpenMPVarListDataTy &Data)

Parses clauses with list.

TypeResult ParseTypeName(SourceRange *Range=nullptr, DeclaratorContext Context=DeclaratorContext::TypeName, AccessSpecifier AS=AS_none, Decl **OwnedType=nullptr, ParsedAttributes *Attrs=nullptr)

ParseTypeName type-name: [C99 6.7.6] specifier-qualifier-list abstract-declarator[opt].

DiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)

bool parseMapTypeModifiers(SemaOpenMP::OpenMPVarListDataTy &Data)

Parses map-type-modifiers in map clause.

SourceLocation ConsumeToken()

ConsumeToken - Consume the current 'peek token' and lex the next one.

void EnterScope(unsigned ScopeFlags)

EnterScope - Start a new scope.

bool parseMapperModifier(SemaOpenMP::OpenMPVarListDataTy &Data)

Parses the mapper modifier in map, to, and from clauses.

bool ParseUnqualifiedId(CXXScopeSpec &SS, ParsedType ObjectType, bool ObjectHadErrors, bool EnteringContext, bool AllowDestructorName, bool AllowConstructorName, bool AllowDeductionGuide, SourceLocation *TemplateKWLoc, UnqualifiedId &Result)

Parse a C++ unqualified-id (or a C identifier), which describes the name of an entity.

SourceLocation ConsumeAnyToken(bool ConsumeCodeCompletionTok=false)

ConsumeAnyToken - Dispatch to the right Consume* method based on the current token type.

ExprResult ParseConstantExpression()

bool TryConsumeToken(tok::TokenKind Expected)

OpaquePtr< DeclGroupRef > DeclGroupPtrTy

Scope * getCurScope() const

bool SkipUntil(tok::TokenKind T, SkipUntilFlags Flags=static_cast< SkipUntilFlags >(0))

SkipUntil - Read tokens until we get to the specified token, then consume it (unless StopBeforeMatch ...

const Token & getCurToken() const

void ExitScope()

ExitScope - Pop a scope off the scope stack.

ExprResult ParseAssignmentExpression(TypeCastState isTypeCast=NotTypeCast)

Parse an expr that doesn't include (top-level) commas.

ExprResult ParseOpenMPParensExpr(StringRef ClauseName, SourceLocation &RLoc, bool IsAddressOfOperand=false)

Parses simple expression in parens for single-expression clauses of OpenMP constructs.

const LangOptions & getLangOpts() const

ExprResult ParseExpression(TypeCastState isTypeCast=NotTypeCast)

Simple precedence-based parser for binary/ternary operators.

@ StopBeforeMatch

Stop skipping at specified token, but don't skip the token itself.

bool ParseOpenMPReservedLocator(OpenMPClauseKind Kind, SemaOpenMP::OpenMPVarListDataTy &Data, const LangOptions &LangOpts)

Parses a reserved locator like 'omp_all_memory'.

const Token & NextToken()

NextToken - This peeks ahead one token and returns it without consuming it.

A class for parsing a DeclSpec.

Activates OpenMP parsing mode to preseve OpenMP specific annotation tokens.

void enterVariableInit(SourceLocation Tok, Decl *D)

Engages in a tight little dance with the lexer to efficiently preprocess tokens.

void EnterToken(const Token &Tok, bool IsReinject)

Enters a token in the token stream to be lexed next.

const Token & LookAhead(unsigned N)

Peeks ahead N tokens and returns that token without consuming any tokens.

bool parseSimpleIntegerLiteral(Token &Tok, uint64_t &Value)

Parses a simple integer literal to get its numeric value.

StringRef getSpelling(SourceLocation loc, SmallVectorImpl< char > &buffer, bool *invalid=nullptr) const

Return the 'spelling' of the token at the given location; does not go up to the spelling location or ...

bool isCodeCompletionReached() const

Returns true if code-completion is enabled and we have hit the code-completion point.

A (possibly-)qualified type.

bool isNull() const

Return true if this QualType doesn't point to a type yet.

The collection of all-type qualifiers we support.

Represents a struct/union/class.

Scope - A scope is a transient data structure that is used while parsing the program.

@ OpenMPDirectiveScope

This is the scope of OpenMP executable directive.

@ CompoundStmtScope

This is a compound statement scope.

@ OpenMPSimdDirectiveScope

This is the scope of some OpenMP simd directive.

@ FnScope

This indicates that the scope corresponds to a function, which means that labels are set here.

@ OpenMPLoopDirectiveScope

This is the scope of some OpenMP loop directive.

@ DeclScope

This is a scope that can contain a declaration.

Smart pointer class that efficiently represents Objective-C method names.

AMDGPUWavesPerEUAttr * CreateAMDGPUWavesPerEUAttr(const AttributeCommonInfo &CI, Expr *Min, Expr *Max)

Create an AMDGPUWavesPerEUAttr attribute.

AMDGPUFlatWorkGroupSizeAttr * CreateAMDGPUFlatWorkGroupSizeAttr(const AttributeCommonInfo &CI, Expr *Min, Expr *Max)

Create an AMDGPUWavesPerEUAttr attribute.

QualType ProduceConstructorSignatureHelp(QualType Type, SourceLocation Loc, ArrayRef< Expr * > Args, SourceLocation OpenParLoc, bool Braced)

void CodeCompleteInitializer(Scope *S, Decl *D)

DeclGroupPtrTy ActOnOpenMPDeclareReductionDirectiveEnd(Scope *S, DeclGroupPtrTy DeclReductions, bool IsValid)

Called at the end of '#pragma omp declare reduction'.

void ActOnOpenMPDeclareReductionCombinerEnd(Decl *D, Expr *Combiner)

Finish current declare reduction construct initializer.

OMPClause * ActOnOpenMPUseClause(Expr *InteropVar, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation VarLoc, SourceLocation EndLoc)

Called on well-formed 'use' clause.

void ActOnFinishedOpenMPDeclareTargetContext(DeclareTargetContextInfo &DTCI)

Called once a target context is completed, that can be when a '#pragma omp end declare target' was en...

OMPClause * ActOnOpenMPDirectivePresenceClause(OpenMPClauseKind CK, llvm::ArrayRef< OpenMPDirectiveKind > DKVec, SourceLocation Loc, SourceLocation LLoc, SourceLocation RLoc)

Called on well-formed 'absent' or 'contains' clauses.

void StartOpenMPClause(OpenMPClauseKind K)

Start analysis of clauses.

ExprResult ActOnOpenMPDeclareMapperDirectiveVarDecl(Scope *S, QualType MapperType, SourceLocation StartLoc, DeclarationName VN)

Build the mapper variable of '#pragma omp declare mapper'.

StmtResult ActOnOpenMPErrorDirective(ArrayRef< OMPClause * > Clauses, SourceLocation StartLoc, SourceLocation EndLoc, bool InExContext=true)

Called on well-formed '#pragma omp error'.

DeclGroupPtrTy ActOnOpenMPRequiresDirective(SourceLocation Loc, ArrayRef< OMPClause * > ClauseList)

Called on well-formed '#pragma omp requires'.

OMPClause * ActOnOpenMPSingleExprWithArgClause(OpenMPClauseKind Kind, ArrayRef< unsigned > Arguments, Expr *Expr, SourceLocation StartLoc, SourceLocation LParenLoc, ArrayRef< SourceLocation > ArgumentsLoc, SourceLocation DelimLoc, SourceLocation EndLoc)

OMPClause * ActOnOpenMPPermutationClause(ArrayRef< Expr * > PermExprs, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc)

Called on well-form 'permutation' clause after parsing its arguments.

OMPClause * ActOnOpenMPDestroyClause(Expr *InteropVar, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation VarLoc, SourceLocation EndLoc)

Called on well-formed 'destroy' clause.

VarDecl * ActOnOpenMPDeclareReductionInitializerStart(Scope *S, Decl *D)

Initialize declare reduction construct initializer.

void ActOnOpenMPEndAssumesDirective()

Called on well-formed '#pragma omp end assumes'.

QualType ActOnOpenMPDeclareReductionType(SourceLocation TyLoc, TypeResult ParsedType)

Check if the specified type is allowed to be used in 'omp declare reduction' construct.

DeclGroupPtrTy ActOnOpenMPAllocateDirective(SourceLocation Loc, ArrayRef< Expr * > VarList, ArrayRef< OMPClause * > Clauses, DeclContext *Owner=nullptr)

Called on well-formed '#pragma omp allocate'.

OMPClause * ActOnOpenMPSimpleClause(OpenMPClauseKind Kind, unsigned Argument, SourceLocation ArgumentLoc, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc)

bool isInOpenMPDeclareVariantScope() const

Can we exit an OpenMP declare variant scope at the moment.

TypeResult ActOnOpenMPDeclareMapperVarDecl(Scope *S, Declarator &D)

Check variable declaration in 'omp declare mapper' construct.

ExprResult ActOnOMPIteratorExpr(Scope *S, SourceLocation IteratorKwLoc, SourceLocation LLoc, SourceLocation RLoc, ArrayRef< OMPIteratorData > Data)

OMPClause * ActOnOpenMPUsesAllocatorClause(SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc, ArrayRef< UsesAllocatorsData > Data)

Called on well-formed 'uses_allocators' clause.

StmtResult ActOnOpenMPRegionEnd(StmtResult S, ArrayRef< OMPClause * > Clauses)

End of OpenMP region.

DeclGroupPtrTy ActOnOpenMPDeclareReductionDirectiveStart(Scope *S, DeclContext *DC, DeclarationName Name, ArrayRef< std::pair< QualType, SourceLocation > > ReductionTypes, AccessSpecifier AS, Decl *PrevDeclInScope=nullptr)

Called on start of '#pragma omp declare reduction'.

void ActOnOpenMPEndDeclareVariant()

Handle a omp end declare variant.

void EndOpenMPDSABlock(Stmt *CurDirective)

Called on end of data sharing attribute block.

OMPClause * ActOnOpenMPSizesClause(ArrayRef< Expr * > SizeExprs, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc)

Called on well-form 'sizes' clause.

bool ActOnStartOpenMPDeclareTargetContext(DeclareTargetContextInfo &DTCI)

Called on the start of target region i.e. '#pragma omp declare target'.

StmtResult ActOnOpenMPExecutableDirective(OpenMPDirectiveKind Kind, const DeclarationNameInfo &DirName, OpenMPDirectiveKind CancelRegion, ArrayRef< OMPClause * > Clauses, Stmt *AStmt, SourceLocation StartLoc, SourceLocation EndLoc)

void EndOpenMPClause()

End analysis of clauses.

bool isInOpenMPAssumeScope() const

Check if there is an active global omp begin assumes directive.

QualType ActOnOpenMPDeclareMapperType(SourceLocation TyLoc, TypeResult ParsedType)

Check if the specified type is allowed to be used in 'omp declare mapper' construct.

std::optional< std::pair< FunctionDecl *, Expr * > > checkOpenMPDeclareVariantFunction(DeclGroupPtrTy DG, Expr *VariantRef, OMPTraitInfo &TI, unsigned NumAppendArgs, SourceRange SR)

Checks '#pragma omp declare variant' variant function and original functions after parsing of the ass...

StmtResult ActOnOpenMPInformationalDirective(OpenMPDirectiveKind Kind, const DeclarationNameInfo &DirName, ArrayRef< OMPClause * > Clauses, Stmt *AStmt, SourceLocation StartLoc, SourceLocation EndLoc)

Process an OpenMP informational directive.

OMPClause * ActOnOpenMPSingleExprClause(OpenMPClauseKind Kind, Expr *Expr, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc)

OMPClause * ActOnOpenMPNullaryAssumptionClause(OpenMPClauseKind CK, SourceLocation Loc, SourceLocation RLoc)

OMPClause * ActOnOpenMPInitClause(Expr *InteropVar, OMPInteropInfo &InteropInfo, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation VarLoc, SourceLocation EndLoc)

Called on well-formed 'init' clause.

void ActOnOpenMPDeclareReductionCombinerStart(Scope *S, Decl *D)

Initialize declare reduction construct initializer.

bool isInOpenMPDeclareTargetContext() const

Return true inside OpenMP declare target region.

OMPClause * ActOnOpenMPVarListClause(OpenMPClauseKind Kind, ArrayRef< Expr * > Vars, const OMPVarListLocTy &Locs, OpenMPVarListDataTy &Data)

void StartOpenMPDSABlock(OpenMPDirectiveKind K, const DeclarationNameInfo &DirName, Scope *CurScope, SourceLocation Loc)

Called on start of new data sharing attribute block.

void ActOnOpenMPDeclareVariantDirective(FunctionDecl *FD, Expr *VariantRef, OMPTraitInfo &TI, ArrayRef< Expr * > AdjustArgsNothing, ArrayRef< Expr * > AdjustArgsNeedDevicePtr, ArrayRef< OMPInteropInfo > AppendArgs, SourceLocation AdjustArgsLoc, SourceLocation AppendArgsLoc, SourceRange SR)

Called on well-formed '#pragma omp declare variant' after parsing of the associated method/function.

void ActOnOpenMPDeclareReductionInitializerEnd(Decl *D, Expr *Initializer, VarDecl *OmpPrivParm)

Finish current declare reduction construct initializer.

DeclGroupPtrTy ActOnOpenMPDeclareSimdDirective(DeclGroupPtrTy DG, OMPDeclareSimdDeclAttr::BranchStateTy BS, Expr *Simdlen, ArrayRef< Expr * > Uniforms, ArrayRef< Expr * > Aligneds, ArrayRef< Expr * > Alignments, ArrayRef< Expr * > Linears, ArrayRef< unsigned > LinModifiers, ArrayRef< Expr * > Steps, SourceRange SR)

Called on well-formed '#pragma omp declare simd' after parsing of the associated method/function.

OMPClause * ActOnOpenMPXAttributeClause(ArrayRef< const Attr * > Attrs, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc)

Called on a well-formed 'ompx_attribute' clause.

DeclGroupPtrTy ActOnOpenMPThreadprivateDirective(SourceLocation Loc, ArrayRef< Expr * > VarList)

Called on well-formed '#pragma omp threadprivate'.

void ActOnOpenMPRegionStart(OpenMPDirectiveKind DKind, Scope *CurScope)

Initialization of captured region for OpenMP region.

NamedDecl * lookupOpenMPDeclareTargetName(Scope *CurScope, CXXScopeSpec &ScopeSpec, const DeclarationNameInfo &Id)

Searches for the provided declaration name for OpenMP declare target directive.

void ActOnOpenMPAssumesDirective(SourceLocation Loc, OpenMPDirectiveKind DKind, ArrayRef< std::string > Assumptions, bool SkippedClauses)

Called on well-formed '#pragma omp [begin] assume[s]'.

void ActOnOpenMPBeginDeclareVariant(SourceLocation Loc, OMPTraitInfo &TI)

Handle a omp begin declare variant.

StmtResult ActOnOpenMPLoopnest(Stmt *AStmt)

Process a canonical OpenMP loop nest that can either be a canonical literal loop (ForStmt or CXXForRa...

const DeclareTargetContextInfo ActOnOpenMPEndDeclareTargetDirective()

Called at the end of target region i.e. '#pragma omp end declare target'.

OMPClause * ActOnOpenMPClause(OpenMPClauseKind Kind, SourceLocation StartLoc, SourceLocation EndLoc)

DeclGroupPtrTy ActOnOpenMPDeclareMapperDirective(Scope *S, DeclContext *DC, DeclarationName Name, QualType MapperType, SourceLocation StartLoc, DeclarationName VN, AccessSpecifier AS, Expr *MapperVarRef, ArrayRef< OMPClause * > Clauses, Decl *PrevDeclInScope=nullptr)

Called on start of '#pragma omp declare mapper'.

RAII object used to temporarily allow the C++ 'this' expression to be used, with the given qualifiers...

A RAII object to enter scope of a compound statement.

Sema - This implements semantic analysis and AST building for C.

Scope * getCurScope() const

Retrieve the parser's current scope.

ExprResult CheckBooleanCondition(SourceLocation Loc, Expr *E, bool IsConstexpr=false)

CheckBooleanCondition - Diagnose problems involving the use of the given expression as a boolean cond...

ExprResult VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result, VerifyICEDiagnoser &Diagnoser, AllowFoldKind CanFold=NoFold)

VerifyIntegerConstantExpression - Verifies that an expression is an ICE, and reports the appropriate ...

void ActOnReenterFunctionContext(Scope *S, Decl *D)

Push the parameters of D, which must be a function, into scope.

void FinalizeDeclaration(Decl *D)

FinalizeDeclaration - called by ParseDeclarationAfterDeclarator to perform any semantic actions neces...

DeclarationNameInfo GetNameForDeclarator(Declarator &D)

GetNameForDeclarator - Determine the full declaration name for the given Declarator.

ASTContext & getASTContext() const

ExprResult ActOnParenListExpr(SourceLocation L, SourceLocation R, MultiExprArg Val)

SemaCodeCompletion & CodeCompletion()

DeclContext * getCurLexicalContext() const

DeclGroupPtrTy BuildDeclaratorGroup(MutableArrayRef< Decl * > Group)

BuildDeclaratorGroup - convert a list of declarations into a declaration group, performing any necess...

DeclarationNameInfo GetNameFromUnqualifiedId(const UnqualifiedId &Name)

Retrieves the declaration name from a parsed unqualified-id.

void ActOnInitializerError(Decl *Dcl)

ActOnInitializerError - Given that there was an error parsing an initializer for the given declaratio...

@ Unevaluated

The current expression and its subexpressions occur within an unevaluated operand (C++11 [expr]p7),...

StmtResult ActOnDeclStmt(DeclGroupPtrTy Decl, SourceLocation StartLoc, SourceLocation EndLoc)

void ActOnUninitializedDecl(Decl *dcl)

void AddInitializerToDecl(Decl *dcl, Expr *init, bool DirectInit)

AddInitializerToDecl - Adds the initializer Init to the declaration dcl.

CUDALaunchBoundsAttr * CreateLaunchBoundsAttr(const AttributeCommonInfo &CI, Expr *MaxThreads, Expr *MinBlocks, Expr *MaxBlocks)

Create an CUDALaunchBoundsAttr attribute.

StmtResult ActOnCompoundStmt(SourceLocation L, SourceLocation R, ArrayRef< Stmt * > Elts, bool isStmtExpr)

ExprResult CorrectDelayedTyposInExpr(Expr *E, VarDecl *InitDecl=nullptr, bool RecoverUncorrectedTypos=false, llvm::function_ref< ExprResult(Expr *)> Filter=[](Expr *E) -> ExprResult { return E;})

Process any TypoExprs in the given Expr and its children, generating diagnostics as appropriate and r...

ExprResult ActOnFinishFullExpr(Expr *Expr, bool DiscardedValue)

Encodes a location in the source.

bool isValid() const

Return true if this is a valid SourceLocation object.

A trivial tuple used to represent a source range.

SourceLocation getBegin() const

StringLiteral - This represents a string literal expression, e.g.

Token - This structure provides full information about a lexed token.

IdentifierInfo * getIdentifierInfo() const

bool isAnyIdentifier() const

Return true if this is a raw identifier (when lexing in raw mode) or a non-keyword identifier (when l...

SourceLocation getEndLoc() const

SourceLocation getLocation() const

Return a source location identifier for the specified offset in the current file.

bool is(tok::TokenKind K) const

is/isNot - Predicates to check if this token is a specific kind, as in "if (Tok.is(tok::l_brace)) {....

tok::TokenKind getKind() const

bool isOneOf(tok::TokenKind K1, tok::TokenKind K2) const

bool isNot(tok::TokenKind K) const

bool isAnnotation() const

Return true if this is any of tok::annot_* kind tokens.

Base wrapper for a particular "section" of type source info.

The base class of the type hierarchy.

QualType getCanonicalTypeInternal() const

Represents a C++ unqualified-id that has been parsed.

void setOperatorFunctionId(SourceLocation OperatorLoc, OverloadedOperatorKind Op, SourceLocation SymbolLocations[3])

Specify that this unqualified-id was parsed as an operator-function-id.

Represents a variable declaration or definition.

Directive - Abstract class representing a parsed verify directive.

Defines the clang::TargetInfo interface.

bool Ret(InterpState &S, CodePtr &PC)

bool isStringLiteral(TokenKind K)

Return true if this is a C or C++ string-literal (or C++11 user-defined-string-literal) token.