llvm-project
4929 строк · 180.3 Кб
1//===--- ParseOpenMP.cpp - OpenMP directives parsing ----------------------===//2//3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.4// See https://llvm.org/LICENSE.txt for license information.5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception6//7//===----------------------------------------------------------------------===//8/// \file9/// This file implements parsing of all OpenMP directives and clauses.10///11//===----------------------------------------------------------------------===//12//===----------------------------------------------------------------------===//37// OpenMP declarative directives.38//===----------------------------------------------------------------------===//39// Helper to unify the enum class OpenMPDirectiveKind with its extension64// the OpenMPDirectiveKindEx enum which allows to use them together as if they65// are unsigned values.66struct OpenMPDirectiveKindExWrapper {67OpenMPDirectiveKindExWrapper(unsigned Value) : Value(Value) {}68OpenMPDirectiveKindExWrapper(OpenMPDirectiveKind DK) : Value(unsigned(DK)) {}69bool operator==(OpenMPDirectiveKindExWrapper V) const {70return Value == V.Value;71}72bool operator!=(OpenMPDirectiveKindExWrapper V) const {73return Value != V.Value;74}75bool operator==(OpenMPDirectiveKind V) const { return Value == unsigned(V); }76bool operator!=(OpenMPDirectiveKind V) const { return Value != unsigned(V); }77bool operator<(OpenMPDirectiveKind V) const { return Value < unsigned(V); }78operator unsigned() const { return Value; }79operator OpenMPDirectiveKind() const { return OpenMPDirectiveKind(Value); }80unsigned Value;81};82// Map token string to extended OMP token kind that are102// OpenMPDirectiveKind + OpenMPDirectiveKindEx.103static unsigned getOpenMPDirectiveKindEx(StringRef S) {104OpenMPDirectiveKindExWrapper DKind = getOpenMPDirectiveKind(S);105if (DKind != OMPD_unknown)106return DKind;107}123}226}278/// Parse 'omp declare reduction' construct.280///281/// declare-reduction-directive:282/// annot_pragma_openmp 'declare' 'reduction'283/// '(' <reduction_id> ':' <type> {',' <type>} ':' <expression> ')'284/// ['initializer' '(' ('omp_priv' '=' <expression>)|<function_call> ')']285/// annot_pragma_openmp_end286/// <reduction_id> is either a base language identifier or one of the following287/// operators: '+', '-', '*', '&', '|', '^', '&&' and '||'.288///289Parser::DeclGroupPtrTy290Parser::ParseOpenMPDeclareReductionDirective(AccessSpecifier AS) {291// Parse '('.292BalancedDelimiterTracker T(*this, tok::l_paren, tok::annot_pragma_openmp_end);293if (T.expectAndConsume(294diag::err_expected_lparen_after,295getOpenMPDirectiveName(OMPD_declare_reduction).data())) {296SkipUntil(tok::annot_pragma_openmp_end, StopBeforeMatch);297return DeclGroupPtrTy();298}299}455}531/// Parses 'omp declare mapper' directive.533///534/// declare-mapper-directive:535/// annot_pragma_openmp 'declare' 'mapper' '(' [<mapper-identifier> ':']536/// <type> <var> ')' [<clause>[[,] <clause>] ... ]537/// annot_pragma_openmp_end538/// <mapper-identifier> and <var> are base language identifiers.539///540Parser::DeclGroupPtrTy541Parser::ParseOpenMPDeclareMapperDirective(AccessSpecifier AS) {542bool IsCorrect = true;543// Parse '('544BalancedDelimiterTracker T(*this, tok::l_paren, tok::annot_pragma_openmp_end);545if (T.expectAndConsume(diag::err_expected_lparen_after,546getOpenMPDirectiveName(OMPD_declare_mapper).data())) {547SkipUntil(tok::annot_pragma_openmp_end, StopBeforeMatch);548return DeclGroupPtrTy();549}550}644}667/// RAII that recreates function context for correct parsing of clauses of670/// 'declare simd' construct.671/// OpenMP, 2.8.2 declare simd Construct672/// The expressions appearing in the clauses of this directive are evaluated in673/// the scope of the arguments of the function declaration or definition.674class FNContextRAII final {675Parser &P;676Sema::CXXThisScopeRAII *ThisScope;677Parser::MultiParseScope Scopes;678bool HasFunScope = false;679FNContextRAII() = delete;680FNContextRAII(const FNContextRAII &) = delete;681FNContextRAII &operator=(const FNContextRAII &) = delete;682/// Parses clauses for 'declare simd' directive.715/// clause:716/// 'inbranch' | 'notinbranch'717/// 'simdlen' '(' <expr> ')'718/// { 'uniform' '(' <argument_list> ')' }719/// { 'aligned '(' <argument_list> [ ':' <alignment> ] ')' }720/// { 'linear '(' <argument_list> [ ':' <step> ] ')' }721static bool parseDeclareSimdClauses(722Parser &P, OMPDeclareSimdDeclAttr::BranchStateTy &BS, ExprResult &SimdLen,723SmallVectorImpl<Expr *> &Uniforms, SmallVectorImpl<Expr *> &Aligneds,724SmallVectorImpl<Expr *> &Alignments, SmallVectorImpl<Expr *> &Linears,725SmallVectorImpl<unsigned> &LinModifiers, SmallVectorImpl<Expr *> &Steps) {726SourceRange BSRange;727const Token &Tok = P.getCurToken();728bool IsError = false;729while (Tok.isNot(tok::annot_pragma_openmp_end)) {730if (Tok.isNot(tok::identifier))731break;732OMPDeclareSimdDeclAttr::BranchStateTy Out;733IdentifierInfo *II = Tok.getIdentifierInfo();734StringRef ClauseName = II->getName();735// Parse 'inranch|notinbranch' clauses.736if (OMPDeclareSimdDeclAttr::ConvertStrToBranchStateTy(ClauseName, Out)) {737if (BS != OMPDeclareSimdDeclAttr::BS_Undefined && BS != Out) {738P.Diag(Tok, diag::err_omp_declare_simd_inbranch_notinbranch)739<< ClauseName740<< OMPDeclareSimdDeclAttr::ConvertBranchStateTyToStr(BS) << BSRange;741IsError = true;742}743BS = Out;744BSRange = SourceRange(Tok.getLocation(), Tok.getEndLoc());745P.ConsumeToken();746} else if (ClauseName == "simdlen") {747if (SimdLen.isUsable()) {748P.Diag(Tok, diag::err_omp_more_one_clause)749<< getOpenMPDirectiveName(OMPD_declare_simd) << ClauseName << 0;750IsError = true;751}752P.ConsumeToken();753SourceLocation RLoc;754SimdLen = P.ParseOpenMPParensExpr(ClauseName, RLoc);755if (SimdLen.isInvalid())756IsError = true;757} else {758OpenMPClauseKind CKind = getOpenMPClauseKind(ClauseName);759if (CKind == OMPC_uniform || CKind == OMPC_aligned ||760CKind == OMPC_linear) {761SemaOpenMP::OpenMPVarListDataTy Data;762SmallVectorImpl<Expr *> *Vars = &Uniforms;763if (CKind == OMPC_aligned) {764Vars = &Aligneds;765} else if (CKind == OMPC_linear) {766Data.ExtraModifier = OMPC_LINEAR_val;767Vars = &Linears;768}769}799/// Parse clauses for '#pragma omp declare simd'.801Parser::DeclGroupPtrTy802Parser::ParseOMPDeclareSimdClauses(Parser::DeclGroupPtrTy Ptr,803CachedTokens &Toks, SourceLocation Loc) {804PP.EnterToken(Tok, /*IsReinject*/ true);805PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true,806/*IsReinject*/ true);807// Consume the previously pushed token.808ConsumeAnyToken(/*ConsumeCodeCompletionTok=*/true);809ConsumeAnyToken(/*ConsumeCodeCompletionTok=*/true);810}833/// Constant used in the diagnostics to distinguish the levels in an OpenMP836/// contexts: selector-set={selector(trait, ...), ...}, ....837enum OMPContextLvl {838CONTEXT_SELECTOR_SET_LVL = 0,839CONTEXT_SELECTOR_LVL = 1,840CONTEXT_TRAIT_LVL = 2,841};842}847}865}882} // namespace883}954}1003}1051}1105/// Parse optional 'score' '(' <expr> ')' ':'.1107static ExprResult parseContextScore(Parser &P) {1108ExprResult ScoreExpr;1109llvm::SmallString<16> Buffer;1110StringRef SelectorName =1111P.getPreprocessor().getSpelling(P.getCurToken(), Buffer);1112if (SelectorName != "score")1113return ScoreExpr;1114(void)P.ConsumeToken();1115SourceLocation RLoc;1116ScoreExpr = P.ParseOpenMPParensExpr(SelectorName, RLoc);1117// Parse ':'1118if (P.getCurToken().is(tok::colon))1119(void)P.ConsumeAnyToken();1120else1121P.Diag(P.getCurToken(), diag::warn_omp_declare_variant_expected)1122<< "':'"1123<< "score expression";1124return ScoreExpr;1125}1126/// Parses an OpenMP context selector.1128///1129/// <trait-selector-name> ['('[<trait-score>] <trait-property> [, <t-p>]* ')']1130void Parser::parseOMPContextSelector(1131OMPTraitSelector &TISelector, llvm::omp::TraitSet Set,1132llvm::StringMap<SourceLocation> &SeenSelectors) {1133unsigned short OuterPC = ParenCount;1134}1238}1297/// Parses an OpenMP context selector set.1299///1300/// <trait-set-selector-name> '=' '{' <trait-selector> [, <trait-selector>]* '}'1301void Parser::parseOMPContextSelectorSet(1302OMPTraitSet &TISet, llvm::StringMap<SourceLocation> &SeenSets) {1303auto OuterBC = BraceCount;1304}1374/// Parse OpenMP context selectors:1376///1377/// <trait-set-selector> [, <trait-set-selector>]*1378bool Parser::parseOMPContextSelectors(SourceLocation Loc, OMPTraitInfo &TI) {1379llvm::StringMap<SourceLocation> SeenSets;1380do {1381OMPTraitSet TISet;1382parseOMPContextSelectorSet(TISet, SeenSets);1383if (TISet.Kind != TraitSet::invalid && !TISet.Selectors.empty())1384TI.Sets.push_back(TISet);1385} while (TryConsumeToken(tok::comma));1386}1389/// Parse clauses for '#pragma omp declare variant ( variant-func-id ) clause'.1391void Parser::ParseOMPDeclareVariantClauses(Parser::DeclGroupPtrTy Ptr,1392CachedTokens &Toks,1393SourceLocation Loc) {1394PP.EnterToken(Tok, /*IsReinject*/ true);1395PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true,1396/*IsReinject*/ true);1397// Consume the previously pushed token.1398ConsumeAnyToken(/*ConsumeCodeCompletionTok=*/true);1399ConsumeAnyToken(/*ConsumeCodeCompletionTok=*/true);1400}1513}1551}1638/// <clause> [clause[ [,] clause] ... ]1640///1641/// clauses: for error directive1642/// 'at' '(' compilation | execution ')'1643/// 'severity' '(' fatal | warning ')'1644/// 'message' '(' msg-string ')'1645/// ....1646void Parser::ParseOpenMPClauses(OpenMPDirectiveKind DKind,1647SmallVectorImpl<OMPClause *> &Clauses,1648SourceLocation Loc) {1649std::bitset<llvm::omp::Clause_enumSize + 1> SeenClauses;1650while (Tok.isNot(tok::annot_pragma_openmp_end)) {1651OpenMPClauseKind CKind = Tok.isAnnotation()1652? OMPC_unknown1653: getOpenMPClauseKind(PP.getSpelling(Tok));1654Actions.OpenMP().StartOpenMPClause(CKind);1655OMPClause *Clause =1656ParseOpenMPClause(DKind, CKind, !SeenClauses[unsigned(CKind)]);1657SkipUntil(tok::comma, tok::identifier, tok::annot_pragma_openmp_end,1658StopBeforeMatch);1659SeenClauses[unsigned(CKind)] = true;1660if (Clause != nullptr)1661Clauses.push_back(Clause);1662if (Tok.is(tok::annot_pragma_openmp_end)) {1663Actions.OpenMP().EndOpenMPClause();1664break;1665}1666// Skip ',' if any.1667if (Tok.is(tok::comma))1668ConsumeToken();1669Actions.OpenMP().EndOpenMPClause();1670}1671}1672/// `omp assumes` or `omp begin/end assumes` <clause> [[,]<clause>]...1674/// where1675///1676/// clause:1677/// 'ext_IMPL_DEFINED'1678/// 'absent' '(' directive-name [, directive-name]* ')'1679/// 'contains' '(' directive-name [, directive-name]* ')'1680/// 'holds' '(' scalar-expression ')'1681/// 'no_openmp'1682/// 'no_openmp_routines'1683/// 'no_parallelism'1684///1685void Parser::ParseOpenMPAssumesDirective(OpenMPDirectiveKind DKind,1686SourceLocation Loc) {1687SmallVector<std::string, 4> Assumptions;1688bool SkippedClauses = false;1689}1765}1772/// Parsing of simple OpenMP clauses like 'default' or 'proc_bind'.1774///1775/// default-clause:1776/// 'default' '(' 'none' | 'shared' | 'private' | 'firstprivate' ')1777///1778/// proc_bind-clause:1779/// 'proc_bind' '(' 'master' | 'close' | 'spread' ')1780///1781/// device_type-clause:1782/// 'device_type' '(' 'host' | 'nohost' | 'any' )'1783namespace {1784struct SimpleClauseData {1785unsigned Type;1786SourceLocation Loc;1787SourceLocation LOpen;1788SourceLocation TypeLoc;1789SourceLocation RLoc;1790SimpleClauseData(unsigned Type, SourceLocation Loc, SourceLocation LOpen,1791SourceLocation TypeLoc, SourceLocation RLoc)1792: Type(Type), Loc(Loc), LOpen(LOpen), TypeLoc(TypeLoc), RLoc(RLoc) {}1793};1794} // anonymous namespace1795}1822}1970}1982}2004}2015/// Parsing of declarative OpenMP directives.2017///2018/// threadprivate-directive:2019/// annot_pragma_openmp 'threadprivate' simple-variable-list2020/// annot_pragma_openmp_end2021///2022/// allocate-directive:2023/// annot_pragma_openmp 'allocate' simple-variable-list [<clause>]2024/// annot_pragma_openmp_end2025///2026/// declare-reduction-directive:2027/// annot_pragma_openmp 'declare' 'reduction' [...]2028/// annot_pragma_openmp_end2029///2030/// declare-mapper-directive:2031/// annot_pragma_openmp 'declare' 'mapper' '(' [<mapper-identifer> ':']2032/// <type> <var> ')' [<clause>[[,] <clause>] ... ]2033/// annot_pragma_openmp_end2034///2035/// declare-simd-directive:2036/// annot_pragma_openmp 'declare simd' {<clause> [,]}2037/// annot_pragma_openmp_end2038/// <function declaration/definition>2039///2040/// requires directive:2041/// annot_pragma_openmp 'requires' <clause> [[[,] <clause>] ... ]2042/// annot_pragma_openmp_end2043///2044/// assumes directive:2045/// annot_pragma_openmp 'assumes' <clause> [[[,] <clause>] ... ]2046/// annot_pragma_openmp_end2047/// or2048/// annot_pragma_openmp 'begin assumes' <clause> [[[,] <clause>] ... ]2049/// annot_pragma_openmp 'end assumes'2050/// annot_pragma_openmp_end2051///2052Parser::DeclGroupPtrTy Parser::ParseOpenMPDeclarativeDirectiveWithExtDecl(2053AccessSpecifier &AS, ParsedAttributes &Attrs, bool Delayed,2054DeclSpec::TST TagType, Decl *Tag) {2055assert(Tok.isOneOf(tok::annot_pragma_openmp, tok::annot_attr_openmp) &&2056"Not an OpenMP directive!");2057ParsingOpenMPDirectiveRAII DirScope(*this);2058ParenBraceBracketBalancer BalancerRAIIObj(*this);2059}2396}2574/// Parsing of declarative or executable OpenMP directives.2576///2577/// threadprivate-directive:2578/// annot_pragma_openmp 'threadprivate' simple-variable-list2579/// annot_pragma_openmp_end2580///2581/// allocate-directive:2582/// annot_pragma_openmp 'allocate' simple-variable-list2583/// annot_pragma_openmp_end2584///2585/// declare-reduction-directive:2586/// annot_pragma_openmp 'declare' 'reduction' '(' <reduction_id> ':'2587/// <type> {',' <type>} ':' <expression> ')' ['initializer' '('2588/// ('omp_priv' '=' <expression>|<function_call>) ')']2589/// annot_pragma_openmp_end2590///2591/// declare-mapper-directive:2592/// annot_pragma_openmp 'declare' 'mapper' '(' [<mapper-identifer> ':']2593/// <type> <var> ')' [<clause>[[,] <clause>] ... ]2594/// annot_pragma_openmp_end2595///2596/// executable-directive:2597/// annot_pragma_openmp 'parallel' | 'simd' | 'for' | 'sections' |2598/// 'section' | 'single' | 'master' | 'critical' [ '(' <name> ')' ] |2599/// 'parallel for' | 'parallel sections' | 'parallel master' | 'task' |2600/// 'taskyield' | 'barrier' | 'taskwait' | 'flush' | 'ordered' | 'error'2601/// | 'atomic' | 'for simd' | 'parallel for simd' | 'target' | 'target2602/// data' | 'taskgroup' | 'teams' | 'taskloop' | 'taskloop simd' |2603/// 'master taskloop' | 'master taskloop simd' | 'parallel master2604/// taskloop' | 'parallel master taskloop simd' | 'distribute' | 'target2605/// enter data' | 'target exit data' | 'target parallel' | 'target2606/// parallel for' | 'target update' | 'distribute parallel for' |2607/// 'distribute paralle for simd' | 'distribute simd' | 'target parallel2608/// for simd' | 'target simd' | 'teams distribute' | 'teams distribute2609/// simd' | 'teams distribute parallel for simd' | 'teams distribute2610/// parallel for' | 'target teams' | 'target teams distribute' | 'target2611/// teams distribute parallel for' | 'target teams distribute parallel2612/// for simd' | 'target teams distribute simd' | 'masked' |2613/// 'parallel masked' {clause} annot_pragma_openmp_end2614///2615StmtResult Parser::ParseOpenMPDeclarativeOrExecutableDirective(2616ParsedStmtContext StmtCtx, bool ReadDirectiveWithinMetadirective) {2617if (!ReadDirectiveWithinMetadirective)2618assert(Tok.isOneOf(tok::annot_pragma_openmp, tok::annot_attr_openmp) &&2619"Not an OpenMP directive!");2620ParsingOpenMPDirectiveRAII DirScope(*this);2621ParenBraceBracketBalancer BalancerRAIIObj(*this);2622SourceLocation Loc = ReadDirectiveWithinMetadirective2623? Tok.getLocation()2624: ConsumeAnnotationToken();2625OpenMPDirectiveKind DKind = parseOpenMPDirectiveKind(*this);2626if (ReadDirectiveWithinMetadirective && DKind == OMPD_unknown) {2627Diag(Tok, diag::err_omp_unknown_directive);2628return StmtError();2629}2630}2929// Parses simple list:2931// simple-variable-list:2932// '(' id-expression {, id-expression} ')'2933//2934bool Parser::ParseOpenMPSimpleVarList(2935OpenMPDirectiveKind Kind,2936const llvm::function_ref<void(CXXScopeSpec &, DeclarationNameInfo)>2937&Callback,2938bool AllowScopeSpecifier) {2939// Parse '('.2940BalancedDelimiterTracker T(*this, tok::l_paren, tok::annot_pragma_openmp_end);2941if (T.expectAndConsume(diag::err_expected_lparen_after,2942getOpenMPDirectiveName(Kind).data()))2943return true;2944bool IsCorrect = true;2945bool NoIdentIsFound = true;2946}2994}3005}3056/// Parsing of OpenMP clauses.3058///3059/// clause:3060/// if-clause | final-clause | num_threads-clause | safelen-clause |3061/// default-clause | private-clause | firstprivate-clause | shared-clause3062/// | linear-clause | aligned-clause | collapse-clause | bind-clause |3063/// lastprivate-clause | reduction-clause | proc_bind-clause |3064/// schedule-clause | copyin-clause | copyprivate-clause | untied-clause |3065/// mergeable-clause | flush-clause | read-clause | write-clause |3066/// update-clause | capture-clause | seq_cst-clause | device-clause |3067/// simdlen-clause | threads-clause | simd-clause | num_teams-clause |3068/// thread_limit-clause | priority-clause | grainsize-clause |3069/// nogroup-clause | num_tasks-clause | hint-clause | to-clause |3070/// from-clause | is_device_ptr-clause | task_reduction-clause |3071/// in_reduction-clause | allocator-clause | allocate-clause |3072/// acq_rel-clause | acquire-clause | release-clause | relaxed-clause |3073/// depobj-clause | destroy-clause | detach-clause | inclusive-clause |3074/// exclusive-clause | uses_allocators-clause | use_device_addr-clause |3075/// has_device_addr3076///3077OMPClause *Parser::ParseOpenMPClause(OpenMPDirectiveKind DKind,3078OpenMPClauseKind CKind, bool FirstClause) {3079OMPClauseKind = CKind;3080OMPClause *Clause = nullptr;3081bool ErrorFound = false;3082bool WrongDirective = false;3083// Check if clause is allowed for the given directive.3084if (CKind != OMPC_unknown &&3085!isAllowedClauseForDirective(DKind, CKind, getLangOpts().OpenMP)) {3086Diag(Tok, diag::err_omp_unexpected_clause)3087<< getOpenMPClauseName(CKind) << getOpenMPDirectiveName(DKind);3088ErrorFound = true;3089WrongDirective = true;3090}3091}3343/// Parses simple expression in parens for single-expression clauses of OpenMP3345/// constructs.3346/// \param RLoc Returned location of right paren.3347ExprResult Parser::ParseOpenMPParensExpr(StringRef ClauseName,3348SourceLocation &RLoc,3349bool IsAddressOfOperand) {3350BalancedDelimiterTracker T(*this, tok::l_paren, tok::annot_pragma_openmp_end);3351if (T.expectAndConsume(diag::err_expected_lparen_after, ClauseName.data()))3352return ExprError();3353}3367/// Parsing of OpenMP clauses with single expressions like 'final',3369/// 'collapse', 'safelen', 'num_threads', 'simdlen', 'num_teams',3370/// 'thread_limit', 'simdlen', 'priority', 'grainsize', 'num_tasks', 'hint' or3371/// 'detach'.3372///3373/// final-clause:3374/// 'final' '(' expression ')'3375///3376/// num_threads-clause:3377/// 'num_threads' '(' expression ')'3378///3379/// safelen-clause:3380/// 'safelen' '(' expression ')'3381///3382/// simdlen-clause:3383/// 'simdlen' '(' expression ')'3384///3385/// collapse-clause:3386/// 'collapse' '(' expression ')'3387///3388/// priority-clause:3389/// 'priority' '(' expression ')'3390///3391/// grainsize-clause:3392/// 'grainsize' '(' expression ')'3393///3394/// num_tasks-clause:3395/// 'num_tasks' '(' expression ')'3396///3397/// hint-clause:3398/// 'hint' '(' expression ')'3399///3400/// allocator-clause:3401/// 'allocator' '(' expression ')'3402///3403/// detach-clause:3404/// 'detach' '(' event-handler-expression ')'3405///3406/// align-clause3407/// 'align' '(' positive-integer-constant ')'3408///3409OMPClause *Parser::ParseOpenMPSingleExprClause(OpenMPClauseKind Kind,3410bool ParseOnly) {3411SourceLocation Loc = ConsumeToken();3412SourceLocation LLoc = Tok.getLocation();3413SourceLocation RLoc;3414}3425/// Parse indirect clause for '#pragma omp declare target' directive.3427/// 'indirect' '[' '(' invoked-by-fptr ')' ']'3428/// where invoked-by-fptr is a constant boolean expression that evaluates to3429/// true or false at compile time.3430bool Parser::ParseOpenMPIndirectClause(3431SemaOpenMP::DeclareTargetContextInfo &DTCI, bool ParseOnly) {3432SourceLocation Loc = ConsumeToken();3433SourceLocation RLoc;3434}3466/// Parses a comma-separated list of interop-types and a prefer_type list.3468///3469bool Parser::ParseOMPInteropInfo(OMPInteropInfo &InteropInfo,3470OpenMPClauseKind Kind) {3471const Token &Tok = getCurToken();3472bool HasError = false;3473bool IsTarget = false;3474bool IsTargetSync = false;3475}3550/// Parsing of OpenMP clauses that use an interop-var.3552///3553/// init-clause:3554/// init([interop-modifier, ]interop-type[[, interop-type] ... ]:interop-var)3555///3556/// destroy-clause:3557/// destroy(interop-var)3558///3559/// use-clause:3560/// use(interop-var)3561///3562/// interop-modifier:3563/// prefer_type(preference-list)3564///3565/// preference-list:3566/// foreign-runtime-id [, foreign-runtime-id]...3567///3568/// foreign-runtime-id:3569/// <string-literal> | <constant-integral-expression>3570///3571/// interop-type:3572/// target | targetsync3573///3574OMPClause *Parser::ParseOpenMPInteropClause(OpenMPClauseKind Kind,3575bool ParseOnly) {3576SourceLocation Loc = ConsumeToken();3577// Parse '('.3578BalancedDelimiterTracker T(*this, tok::l_paren, tok::annot_pragma_openmp_end);3579if (T.expectAndConsume(diag::err_expected_lparen_after,3580getOpenMPClauseName(Kind).data()))3581return nullptr;3582}3619}3676/// Parsing of simple OpenMP clauses like 'default' or 'proc_bind'.3678///3679/// default-clause:3680/// 'default' '(' 'none' | 'shared' | 'private' | 'firstprivate' ')'3681///3682/// proc_bind-clause:3683/// 'proc_bind' '(' 'master' | 'close' | 'spread' ')'3684///3685/// bind-clause:3686/// 'bind' '(' 'teams' | 'parallel' | 'thread' ')'3687///3688/// update-clause:3689/// 'update' '(' 'in' | 'out' | 'inout' | 'mutexinoutset' |3690/// 'inoutset' ')'3691///3692OMPClause *Parser::ParseOpenMPSimpleClause(OpenMPClauseKind Kind,3693bool ParseOnly) {3694std::optional<SimpleClauseData> Val = parseOpenMPSimpleClause(*this, Kind);3695if (!Val || ParseOnly)3696return nullptr;3697if (getLangOpts().OpenMP < 51 && Kind == OMPC_default &&3698(static_cast<DefaultKind>(Val->Type) == OMP_DEFAULT_private ||3699static_cast<DefaultKind>(Val->Type) ==3700OMP_DEFAULT_firstprivate)) {3701Diag(Val->LOpen, diag::err_omp_invalid_dsa)3702<< getOpenMPClauseName(static_cast<DefaultKind>(Val->Type) ==3703OMP_DEFAULT_private3704? OMPC_private3705: OMPC_firstprivate)3706<< getOpenMPClauseName(OMPC_default) << "5.1";3707return nullptr;3708}3709return Actions.OpenMP().ActOnOpenMPSimpleClause(3710Kind, Val->Type, Val->TypeLoc, Val->LOpen, Val->Loc, Val->RLoc);3711}3712/// Parsing of OpenMP clauses like 'ordered'.3714///3715/// ordered-clause:3716/// 'ordered'3717///3718/// nowait-clause:3719/// 'nowait'3720///3721/// untied-clause:3722/// 'untied'3723///3724/// mergeable-clause:3725/// 'mergeable'3726///3727/// read-clause:3728/// 'read'3729///3730/// threads-clause:3731/// 'threads'3732///3733/// simd-clause:3734/// 'simd'3735///3736/// nogroup-clause:3737/// 'nogroup'3738///3739OMPClause *Parser::ParseOpenMPClause(OpenMPClauseKind Kind, bool ParseOnly) {3740SourceLocation Loc = Tok.getLocation();3741ConsumeAnyToken();3742}3747/// Parsing of OpenMP clauses with single expressions and some additional3749/// argument like 'schedule' or 'dist_schedule'.3750///3751/// schedule-clause:3752/// 'schedule' '(' [ modifier [ ',' modifier ] ':' ] kind [',' expression ]3753/// ')'3754///3755/// if-clause:3756/// 'if' '(' [ directive-name-modifier ':' ] expression ')'3757///3758/// defaultmap:3759/// 'defaultmap' '(' modifier [ ':' kind ] ')'3760///3761/// device-clause:3762/// 'device' '(' [ device-modifier ':' ] expression ')'3763///3764OMPClause *Parser::ParseOpenMPSingleExprWithArgClause(OpenMPDirectiveKind DKind,3765OpenMPClauseKind Kind,3766bool ParseOnly) {3767SourceLocation Loc = ConsumeToken();3768SourceLocation DelimLoc;3769// Parse '('.3770BalancedDelimiterTracker T(*this, tok::l_paren, tok::annot_pragma_openmp_end);3771if (T.expectAndConsume(diag::err_expected_lparen_after,3772getOpenMPClauseName(Kind).data()))3773return nullptr;3774}4006}4053/// Checks if the token is a valid map-type-modifier.4055/// FIXME: It will return an OpenMPMapClauseKind if that's what it parses.4056static OpenMPMapModifierKind isMapModifier(Parser &P) {4057Token Tok = P.getCurToken();4058if (!Tok.is(tok::identifier))4059return OMPC_MAP_MODIFIER_unknown;4060}4067/// Parse the mapper modifier in map, to, and from clauses.4069bool Parser::parseMapperModifier(SemaOpenMP::OpenMPVarListDataTy &Data) {4070// Parse '('.4071BalancedDelimiterTracker T(*this, tok::l_paren, tok::colon);4072if (T.expectAndConsume(diag::err_expected_lparen_after, "mapper")) {4073SkipUntil(tok::colon, tok::r_paren, tok::annot_pragma_openmp_end,4074StopBeforeMatch);4075return true;4076}4077// Parse mapper-identifier4078if (getLangOpts().CPlusPlus)4079ParseOptionalCXXScopeSpecifier(Data.ReductionOrMapperIdScopeSpec,4080/*ObjectType=*/nullptr,4081/*ObjectHasErrors=*/false,4082/*EnteringContext=*/false);4083if (Tok.isNot(tok::identifier) && Tok.isNot(tok::kw_default)) {4084Diag(Tok.getLocation(), diag::err_omp_mapper_illegal_identifier);4085SkipUntil(tok::colon, tok::r_paren, tok::annot_pragma_openmp_end,4086StopBeforeMatch);4087return true;4088}4089auto &DeclNames = Actions.getASTContext().DeclarationNames;4090Data.ReductionOrMapperId = DeclarationNameInfo(4091DeclNames.getIdentifier(Tok.getIdentifierInfo()), Tok.getLocation());4092ConsumeToken();4093// Parse ')'.4094return T.consumeClose();4095}4096/// Parse map-type-modifiers in map clause.4100/// map([ [map-type-modifier[,] [map-type-modifier[,] ...] [map-type] : ] list)4101/// where, map-type-modifier ::= always | close | mapper(mapper-identifier) |4102/// present4103/// where, map-type ::= alloc | delete | from | release | to | tofrom4104bool Parser::parseMapTypeModifiers(SemaOpenMP::OpenMPVarListDataTy &Data) {4105bool HasMapType = false;4106SourceLocation PreMapLoc = Tok.getLocation();4107StringRef PreMapName = "";4108while (getCurToken().isNot(tok::colon)) {4109OpenMPMapModifierKind TypeModifier = isMapModifier(*this);4110OpenMPMapClauseKind MapKind = isMapType(*this);4111if (TypeModifier == OMPC_MAP_MODIFIER_always ||4112TypeModifier == OMPC_MAP_MODIFIER_close ||4113TypeModifier == OMPC_MAP_MODIFIER_present ||4114TypeModifier == OMPC_MAP_MODIFIER_ompx_hold) {4115Data.MapTypeModifiers.push_back(TypeModifier);4116Data.MapTypeModifiersLoc.push_back(Tok.getLocation());4117if (PP.LookAhead(0).isNot(tok::comma) &&4118PP.LookAhead(0).isNot(tok::colon) && getLangOpts().OpenMP >= 52)4119Diag(Tok.getLocation(), diag::err_omp_missing_comma)4120<< "map type modifier";4121ConsumeToken();4122} else if (TypeModifier == OMPC_MAP_MODIFIER_mapper) {4123Data.MapTypeModifiers.push_back(TypeModifier);4124Data.MapTypeModifiersLoc.push_back(Tok.getLocation());4125ConsumeToken();4126if (parseMapperModifier(Data))4127return true;4128if (Tok.isNot(tok::comma) && Tok.isNot(tok::colon) &&4129getLangOpts().OpenMP >= 52)4130Diag(Data.MapTypeModifiersLoc.back(), diag::err_omp_missing_comma)4131<< "map type modifier";4132}4183/// Checks if the token is a valid map-type.4185/// If it is not MapType kind, OMPC_MAP_unknown is returned.4186static OpenMPMapClauseKind isMapType(Parser &P) {4187Token Tok = P.getCurToken();4188// The map-type token can be either an identifier or the C++ delete keyword.4189if (!Tok.isOneOf(tok::identifier, tok::kw_delete))4190return OMPC_MAP_unknown;4191Preprocessor &PP = P.getPreprocessor();4192unsigned MapType =4193getOpenMPSimpleClauseType(OMPC_map, PP.getSpelling(Tok), P.getLangOpts());4194if (MapType == OMPC_MAP_to || MapType == OMPC_MAP_from ||4195MapType == OMPC_MAP_tofrom || MapType == OMPC_MAP_alloc ||4196MapType == OMPC_MAP_delete || MapType == OMPC_MAP_release)4197return static_cast<OpenMPMapClauseKind>(MapType);4198return OMPC_MAP_unknown;4199}4200/// Parse map-type in map clause.4202/// map([ [map-type-modifier[,] [map-type-modifier[,] ...] map-type : ] list)4203/// where, map-type ::= to | from | tofrom | alloc | release | delete4204static void parseMapType(Parser &P, SemaOpenMP::OpenMPVarListDataTy &Data) {4205Token Tok = P.getCurToken();4206if (Tok.is(tok::colon)) {4207P.Diag(Tok, diag::err_omp_map_type_missing);4208return;4209}4210Data.ExtraModifier = isMapType(P);4211if (Data.ExtraModifier == OMPC_MAP_unknown)4212P.Diag(Tok, diag::err_omp_unknown_map_type);4213P.ConsumeToken();4214}4215/// Parses simple expression in parens for single-expression clauses of OpenMP4217/// constructs.4218ExprResult Parser::ParseOpenMPIteratorsExpr() {4219assert(Tok.is(tok::identifier) && PP.getSpelling(Tok) == "iterator" &&4220"Expected 'iterator' token.");4221SourceLocation IteratorKwLoc = ConsumeToken();4222}4322}4349/// Parse step size expression. Returns true if parsing is successfull,4351/// otherwise returns false.4352static bool parseStepSize(Parser &P, SemaOpenMP::OpenMPVarListDataTy &Data,4353OpenMPClauseKind CKind, SourceLocation ELoc) {4354ExprResult Tail = P.ParseAssignmentExpression();4355Sema &Actions = P.getActions();4356Tail = Actions.ActOnFinishFullExpr(Tail.get(), ELoc,4357/*DiscardedValue*/ false);4358if (Tail.isUsable()) {4359Data.DepModOrTailExpr = Tail.get();4360Token CurTok = P.getCurToken();4361if (CurTok.isNot(tok::r_paren) && CurTok.isNot(tok::comma)) {4362P.Diag(CurTok, diag::err_expected_punc) << "step expression";4363}4364return true;4365}4366return false;4367}4368/// Parses clauses with list.4370bool Parser::ParseOpenMPVarList(OpenMPDirectiveKind DKind,4371OpenMPClauseKind Kind,4372SmallVectorImpl<Expr *> &Vars,4373SemaOpenMP::OpenMPVarListDataTy &Data) {4374UnqualifiedId UnqualifiedReductionId;4375bool InvalidReductionId = false;4376bool IsInvalidMapperModifier = false;4377}4821/// Parsing of OpenMP clause 'private', 'firstprivate', 'lastprivate',4823/// 'shared', 'copyin', 'copyprivate', 'flush', 'reduction', 'task_reduction',4824/// 'in_reduction', 'nontemporal', 'exclusive' or 'inclusive'.4825///4826/// private-clause:4827/// 'private' '(' list ')'4828/// firstprivate-clause:4829/// 'firstprivate' '(' list ')'4830/// lastprivate-clause:4831/// 'lastprivate' '(' list ')'4832/// shared-clause:4833/// 'shared' '(' list ')'4834/// linear-clause:4835/// 'linear' '(' linear-list [ ':' linear-step ] ')'4836/// aligned-clause:4837/// 'aligned' '(' list [ ':' alignment ] ')'4838/// reduction-clause:4839/// 'reduction' '(' [ modifier ',' ] reduction-identifier ':' list ')'4840/// task_reduction-clause:4841/// 'task_reduction' '(' reduction-identifier ':' list ')'4842/// in_reduction-clause:4843/// 'in_reduction' '(' reduction-identifier ':' list ')'4844/// copyprivate-clause:4845/// 'copyprivate' '(' list ')'4846/// flush-clause:4847/// 'flush' '(' list ')'4848/// depend-clause:4849/// 'depend' '(' in | out | inout : list | source ')'4850/// map-clause:4851/// 'map' '(' [ [ always [,] ] [ close [,] ]4852/// [ mapper '(' mapper-identifier ')' [,] ]4853/// to | from | tofrom | alloc | release | delete ':' ] list ')';4854/// to-clause:4855/// 'to' '(' [ mapper '(' mapper-identifier ')' ':' ] list ')'4856/// from-clause:4857/// 'from' '(' [ mapper '(' mapper-identifier ')' ':' ] list ')'4858/// use_device_ptr-clause:4859/// 'use_device_ptr' '(' list ')'4860/// use_device_addr-clause:4861/// 'use_device_addr' '(' list ')'4862/// is_device_ptr-clause:4863/// 'is_device_ptr' '(' list ')'4864/// has_device_addr-clause:4865/// 'has_device_addr' '(' list ')'4866/// allocate-clause:4867/// 'allocate' '(' [ allocator ':' ] list ')'4868/// nontemporal-clause:4869/// 'nontemporal' '(' list ')'4870/// inclusive-clause:4871/// 'inclusive' '(' list ')'4872/// exclusive-clause:4873/// 'exclusive' '(' list ')'4874///4875/// For 'linear' clause linear-list may have the following forms:4876/// list4877/// modifier(list)4878/// where modifier is 'val' (C) or 'ref', 'val' or 'uval'(C++).4879OMPClause *Parser::ParseOpenMPVarListClause(OpenMPDirectiveKind DKind,4880OpenMPClauseKind Kind,4881bool ParseOnly) {4882SourceLocation Loc = Tok.getLocation();4883SourceLocation LOpen = ConsumeToken();4884SmallVector<Expr *, 4> Vars;4885SemaOpenMP::OpenMPVarListDataTy Data;4886}4895}4930