mirror of
https://github.com/llvm/llvm-project.git
synced 2025-04-27 03:26:06 +00:00
a22236120f
Implementation of the unroll directive introduced in OpenMP 5.1. Follows the approach from D76342 for the tile directive (i.e. AST-based, not using the OpenMPIRBuilder). Tries to use `llvm.loop.unroll.*` metadata where possible, but has to fall back to an AST representation of the outer loop if the partially unrolled generated loop is associated with another directive (because it needs to compute the number of iterations). Reviewed By: ABataev Differential Revision: https://reviews.llvm.org/D99459
4092 lines
148 KiB
C++
4092 lines
148 KiB
C++
//===--- ParseOpenMP.cpp - OpenMP directives parsing ----------------------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
/// \file
|
|
/// This file implements parsing of all OpenMP directives and clauses.
|
|
///
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "clang/AST/ASTContext.h"
|
|
#include "clang/AST/OpenMPClause.h"
|
|
#include "clang/AST/StmtOpenMP.h"
|
|
#include "clang/Basic/OpenMPKinds.h"
|
|
#include "clang/Basic/TargetInfo.h"
|
|
#include "clang/Basic/TokenKinds.h"
|
|
#include "clang/Parse/ParseDiagnostic.h"
|
|
#include "clang/Parse/Parser.h"
|
|
#include "clang/Parse/RAIIObjectsForParser.h"
|
|
#include "clang/Sema/Scope.h"
|
|
#include "llvm/ADT/PointerIntPair.h"
|
|
#include "llvm/ADT/StringSwitch.h"
|
|
#include "llvm/ADT/UniqueVector.h"
|
|
#include "llvm/Frontend/OpenMP/OMPContext.h"
|
|
|
|
using namespace clang;
|
|
using namespace llvm::omp;
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// OpenMP declarative directives.
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
namespace {
|
|
enum OpenMPDirectiveKindEx {
|
|
OMPD_cancellation = llvm::omp::Directive_enumSize + 1,
|
|
OMPD_data,
|
|
OMPD_declare,
|
|
OMPD_end,
|
|
OMPD_end_declare,
|
|
OMPD_enter,
|
|
OMPD_exit,
|
|
OMPD_point,
|
|
OMPD_reduction,
|
|
OMPD_target_enter,
|
|
OMPD_target_exit,
|
|
OMPD_update,
|
|
OMPD_distribute_parallel,
|
|
OMPD_teams_distribute_parallel,
|
|
OMPD_target_teams_distribute_parallel,
|
|
OMPD_mapper,
|
|
OMPD_variant,
|
|
OMPD_begin,
|
|
OMPD_begin_declare,
|
|
};
|
|
|
|
// Helper to unify the enum class OpenMPDirectiveKind with its extension
|
|
// the OpenMPDirectiveKindEx enum which allows to use them together as if they
|
|
// are unsigned values.
|
|
struct OpenMPDirectiveKindExWrapper {
|
|
OpenMPDirectiveKindExWrapper(unsigned Value) : Value(Value) {}
|
|
OpenMPDirectiveKindExWrapper(OpenMPDirectiveKind DK) : Value(unsigned(DK)) {}
|
|
bool operator==(OpenMPDirectiveKindExWrapper V) const {
|
|
return Value == V.Value;
|
|
}
|
|
bool operator!=(OpenMPDirectiveKindExWrapper V) const {
|
|
return Value != V.Value;
|
|
}
|
|
bool operator==(OpenMPDirectiveKind V) const { return Value == unsigned(V); }
|
|
bool operator!=(OpenMPDirectiveKind V) const { return Value != unsigned(V); }
|
|
bool operator<(OpenMPDirectiveKind V) const { return Value < unsigned(V); }
|
|
operator unsigned() const { return Value; }
|
|
operator OpenMPDirectiveKind() const { return OpenMPDirectiveKind(Value); }
|
|
unsigned Value;
|
|
};
|
|
|
|
class DeclDirectiveListParserHelper final {
|
|
SmallVector<Expr *, 4> Identifiers;
|
|
Parser *P;
|
|
OpenMPDirectiveKind Kind;
|
|
|
|
public:
|
|
DeclDirectiveListParserHelper(Parser *P, OpenMPDirectiveKind Kind)
|
|
: P(P), Kind(Kind) {}
|
|
void operator()(CXXScopeSpec &SS, DeclarationNameInfo NameInfo) {
|
|
ExprResult Res = P->getActions().ActOnOpenMPIdExpression(
|
|
P->getCurScope(), SS, NameInfo, Kind);
|
|
if (Res.isUsable())
|
|
Identifiers.push_back(Res.get());
|
|
}
|
|
llvm::ArrayRef<Expr *> getIdentifiers() const { return Identifiers; }
|
|
};
|
|
} // namespace
|
|
|
|
// Map token string to extended OMP token kind that are
|
|
// OpenMPDirectiveKind + OpenMPDirectiveKindEx.
|
|
static unsigned getOpenMPDirectiveKindEx(StringRef S) {
|
|
OpenMPDirectiveKindExWrapper DKind = getOpenMPDirectiveKind(S);
|
|
if (DKind != OMPD_unknown)
|
|
return DKind;
|
|
|
|
return llvm::StringSwitch<OpenMPDirectiveKindExWrapper>(S)
|
|
.Case("cancellation", OMPD_cancellation)
|
|
.Case("data", OMPD_data)
|
|
.Case("declare", OMPD_declare)
|
|
.Case("end", OMPD_end)
|
|
.Case("enter", OMPD_enter)
|
|
.Case("exit", OMPD_exit)
|
|
.Case("point", OMPD_point)
|
|
.Case("reduction", OMPD_reduction)
|
|
.Case("update", OMPD_update)
|
|
.Case("mapper", OMPD_mapper)
|
|
.Case("variant", OMPD_variant)
|
|
.Case("begin", OMPD_begin)
|
|
.Default(OMPD_unknown);
|
|
}
|
|
|
|
static OpenMPDirectiveKindExWrapper parseOpenMPDirectiveKind(Parser &P) {
|
|
// Array of foldings: F[i][0] F[i][1] ===> F[i][2].
|
|
// E.g.: OMPD_for OMPD_simd ===> OMPD_for_simd
|
|
// TODO: add other combined directives in topological order.
|
|
static const 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_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_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_target, OMPD_teams, OMPD_target_teams},
|
|
{OMPD_target_teams, OMPD_distribute, OMPD_target_teams_distribute},
|
|
{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_master_taskloop, OMPD_simd, OMPD_master_taskloop_simd},
|
|
{OMPD_parallel, OMPD_master, OMPD_parallel_master},
|
|
{OMPD_parallel_master, OMPD_taskloop, OMPD_parallel_master_taskloop},
|
|
{OMPD_parallel_master_taskloop, OMPD_simd,
|
|
OMPD_parallel_master_taskloop_simd}};
|
|
enum { CancellationPoint = 0, DeclareReduction = 1, TargetData = 2 };
|
|
Token Tok = P.getCurToken();
|
|
OpenMPDirectiveKindExWrapper DKind =
|
|
Tok.isAnnotation()
|
|
? static_cast<unsigned>(OMPD_unknown)
|
|
: getOpenMPDirectiveKindEx(P.getPreprocessor().getSpelling(Tok));
|
|
if (DKind == OMPD_unknown)
|
|
return OMPD_unknown;
|
|
|
|
for (unsigned I = 0; I < llvm::array_lengthof(F); ++I) {
|
|
if (DKind != F[I][0])
|
|
continue;
|
|
|
|
Tok = P.getPreprocessor().LookAhead(0);
|
|
OpenMPDirectiveKindExWrapper SDKind =
|
|
Tok.isAnnotation()
|
|
? static_cast<unsigned>(OMPD_unknown)
|
|
: getOpenMPDirectiveKindEx(P.getPreprocessor().getSpelling(Tok));
|
|
if (SDKind == OMPD_unknown)
|
|
continue;
|
|
|
|
if (SDKind == F[I][1]) {
|
|
P.ConsumeToken();
|
|
DKind = F[I][2];
|
|
}
|
|
}
|
|
return unsigned(DKind) < llvm::omp::Directive_enumSize
|
|
? static_cast<OpenMPDirectiveKind>(DKind)
|
|
: OMPD_unknown;
|
|
}
|
|
|
|
static DeclarationName parseOpenMPReductionId(Parser &P) {
|
|
Token Tok = P.getCurToken();
|
|
Sema &Actions = P.getActions();
|
|
OverloadedOperatorKind OOK = OO_None;
|
|
// Allow to use 'operator' keyword for C++ operators
|
|
bool WithOperator = false;
|
|
if (Tok.is(tok::kw_operator)) {
|
|
P.ConsumeToken();
|
|
Tok = P.getCurToken();
|
|
WithOperator = true;
|
|
}
|
|
switch (Tok.getKind()) {
|
|
case tok::plus: // '+'
|
|
OOK = OO_Plus;
|
|
break;
|
|
case tok::minus: // '-'
|
|
OOK = OO_Minus;
|
|
break;
|
|
case tok::star: // '*'
|
|
OOK = OO_Star;
|
|
break;
|
|
case tok::amp: // '&'
|
|
OOK = OO_Amp;
|
|
break;
|
|
case tok::pipe: // '|'
|
|
OOK = OO_Pipe;
|
|
break;
|
|
case tok::caret: // '^'
|
|
OOK = OO_Caret;
|
|
break;
|
|
case tok::ampamp: // '&&'
|
|
OOK = OO_AmpAmp;
|
|
break;
|
|
case tok::pipepipe: // '||'
|
|
OOK = OO_PipePipe;
|
|
break;
|
|
case tok::identifier: // identifier
|
|
if (!WithOperator)
|
|
break;
|
|
LLVM_FALLTHROUGH;
|
|
default:
|
|
P.Diag(Tok.getLocation(), diag::err_omp_expected_reduction_identifier);
|
|
P.SkipUntil(tok::colon, tok::r_paren, tok::annot_pragma_openmp_end,
|
|
Parser::StopBeforeMatch);
|
|
return DeclarationName();
|
|
}
|
|
P.ConsumeToken();
|
|
auto &DeclNames = Actions.getASTContext().DeclarationNames;
|
|
return OOK == OO_None ? DeclNames.getIdentifier(Tok.getIdentifierInfo())
|
|
: DeclNames.getCXXOperatorName(OOK);
|
|
}
|
|
|
|
/// Parse 'omp declare reduction' construct.
|
|
///
|
|
/// declare-reduction-directive:
|
|
/// annot_pragma_openmp 'declare' 'reduction'
|
|
/// '(' <reduction_id> ':' <type> {',' <type>} ':' <expression> ')'
|
|
/// ['initializer' '(' ('omp_priv' '=' <expression>)|<function_call> ')']
|
|
/// annot_pragma_openmp_end
|
|
/// <reduction_id> is either a base language identifier or one of the following
|
|
/// operators: '+', '-', '*', '&', '|', '^', '&&' and '||'.
|
|
///
|
|
Parser::DeclGroupPtrTy
|
|
Parser::ParseOpenMPDeclareReductionDirective(AccessSpecifier AS) {
|
|
// Parse '('.
|
|
BalancedDelimiterTracker T(*this, tok::l_paren, tok::annot_pragma_openmp_end);
|
|
if (T.expectAndConsume(
|
|
diag::err_expected_lparen_after,
|
|
getOpenMPDirectiveName(OMPD_declare_reduction).data())) {
|
|
SkipUntil(tok::annot_pragma_openmp_end, StopBeforeMatch);
|
|
return DeclGroupPtrTy();
|
|
}
|
|
|
|
DeclarationName Name = parseOpenMPReductionId(*this);
|
|
if (Name.isEmpty() && Tok.is(tok::annot_pragma_openmp_end))
|
|
return DeclGroupPtrTy();
|
|
|
|
// Consume ':'.
|
|
bool IsCorrect = !ExpectAndConsume(tok::colon);
|
|
|
|
if (!IsCorrect && Tok.is(tok::annot_pragma_openmp_end))
|
|
return DeclGroupPtrTy();
|
|
|
|
IsCorrect = IsCorrect && !Name.isEmpty();
|
|
|
|
if (Tok.is(tok::colon) || Tok.is(tok::annot_pragma_openmp_end)) {
|
|
Diag(Tok.getLocation(), diag::err_expected_type);
|
|
IsCorrect = false;
|
|
}
|
|
|
|
if (!IsCorrect && Tok.is(tok::annot_pragma_openmp_end))
|
|
return DeclGroupPtrTy();
|
|
|
|
SmallVector<std::pair<QualType, SourceLocation>, 8> ReductionTypes;
|
|
// Parse list of types until ':' token.
|
|
do {
|
|
ColonProtectionRAIIObject ColonRAII(*this);
|
|
SourceRange Range;
|
|
TypeResult TR = ParseTypeName(&Range, DeclaratorContext::Prototype, AS);
|
|
if (TR.isUsable()) {
|
|
QualType ReductionType =
|
|
Actions.ActOnOpenMPDeclareReductionType(Range.getBegin(), TR);
|
|
if (!ReductionType.isNull()) {
|
|
ReductionTypes.push_back(
|
|
std::make_pair(ReductionType, Range.getBegin()));
|
|
}
|
|
} else {
|
|
SkipUntil(tok::comma, tok::colon, tok::annot_pragma_openmp_end,
|
|
StopBeforeMatch);
|
|
}
|
|
|
|
if (Tok.is(tok::colon) || Tok.is(tok::annot_pragma_openmp_end))
|
|
break;
|
|
|
|
// Consume ','.
|
|
if (ExpectAndConsume(tok::comma)) {
|
|
IsCorrect = false;
|
|
if (Tok.is(tok::annot_pragma_openmp_end)) {
|
|
Diag(Tok.getLocation(), diag::err_expected_type);
|
|
return DeclGroupPtrTy();
|
|
}
|
|
}
|
|
} while (Tok.isNot(tok::annot_pragma_openmp_end));
|
|
|
|
if (ReductionTypes.empty()) {
|
|
SkipUntil(tok::annot_pragma_openmp_end, StopBeforeMatch);
|
|
return DeclGroupPtrTy();
|
|
}
|
|
|
|
if (!IsCorrect && Tok.is(tok::annot_pragma_openmp_end))
|
|
return DeclGroupPtrTy();
|
|
|
|
// Consume ':'.
|
|
if (ExpectAndConsume(tok::colon))
|
|
IsCorrect = false;
|
|
|
|
if (Tok.is(tok::annot_pragma_openmp_end)) {
|
|
Diag(Tok.getLocation(), diag::err_expected_expression);
|
|
return DeclGroupPtrTy();
|
|
}
|
|
|
|
DeclGroupPtrTy DRD = Actions.ActOnOpenMPDeclareReductionDirectiveStart(
|
|
getCurScope(), Actions.getCurLexicalContext(), Name, ReductionTypes, AS);
|
|
|
|
// Parse <combiner> expression and then parse initializer if any for each
|
|
// correct type.
|
|
unsigned I = 0, E = ReductionTypes.size();
|
|
for (Decl *D : DRD.get()) {
|
|
TentativeParsingAction TPA(*this);
|
|
ParseScope OMPDRScope(this, Scope::FnScope | Scope::DeclScope |
|
|
Scope::CompoundStmtScope |
|
|
Scope::OpenMPDirectiveScope);
|
|
// Parse <combiner> expression.
|
|
Actions.ActOnOpenMPDeclareReductionCombinerStart(getCurScope(), D);
|
|
ExprResult CombinerResult = Actions.ActOnFinishFullExpr(
|
|
ParseExpression().get(), D->getLocation(), /*DiscardedValue*/ false);
|
|
Actions.ActOnOpenMPDeclareReductionCombinerEnd(D, CombinerResult.get());
|
|
|
|
if (CombinerResult.isInvalid() && Tok.isNot(tok::r_paren) &&
|
|
Tok.isNot(tok::annot_pragma_openmp_end)) {
|
|
TPA.Commit();
|
|
IsCorrect = false;
|
|
break;
|
|
}
|
|
IsCorrect = !T.consumeClose() && IsCorrect && CombinerResult.isUsable();
|
|
ExprResult InitializerResult;
|
|
if (Tok.isNot(tok::annot_pragma_openmp_end)) {
|
|
// Parse <initializer> expression.
|
|
if (Tok.is(tok::identifier) &&
|
|
Tok.getIdentifierInfo()->isStr("initializer")) {
|
|
ConsumeToken();
|
|
} else {
|
|
Diag(Tok.getLocation(), diag::err_expected) << "'initializer'";
|
|
TPA.Commit();
|
|
IsCorrect = false;
|
|
break;
|
|
}
|
|
// Parse '('.
|
|
BalancedDelimiterTracker T(*this, tok::l_paren,
|
|
tok::annot_pragma_openmp_end);
|
|
IsCorrect =
|
|
!T.expectAndConsume(diag::err_expected_lparen_after, "initializer") &&
|
|
IsCorrect;
|
|
if (Tok.isNot(tok::annot_pragma_openmp_end)) {
|
|
ParseScope OMPDRScope(this, Scope::FnScope | Scope::DeclScope |
|
|
Scope::CompoundStmtScope |
|
|
Scope::OpenMPDirectiveScope);
|
|
// Parse expression.
|
|
VarDecl *OmpPrivParm =
|
|
Actions.ActOnOpenMPDeclareReductionInitializerStart(getCurScope(),
|
|
D);
|
|
// Check if initializer is omp_priv <init_expr> or something else.
|
|
if (Tok.is(tok::identifier) &&
|
|
Tok.getIdentifierInfo()->isStr("omp_priv")) {
|
|
ConsumeToken();
|
|
ParseOpenMPReductionInitializerForDecl(OmpPrivParm);
|
|
} else {
|
|
InitializerResult = Actions.ActOnFinishFullExpr(
|
|
ParseAssignmentExpression().get(), D->getLocation(),
|
|
/*DiscardedValue*/ false);
|
|
}
|
|
Actions.ActOnOpenMPDeclareReductionInitializerEnd(
|
|
D, InitializerResult.get(), OmpPrivParm);
|
|
if (InitializerResult.isInvalid() && Tok.isNot(tok::r_paren) &&
|
|
Tok.isNot(tok::annot_pragma_openmp_end)) {
|
|
TPA.Commit();
|
|
IsCorrect = false;
|
|
break;
|
|
}
|
|
IsCorrect =
|
|
!T.consumeClose() && IsCorrect && !InitializerResult.isInvalid();
|
|
}
|
|
}
|
|
|
|
++I;
|
|
// Revert parsing if not the last type, otherwise accept it, we're done with
|
|
// parsing.
|
|
if (I != E)
|
|
TPA.Revert();
|
|
else
|
|
TPA.Commit();
|
|
}
|
|
return Actions.ActOnOpenMPDeclareReductionDirectiveEnd(getCurScope(), DRD,
|
|
IsCorrect);
|
|
}
|
|
|
|
void Parser::ParseOpenMPReductionInitializerForDecl(VarDecl *OmpPrivParm) {
|
|
// Parse declarator '=' initializer.
|
|
// If a '==' or '+=' is found, suggest a fixit to '='.
|
|
if (isTokenEqualOrEqualTypo()) {
|
|
ConsumeToken();
|
|
|
|
if (Tok.is(tok::code_completion)) {
|
|
cutOffParsing();
|
|
Actions.CodeCompleteInitializer(getCurScope(), OmpPrivParm);
|
|
Actions.FinalizeDeclaration(OmpPrivParm);
|
|
return;
|
|
}
|
|
|
|
PreferredType.enterVariableInit(Tok.getLocation(), OmpPrivParm);
|
|
ExprResult Init = ParseInitializer();
|
|
|
|
if (Init.isInvalid()) {
|
|
SkipUntil(tok::r_paren, tok::annot_pragma_openmp_end, StopBeforeMatch);
|
|
Actions.ActOnInitializerError(OmpPrivParm);
|
|
} else {
|
|
Actions.AddInitializerToDecl(OmpPrivParm, Init.get(),
|
|
/*DirectInit=*/false);
|
|
}
|
|
} else if (Tok.is(tok::l_paren)) {
|
|
// Parse C++ direct initializer: '(' expression-list ')'
|
|
BalancedDelimiterTracker T(*this, tok::l_paren);
|
|
T.consumeOpen();
|
|
|
|
ExprVector Exprs;
|
|
CommaLocsTy CommaLocs;
|
|
|
|
SourceLocation LParLoc = T.getOpenLocation();
|
|
auto RunSignatureHelp = [this, OmpPrivParm, LParLoc, &Exprs]() {
|
|
QualType PreferredType = Actions.ProduceConstructorSignatureHelp(
|
|
getCurScope(), OmpPrivParm->getType()->getCanonicalTypeInternal(),
|
|
OmpPrivParm->getLocation(), Exprs, LParLoc);
|
|
CalledSignatureHelp = true;
|
|
return PreferredType;
|
|
};
|
|
if (ParseExpressionList(Exprs, CommaLocs, [&] {
|
|
PreferredType.enterFunctionArgument(Tok.getLocation(),
|
|
RunSignatureHelp);
|
|
})) {
|
|
if (PP.isCodeCompletionReached() && !CalledSignatureHelp)
|
|
RunSignatureHelp();
|
|
Actions.ActOnInitializerError(OmpPrivParm);
|
|
SkipUntil(tok::r_paren, tok::annot_pragma_openmp_end, StopBeforeMatch);
|
|
} else {
|
|
// Match the ')'.
|
|
SourceLocation RLoc = Tok.getLocation();
|
|
if (!T.consumeClose())
|
|
RLoc = T.getCloseLocation();
|
|
|
|
assert(!Exprs.empty() && Exprs.size() - 1 == CommaLocs.size() &&
|
|
"Unexpected number of commas!");
|
|
|
|
ExprResult Initializer =
|
|
Actions.ActOnParenListExpr(T.getOpenLocation(), RLoc, Exprs);
|
|
Actions.AddInitializerToDecl(OmpPrivParm, Initializer.get(),
|
|
/*DirectInit=*/true);
|
|
}
|
|
} else if (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace)) {
|
|
// Parse C++0x braced-init-list.
|
|
Diag(Tok, diag::warn_cxx98_compat_generalized_initializer_lists);
|
|
|
|
ExprResult Init(ParseBraceInitializer());
|
|
|
|
if (Init.isInvalid()) {
|
|
Actions.ActOnInitializerError(OmpPrivParm);
|
|
} else {
|
|
Actions.AddInitializerToDecl(OmpPrivParm, Init.get(),
|
|
/*DirectInit=*/true);
|
|
}
|
|
} else {
|
|
Actions.ActOnUninitializedDecl(OmpPrivParm);
|
|
}
|
|
}
|
|
|
|
/// Parses 'omp declare mapper' directive.
|
|
///
|
|
/// declare-mapper-directive:
|
|
/// annot_pragma_openmp 'declare' 'mapper' '(' [<mapper-identifier> ':']
|
|
/// <type> <var> ')' [<clause>[[,] <clause>] ... ]
|
|
/// annot_pragma_openmp_end
|
|
/// <mapper-identifier> and <var> are base language identifiers.
|
|
///
|
|
Parser::DeclGroupPtrTy
|
|
Parser::ParseOpenMPDeclareMapperDirective(AccessSpecifier AS) {
|
|
bool IsCorrect = true;
|
|
// Parse '('
|
|
BalancedDelimiterTracker T(*this, tok::l_paren, tok::annot_pragma_openmp_end);
|
|
if (T.expectAndConsume(diag::err_expected_lparen_after,
|
|
getOpenMPDirectiveName(OMPD_declare_mapper).data())) {
|
|
SkipUntil(tok::annot_pragma_openmp_end, StopBeforeMatch);
|
|
return DeclGroupPtrTy();
|
|
}
|
|
|
|
// Parse <mapper-identifier>
|
|
auto &DeclNames = Actions.getASTContext().DeclarationNames;
|
|
DeclarationName MapperId;
|
|
if (PP.LookAhead(0).is(tok::colon)) {
|
|
if (Tok.isNot(tok::identifier) && Tok.isNot(tok::kw_default)) {
|
|
Diag(Tok.getLocation(), diag::err_omp_mapper_illegal_identifier);
|
|
IsCorrect = false;
|
|
} else {
|
|
MapperId = DeclNames.getIdentifier(Tok.getIdentifierInfo());
|
|
}
|
|
ConsumeToken();
|
|
// Consume ':'.
|
|
ExpectAndConsume(tok::colon);
|
|
} else {
|
|
// If no mapper identifier is provided, its name is "default" by default
|
|
MapperId =
|
|
DeclNames.getIdentifier(&Actions.getASTContext().Idents.get("default"));
|
|
}
|
|
|
|
if (!IsCorrect && Tok.is(tok::annot_pragma_openmp_end))
|
|
return DeclGroupPtrTy();
|
|
|
|
// Parse <type> <var>
|
|
DeclarationName VName;
|
|
QualType MapperType;
|
|
SourceRange Range;
|
|
TypeResult ParsedType = parseOpenMPDeclareMapperVarDecl(Range, VName, AS);
|
|
if (ParsedType.isUsable())
|
|
MapperType =
|
|
Actions.ActOnOpenMPDeclareMapperType(Range.getBegin(), ParsedType);
|
|
if (MapperType.isNull())
|
|
IsCorrect = false;
|
|
if (!IsCorrect) {
|
|
SkipUntil(tok::annot_pragma_openmp_end, Parser::StopBeforeMatch);
|
|
return DeclGroupPtrTy();
|
|
}
|
|
|
|
// Consume ')'.
|
|
IsCorrect &= !T.consumeClose();
|
|
if (!IsCorrect) {
|
|
SkipUntil(tok::annot_pragma_openmp_end, Parser::StopBeforeMatch);
|
|
return DeclGroupPtrTy();
|
|
}
|
|
|
|
// Enter scope.
|
|
DeclarationNameInfo DirName;
|
|
SourceLocation Loc = Tok.getLocation();
|
|
unsigned ScopeFlags = Scope::FnScope | Scope::DeclScope |
|
|
Scope::CompoundStmtScope | Scope::OpenMPDirectiveScope;
|
|
ParseScope OMPDirectiveScope(this, ScopeFlags);
|
|
Actions.StartOpenMPDSABlock(OMPD_declare_mapper, DirName, getCurScope(), Loc);
|
|
|
|
// Add the mapper variable declaration.
|
|
ExprResult MapperVarRef = Actions.ActOnOpenMPDeclareMapperDirectiveVarDecl(
|
|
getCurScope(), MapperType, Range.getBegin(), VName);
|
|
|
|
// Parse map clauses.
|
|
SmallVector<OMPClause *, 6> Clauses;
|
|
while (Tok.isNot(tok::annot_pragma_openmp_end)) {
|
|
OpenMPClauseKind CKind = Tok.isAnnotation()
|
|
? OMPC_unknown
|
|
: getOpenMPClauseKind(PP.getSpelling(Tok));
|
|
Actions.StartOpenMPClause(CKind);
|
|
OMPClause *Clause =
|
|
ParseOpenMPClause(OMPD_declare_mapper, CKind, Clauses.empty());
|
|
if (Clause)
|
|
Clauses.push_back(Clause);
|
|
else
|
|
IsCorrect = false;
|
|
// Skip ',' if any.
|
|
if (Tok.is(tok::comma))
|
|
ConsumeToken();
|
|
Actions.EndOpenMPClause();
|
|
}
|
|
if (Clauses.empty()) {
|
|
Diag(Tok, diag::err_omp_expected_clause)
|
|
<< getOpenMPDirectiveName(OMPD_declare_mapper);
|
|
IsCorrect = false;
|
|
}
|
|
|
|
// Exit scope.
|
|
Actions.EndOpenMPDSABlock(nullptr);
|
|
OMPDirectiveScope.Exit();
|
|
DeclGroupPtrTy DG = Actions.ActOnOpenMPDeclareMapperDirective(
|
|
getCurScope(), Actions.getCurLexicalContext(), MapperId, MapperType,
|
|
Range.getBegin(), VName, AS, MapperVarRef.get(), Clauses);
|
|
if (!IsCorrect)
|
|
return DeclGroupPtrTy();
|
|
|
|
return DG;
|
|
}
|
|
|
|
TypeResult Parser::parseOpenMPDeclareMapperVarDecl(SourceRange &Range,
|
|
DeclarationName &Name,
|
|
AccessSpecifier AS) {
|
|
// Parse the common declaration-specifiers piece.
|
|
Parser::DeclSpecContext DSC = Parser::DeclSpecContext::DSC_type_specifier;
|
|
DeclSpec DS(AttrFactory);
|
|
ParseSpecifierQualifierList(DS, AS, DSC);
|
|
|
|
// Parse the declarator.
|
|
DeclaratorContext Context = DeclaratorContext::Prototype;
|
|
Declarator DeclaratorInfo(DS, Context);
|
|
ParseDeclarator(DeclaratorInfo);
|
|
Range = DeclaratorInfo.getSourceRange();
|
|
if (DeclaratorInfo.getIdentifier() == nullptr) {
|
|
Diag(Tok.getLocation(), diag::err_omp_mapper_expected_declarator);
|
|
return true;
|
|
}
|
|
Name = Actions.GetNameForDeclarator(DeclaratorInfo).getName();
|
|
|
|
return Actions.ActOnOpenMPDeclareMapperVarDecl(getCurScope(), DeclaratorInfo);
|
|
}
|
|
|
|
namespace {
|
|
/// RAII that recreates function context for correct parsing of clauses of
|
|
/// 'declare simd' construct.
|
|
/// OpenMP, 2.8.2 declare simd Construct
|
|
/// The expressions appearing in the clauses of this directive are evaluated in
|
|
/// the scope of the arguments of the function declaration or definition.
|
|
class FNContextRAII final {
|
|
Parser &P;
|
|
Sema::CXXThisScopeRAII *ThisScope;
|
|
Parser::MultiParseScope Scopes;
|
|
bool HasFunScope = false;
|
|
FNContextRAII() = delete;
|
|
FNContextRAII(const FNContextRAII &) = delete;
|
|
FNContextRAII &operator=(const FNContextRAII &) = delete;
|
|
|
|
public:
|
|
FNContextRAII(Parser &P, Parser::DeclGroupPtrTy Ptr) : P(P), Scopes(P) {
|
|
Decl *D = *Ptr.get().begin();
|
|
NamedDecl *ND = dyn_cast<NamedDecl>(D);
|
|
RecordDecl *RD = dyn_cast_or_null<RecordDecl>(D->getDeclContext());
|
|
Sema &Actions = P.getActions();
|
|
|
|
// Allow 'this' within late-parsed attributes.
|
|
ThisScope = new Sema::CXXThisScopeRAII(Actions, RD, Qualifiers(),
|
|
ND && ND->isCXXInstanceMember());
|
|
|
|
// If the Decl is templatized, add template parameters to scope.
|
|
// FIXME: Track CurTemplateDepth?
|
|
P.ReenterTemplateScopes(Scopes, D);
|
|
|
|
// If the Decl is on a function, add function parameters to the scope.
|
|
if (D->isFunctionOrFunctionTemplate()) {
|
|
HasFunScope = true;
|
|
Scopes.Enter(Scope::FnScope | Scope::DeclScope |
|
|
Scope::CompoundStmtScope);
|
|
Actions.ActOnReenterFunctionContext(Actions.getCurScope(), D);
|
|
}
|
|
}
|
|
~FNContextRAII() {
|
|
if (HasFunScope)
|
|
P.getActions().ActOnExitFunctionContext();
|
|
delete ThisScope;
|
|
}
|
|
};
|
|
} // namespace
|
|
|
|
/// Parses clauses for 'declare simd' directive.
|
|
/// clause:
|
|
/// 'inbranch' | 'notinbranch'
|
|
/// 'simdlen' '(' <expr> ')'
|
|
/// { 'uniform' '(' <argument_list> ')' }
|
|
/// { 'aligned '(' <argument_list> [ ':' <alignment> ] ')' }
|
|
/// { 'linear '(' <argument_list> [ ':' <step> ] ')' }
|
|
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) {
|
|
SourceRange BSRange;
|
|
const Token &Tok = P.getCurToken();
|
|
bool IsError = false;
|
|
while (Tok.isNot(tok::annot_pragma_openmp_end)) {
|
|
if (Tok.isNot(tok::identifier))
|
|
break;
|
|
OMPDeclareSimdDeclAttr::BranchStateTy Out;
|
|
IdentifierInfo *II = Tok.getIdentifierInfo();
|
|
StringRef ClauseName = II->getName();
|
|
// Parse 'inranch|notinbranch' clauses.
|
|
if (OMPDeclareSimdDeclAttr::ConvertStrToBranchStateTy(ClauseName, Out)) {
|
|
if (BS != OMPDeclareSimdDeclAttr::BS_Undefined && BS != Out) {
|
|
P.Diag(Tok, diag::err_omp_declare_simd_inbranch_notinbranch)
|
|
<< ClauseName
|
|
<< OMPDeclareSimdDeclAttr::ConvertBranchStateTyToStr(BS) << BSRange;
|
|
IsError = true;
|
|
}
|
|
BS = Out;
|
|
BSRange = SourceRange(Tok.getLocation(), Tok.getEndLoc());
|
|
P.ConsumeToken();
|
|
} else if (ClauseName.equals("simdlen")) {
|
|
if (SimdLen.isUsable()) {
|
|
P.Diag(Tok, diag::err_omp_more_one_clause)
|
|
<< getOpenMPDirectiveName(OMPD_declare_simd) << ClauseName << 0;
|
|
IsError = true;
|
|
}
|
|
P.ConsumeToken();
|
|
SourceLocation RLoc;
|
|
SimdLen = P.ParseOpenMPParensExpr(ClauseName, RLoc);
|
|
if (SimdLen.isInvalid())
|
|
IsError = true;
|
|
} else {
|
|
OpenMPClauseKind CKind = getOpenMPClauseKind(ClauseName);
|
|
if (CKind == OMPC_uniform || CKind == OMPC_aligned ||
|
|
CKind == OMPC_linear) {
|
|
Parser::OpenMPVarListDataTy Data;
|
|
SmallVectorImpl<Expr *> *Vars = &Uniforms;
|
|
if (CKind == OMPC_aligned) {
|
|
Vars = &Aligneds;
|
|
} else if (CKind == OMPC_linear) {
|
|
Data.ExtraModifier = OMPC_LINEAR_val;
|
|
Vars = &Linears;
|
|
}
|
|
|
|
P.ConsumeToken();
|
|
if (P.ParseOpenMPVarList(OMPD_declare_simd,
|
|
getOpenMPClauseKind(ClauseName), *Vars, Data))
|
|
IsError = true;
|
|
if (CKind == OMPC_aligned) {
|
|
Alignments.append(Aligneds.size() - Alignments.size(),
|
|
Data.DepModOrTailExpr);
|
|
} else if (CKind == OMPC_linear) {
|
|
assert(0 <= Data.ExtraModifier &&
|
|
Data.ExtraModifier <= OMPC_LINEAR_unknown &&
|
|
"Unexpected linear modifier.");
|
|
if (P.getActions().CheckOpenMPLinearModifier(
|
|
static_cast<OpenMPLinearClauseKind>(Data.ExtraModifier),
|
|
Data.ExtraModifierLoc))
|
|
Data.ExtraModifier = OMPC_LINEAR_val;
|
|
LinModifiers.append(Linears.size() - LinModifiers.size(),
|
|
Data.ExtraModifier);
|
|
Steps.append(Linears.size() - Steps.size(), Data.DepModOrTailExpr);
|
|
}
|
|
} else
|
|
// TODO: add parsing of other clauses.
|
|
break;
|
|
}
|
|
// Skip ',' if any.
|
|
if (Tok.is(tok::comma))
|
|
P.ConsumeToken();
|
|
}
|
|
return IsError;
|
|
}
|
|
|
|
/// Parse clauses for '#pragma omp declare simd'.
|
|
Parser::DeclGroupPtrTy
|
|
Parser::ParseOMPDeclareSimdClauses(Parser::DeclGroupPtrTy Ptr,
|
|
CachedTokens &Toks, SourceLocation Loc) {
|
|
PP.EnterToken(Tok, /*IsReinject*/ true);
|
|
PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true,
|
|
/*IsReinject*/ true);
|
|
// Consume the previously pushed token.
|
|
ConsumeAnyToken(/*ConsumeCodeCompletionTok=*/true);
|
|
ConsumeAnyToken(/*ConsumeCodeCompletionTok=*/true);
|
|
|
|
FNContextRAII FnContext(*this, Ptr);
|
|
OMPDeclareSimdDeclAttr::BranchStateTy BS =
|
|
OMPDeclareSimdDeclAttr::BS_Undefined;
|
|
ExprResult Simdlen;
|
|
SmallVector<Expr *, 4> Uniforms;
|
|
SmallVector<Expr *, 4> Aligneds;
|
|
SmallVector<Expr *, 4> Alignments;
|
|
SmallVector<Expr *, 4> Linears;
|
|
SmallVector<unsigned, 4> LinModifiers;
|
|
SmallVector<Expr *, 4> Steps;
|
|
bool IsError =
|
|
parseDeclareSimdClauses(*this, BS, Simdlen, Uniforms, Aligneds,
|
|
Alignments, Linears, LinModifiers, Steps);
|
|
skipUntilPragmaOpenMPEnd(OMPD_declare_simd);
|
|
// Skip the last annot_pragma_openmp_end.
|
|
SourceLocation EndLoc = ConsumeAnnotationToken();
|
|
if (IsError)
|
|
return Ptr;
|
|
return Actions.ActOnOpenMPDeclareSimdDirective(
|
|
Ptr, BS, Simdlen.get(), Uniforms, Aligneds, Alignments, Linears,
|
|
LinModifiers, Steps, SourceRange(Loc, EndLoc));
|
|
}
|
|
|
|
namespace {
|
|
/// Constant used in the diagnostics to distinguish the levels in an OpenMP
|
|
/// contexts: selector-set={selector(trait, ...), ...}, ....
|
|
enum OMPContextLvl {
|
|
CONTEXT_SELECTOR_SET_LVL = 0,
|
|
CONTEXT_SELECTOR_LVL = 1,
|
|
CONTEXT_TRAIT_LVL = 2,
|
|
};
|
|
|
|
static StringRef stringLiteralParser(Parser &P) {
|
|
ExprResult Res = P.ParseStringLiteralExpression(true);
|
|
return Res.isUsable() ? Res.getAs<StringLiteral>()->getString() : "";
|
|
}
|
|
|
|
static StringRef getNameFromIdOrString(Parser &P, Token &Tok,
|
|
OMPContextLvl Lvl) {
|
|
if (Tok.is(tok::identifier)) {
|
|
llvm::SmallString<16> Buffer;
|
|
StringRef Name = P.getPreprocessor().getSpelling(Tok, Buffer);
|
|
(void)P.ConsumeToken();
|
|
return Name;
|
|
}
|
|
|
|
if (tok::isStringLiteral(Tok.getKind()))
|
|
return stringLiteralParser(P);
|
|
|
|
P.Diag(Tok.getLocation(),
|
|
diag::warn_omp_declare_variant_string_literal_or_identifier)
|
|
<< Lvl;
|
|
return "";
|
|
}
|
|
|
|
static bool checkForDuplicates(Parser &P, StringRef Name,
|
|
SourceLocation NameLoc,
|
|
llvm::StringMap<SourceLocation> &Seen,
|
|
OMPContextLvl Lvl) {
|
|
auto Res = Seen.try_emplace(Name, NameLoc);
|
|
if (Res.second)
|
|
return false;
|
|
|
|
// Each trait-set-selector-name, trait-selector-name and trait-name can
|
|
// only be specified once.
|
|
P.Diag(NameLoc, diag::warn_omp_declare_variant_ctx_mutiple_use)
|
|
<< Lvl << Name;
|
|
P.Diag(Res.first->getValue(), diag::note_omp_declare_variant_ctx_used_here)
|
|
<< Lvl << Name;
|
|
return true;
|
|
}
|
|
} // namespace
|
|
|
|
void Parser::parseOMPTraitPropertyKind(OMPTraitProperty &TIProperty,
|
|
llvm::omp::TraitSet Set,
|
|
llvm::omp::TraitSelector Selector,
|
|
llvm::StringMap<SourceLocation> &Seen) {
|
|
TIProperty.Kind = TraitProperty::invalid;
|
|
|
|
SourceLocation NameLoc = Tok.getLocation();
|
|
StringRef Name = getNameFromIdOrString(*this, Tok, CONTEXT_TRAIT_LVL);
|
|
if (Name.empty()) {
|
|
Diag(Tok.getLocation(), diag::note_omp_declare_variant_ctx_options)
|
|
<< CONTEXT_TRAIT_LVL << listOpenMPContextTraitProperties(Set, Selector);
|
|
return;
|
|
}
|
|
|
|
TIProperty.RawString = Name;
|
|
TIProperty.Kind = getOpenMPContextTraitPropertyKind(Set, Selector, Name);
|
|
if (TIProperty.Kind != TraitProperty::invalid) {
|
|
if (checkForDuplicates(*this, Name, NameLoc, Seen, CONTEXT_TRAIT_LVL))
|
|
TIProperty.Kind = TraitProperty::invalid;
|
|
return;
|
|
}
|
|
|
|
// It follows diagnosis and helping notes.
|
|
// FIXME: We should move the diagnosis string generation into libFrontend.
|
|
Diag(NameLoc, diag::warn_omp_declare_variant_ctx_not_a_property)
|
|
<< Name << getOpenMPContextTraitSelectorName(Selector)
|
|
<< getOpenMPContextTraitSetName(Set);
|
|
|
|
TraitSet SetForName = getOpenMPContextTraitSetKind(Name);
|
|
if (SetForName != TraitSet::invalid) {
|
|
Diag(NameLoc, diag::note_omp_declare_variant_ctx_is_a)
|
|
<< Name << CONTEXT_SELECTOR_SET_LVL << CONTEXT_TRAIT_LVL;
|
|
Diag(NameLoc, diag::note_omp_declare_variant_ctx_try)
|
|
<< Name << "<selector-name>"
|
|
<< "(<property-name>)";
|
|
return;
|
|
}
|
|
TraitSelector SelectorForName = getOpenMPContextTraitSelectorKind(Name);
|
|
if (SelectorForName != TraitSelector::invalid) {
|
|
Diag(NameLoc, diag::note_omp_declare_variant_ctx_is_a)
|
|
<< Name << CONTEXT_SELECTOR_LVL << CONTEXT_TRAIT_LVL;
|
|
bool AllowsTraitScore = false;
|
|
bool RequiresProperty = false;
|
|
isValidTraitSelectorForTraitSet(
|
|
SelectorForName, getOpenMPContextTraitSetForSelector(SelectorForName),
|
|
AllowsTraitScore, RequiresProperty);
|
|
Diag(NameLoc, diag::note_omp_declare_variant_ctx_try)
|
|
<< getOpenMPContextTraitSetName(
|
|
getOpenMPContextTraitSetForSelector(SelectorForName))
|
|
<< Name << (RequiresProperty ? "(<property-name>)" : "");
|
|
return;
|
|
}
|
|
for (const auto &PotentialSet :
|
|
{TraitSet::construct, TraitSet::user, TraitSet::implementation,
|
|
TraitSet::device}) {
|
|
TraitProperty PropertyForName =
|
|
getOpenMPContextTraitPropertyKind(PotentialSet, Selector, Name);
|
|
if (PropertyForName == TraitProperty::invalid)
|
|
continue;
|
|
Diag(NameLoc, diag::note_omp_declare_variant_ctx_try)
|
|
<< getOpenMPContextTraitSetName(
|
|
getOpenMPContextTraitSetForProperty(PropertyForName))
|
|
<< getOpenMPContextTraitSelectorName(
|
|
getOpenMPContextTraitSelectorForProperty(PropertyForName))
|
|
<< ("(" + Name + ")").str();
|
|
return;
|
|
}
|
|
Diag(NameLoc, diag::note_omp_declare_variant_ctx_options)
|
|
<< CONTEXT_TRAIT_LVL << listOpenMPContextTraitProperties(Set, Selector);
|
|
}
|
|
|
|
static bool checkExtensionProperty(Parser &P, SourceLocation Loc,
|
|
OMPTraitProperty &TIProperty,
|
|
OMPTraitSelector &TISelector,
|
|
llvm::StringMap<SourceLocation> &Seen) {
|
|
assert(TISelector.Kind ==
|
|
llvm::omp::TraitSelector::implementation_extension &&
|
|
"Only for extension properties, e.g., "
|
|
"`implementation={extension(PROPERTY)}`");
|
|
if (TIProperty.Kind == TraitProperty::invalid)
|
|
return false;
|
|
|
|
if (TIProperty.Kind ==
|
|
TraitProperty::implementation_extension_disable_implicit_base)
|
|
return true;
|
|
|
|
if (TIProperty.Kind ==
|
|
TraitProperty::implementation_extension_allow_templates)
|
|
return true;
|
|
|
|
auto IsMatchExtension = [](OMPTraitProperty &TP) {
|
|
return (TP.Kind ==
|
|
llvm::omp::TraitProperty::implementation_extension_match_all ||
|
|
TP.Kind ==
|
|
llvm::omp::TraitProperty::implementation_extension_match_any ||
|
|
TP.Kind ==
|
|
llvm::omp::TraitProperty::implementation_extension_match_none);
|
|
};
|
|
|
|
if (IsMatchExtension(TIProperty)) {
|
|
for (OMPTraitProperty &SeenProp : TISelector.Properties)
|
|
if (IsMatchExtension(SeenProp)) {
|
|
P.Diag(Loc, diag::err_omp_variant_ctx_second_match_extension);
|
|
StringRef SeenName = llvm::omp::getOpenMPContextTraitPropertyName(
|
|
SeenProp.Kind, SeenProp.RawString);
|
|
SourceLocation SeenLoc = Seen[SeenName];
|
|
P.Diag(SeenLoc, diag::note_omp_declare_variant_ctx_used_here)
|
|
<< CONTEXT_TRAIT_LVL << SeenName;
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
llvm_unreachable("Unknown extension property!");
|
|
}
|
|
|
|
void Parser::parseOMPContextProperty(OMPTraitSelector &TISelector,
|
|
llvm::omp::TraitSet Set,
|
|
llvm::StringMap<SourceLocation> &Seen) {
|
|
assert(TISelector.Kind != TraitSelector::user_condition &&
|
|
"User conditions are special properties not handled here!");
|
|
|
|
SourceLocation PropertyLoc = Tok.getLocation();
|
|
OMPTraitProperty TIProperty;
|
|
parseOMPTraitPropertyKind(TIProperty, Set, TISelector.Kind, Seen);
|
|
|
|
if (TISelector.Kind == llvm::omp::TraitSelector::implementation_extension)
|
|
if (!checkExtensionProperty(*this, Tok.getLocation(), TIProperty,
|
|
TISelector, Seen))
|
|
TIProperty.Kind = TraitProperty::invalid;
|
|
|
|
// If we have an invalid property here we already issued a warning.
|
|
if (TIProperty.Kind == TraitProperty::invalid) {
|
|
if (PropertyLoc != Tok.getLocation())
|
|
Diag(Tok.getLocation(), diag::note_omp_declare_variant_ctx_continue_here)
|
|
<< CONTEXT_TRAIT_LVL;
|
|
return;
|
|
}
|
|
|
|
if (isValidTraitPropertyForTraitSetAndSelector(TIProperty.Kind,
|
|
TISelector.Kind, Set)) {
|
|
|
|
// If we make it here the property, selector, set, score, condition, ... are
|
|
// all valid (or have been corrected). Thus we can record the property.
|
|
TISelector.Properties.push_back(TIProperty);
|
|
return;
|
|
}
|
|
|
|
Diag(PropertyLoc, diag::warn_omp_ctx_incompatible_property_for_selector)
|
|
<< getOpenMPContextTraitPropertyName(TIProperty.Kind,
|
|
TIProperty.RawString)
|
|
<< getOpenMPContextTraitSelectorName(TISelector.Kind)
|
|
<< getOpenMPContextTraitSetName(Set);
|
|
Diag(PropertyLoc, diag::note_omp_ctx_compatible_set_and_selector_for_property)
|
|
<< getOpenMPContextTraitPropertyName(TIProperty.Kind,
|
|
TIProperty.RawString)
|
|
<< getOpenMPContextTraitSelectorName(
|
|
getOpenMPContextTraitSelectorForProperty(TIProperty.Kind))
|
|
<< getOpenMPContextTraitSetName(
|
|
getOpenMPContextTraitSetForProperty(TIProperty.Kind));
|
|
Diag(Tok.getLocation(), diag::note_omp_declare_variant_ctx_continue_here)
|
|
<< CONTEXT_TRAIT_LVL;
|
|
}
|
|
|
|
void Parser::parseOMPTraitSelectorKind(OMPTraitSelector &TISelector,
|
|
llvm::omp::TraitSet Set,
|
|
llvm::StringMap<SourceLocation> &Seen) {
|
|
TISelector.Kind = TraitSelector::invalid;
|
|
|
|
SourceLocation NameLoc = Tok.getLocation();
|
|
StringRef Name = getNameFromIdOrString(*this, Tok, CONTEXT_SELECTOR_LVL);
|
|
if (Name.empty()) {
|
|
Diag(Tok.getLocation(), diag::note_omp_declare_variant_ctx_options)
|
|
<< CONTEXT_SELECTOR_LVL << listOpenMPContextTraitSelectors(Set);
|
|
return;
|
|
}
|
|
|
|
TISelector.Kind = getOpenMPContextTraitSelectorKind(Name);
|
|
if (TISelector.Kind != TraitSelector::invalid) {
|
|
if (checkForDuplicates(*this, Name, NameLoc, Seen, CONTEXT_SELECTOR_LVL))
|
|
TISelector.Kind = TraitSelector::invalid;
|
|
return;
|
|
}
|
|
|
|
// It follows diagnosis and helping notes.
|
|
Diag(NameLoc, diag::warn_omp_declare_variant_ctx_not_a_selector)
|
|
<< Name << getOpenMPContextTraitSetName(Set);
|
|
|
|
TraitSet SetForName = getOpenMPContextTraitSetKind(Name);
|
|
if (SetForName != TraitSet::invalid) {
|
|
Diag(NameLoc, diag::note_omp_declare_variant_ctx_is_a)
|
|
<< Name << CONTEXT_SELECTOR_SET_LVL << CONTEXT_SELECTOR_LVL;
|
|
Diag(NameLoc, diag::note_omp_declare_variant_ctx_try)
|
|
<< Name << "<selector-name>"
|
|
<< "<property-name>";
|
|
return;
|
|
}
|
|
for (const auto &PotentialSet :
|
|
{TraitSet::construct, TraitSet::user, TraitSet::implementation,
|
|
TraitSet::device}) {
|
|
TraitProperty PropertyForName = getOpenMPContextTraitPropertyKind(
|
|
PotentialSet, TraitSelector::invalid, Name);
|
|
if (PropertyForName == TraitProperty::invalid)
|
|
continue;
|
|
Diag(NameLoc, diag::note_omp_declare_variant_ctx_is_a)
|
|
<< Name << CONTEXT_TRAIT_LVL << CONTEXT_SELECTOR_LVL;
|
|
Diag(NameLoc, diag::note_omp_declare_variant_ctx_try)
|
|
<< getOpenMPContextTraitSetName(
|
|
getOpenMPContextTraitSetForProperty(PropertyForName))
|
|
<< getOpenMPContextTraitSelectorName(
|
|
getOpenMPContextTraitSelectorForProperty(PropertyForName))
|
|
<< ("(" + Name + ")").str();
|
|
return;
|
|
}
|
|
Diag(NameLoc, diag::note_omp_declare_variant_ctx_options)
|
|
<< CONTEXT_SELECTOR_LVL << listOpenMPContextTraitSelectors(Set);
|
|
}
|
|
|
|
/// Parse optional 'score' '(' <expr> ')' ':'.
|
|
static ExprResult parseContextScore(Parser &P) {
|
|
ExprResult ScoreExpr;
|
|
llvm::SmallString<16> Buffer;
|
|
StringRef SelectorName =
|
|
P.getPreprocessor().getSpelling(P.getCurToken(), Buffer);
|
|
if (!SelectorName.equals("score"))
|
|
return ScoreExpr;
|
|
(void)P.ConsumeToken();
|
|
SourceLocation RLoc;
|
|
ScoreExpr = P.ParseOpenMPParensExpr(SelectorName, RLoc);
|
|
// Parse ':'
|
|
if (P.getCurToken().is(tok::colon))
|
|
(void)P.ConsumeAnyToken();
|
|
else
|
|
P.Diag(P.getCurToken(), diag::warn_omp_declare_variant_expected)
|
|
<< "':'"
|
|
<< "score expression";
|
|
return ScoreExpr;
|
|
}
|
|
|
|
/// Parses an OpenMP context selector.
|
|
///
|
|
/// <trait-selector-name> ['('[<trait-score>] <trait-property> [, <t-p>]* ')']
|
|
void Parser::parseOMPContextSelector(
|
|
OMPTraitSelector &TISelector, llvm::omp::TraitSet Set,
|
|
llvm::StringMap<SourceLocation> &SeenSelectors) {
|
|
unsigned short OuterPC = ParenCount;
|
|
|
|
// If anything went wrong we issue an error or warning and then skip the rest
|
|
// of the selector. However, commas are ambiguous so we look for the nesting
|
|
// of parentheses here as well.
|
|
auto FinishSelector = [OuterPC, this]() -> void {
|
|
bool Done = false;
|
|
while (!Done) {
|
|
while (!SkipUntil({tok::r_brace, tok::r_paren, tok::comma,
|
|
tok::annot_pragma_openmp_end},
|
|
StopBeforeMatch))
|
|
;
|
|
if (Tok.is(tok::r_paren) && OuterPC > ParenCount)
|
|
(void)ConsumeParen();
|
|
if (OuterPC <= ParenCount) {
|
|
Done = true;
|
|
break;
|
|
}
|
|
if (!Tok.is(tok::comma) && !Tok.is(tok::r_paren)) {
|
|
Done = true;
|
|
break;
|
|
}
|
|
(void)ConsumeAnyToken();
|
|
}
|
|
Diag(Tok.getLocation(), diag::note_omp_declare_variant_ctx_continue_here)
|
|
<< CONTEXT_SELECTOR_LVL;
|
|
};
|
|
|
|
SourceLocation SelectorLoc = Tok.getLocation();
|
|
parseOMPTraitSelectorKind(TISelector, Set, SeenSelectors);
|
|
if (TISelector.Kind == TraitSelector::invalid)
|
|
return FinishSelector();
|
|
|
|
bool AllowsTraitScore = false;
|
|
bool RequiresProperty = false;
|
|
if (!isValidTraitSelectorForTraitSet(TISelector.Kind, Set, AllowsTraitScore,
|
|
RequiresProperty)) {
|
|
Diag(SelectorLoc, diag::warn_omp_ctx_incompatible_selector_for_set)
|
|
<< getOpenMPContextTraitSelectorName(TISelector.Kind)
|
|
<< getOpenMPContextTraitSetName(Set);
|
|
Diag(SelectorLoc, diag::note_omp_ctx_compatible_set_for_selector)
|
|
<< getOpenMPContextTraitSelectorName(TISelector.Kind)
|
|
<< getOpenMPContextTraitSetName(
|
|
getOpenMPContextTraitSetForSelector(TISelector.Kind))
|
|
<< RequiresProperty;
|
|
return FinishSelector();
|
|
}
|
|
|
|
if (!RequiresProperty) {
|
|
TISelector.Properties.push_back(
|
|
{getOpenMPContextTraitPropertyForSelector(TISelector.Kind),
|
|
getOpenMPContextTraitSelectorName(TISelector.Kind)});
|
|
return;
|
|
}
|
|
|
|
if (!Tok.is(tok::l_paren)) {
|
|
Diag(SelectorLoc, diag::warn_omp_ctx_selector_without_properties)
|
|
<< getOpenMPContextTraitSelectorName(TISelector.Kind)
|
|
<< getOpenMPContextTraitSetName(Set);
|
|
return FinishSelector();
|
|
}
|
|
|
|
if (TISelector.Kind == TraitSelector::user_condition) {
|
|
SourceLocation RLoc;
|
|
ExprResult Condition = ParseOpenMPParensExpr("user condition", RLoc);
|
|
if (!Condition.isUsable())
|
|
return FinishSelector();
|
|
TISelector.ScoreOrCondition = Condition.get();
|
|
TISelector.Properties.push_back(
|
|
{TraitProperty::user_condition_unknown, "<condition>"});
|
|
return;
|
|
}
|
|
|
|
BalancedDelimiterTracker BDT(*this, tok::l_paren,
|
|
tok::annot_pragma_openmp_end);
|
|
// Parse '('.
|
|
(void)BDT.consumeOpen();
|
|
|
|
SourceLocation ScoreLoc = Tok.getLocation();
|
|
ExprResult Score = parseContextScore(*this);
|
|
|
|
if (!AllowsTraitScore && !Score.isUnset()) {
|
|
if (Score.isUsable()) {
|
|
Diag(ScoreLoc, diag::warn_omp_ctx_incompatible_score_for_property)
|
|
<< getOpenMPContextTraitSelectorName(TISelector.Kind)
|
|
<< getOpenMPContextTraitSetName(Set) << Score.get();
|
|
} else {
|
|
Diag(ScoreLoc, diag::warn_omp_ctx_incompatible_score_for_property)
|
|
<< getOpenMPContextTraitSelectorName(TISelector.Kind)
|
|
<< getOpenMPContextTraitSetName(Set) << "<invalid>";
|
|
}
|
|
Score = ExprResult();
|
|
}
|
|
|
|
if (Score.isUsable())
|
|
TISelector.ScoreOrCondition = Score.get();
|
|
|
|
llvm::StringMap<SourceLocation> SeenProperties;
|
|
do {
|
|
parseOMPContextProperty(TISelector, Set, SeenProperties);
|
|
} while (TryConsumeToken(tok::comma));
|
|
|
|
// Parse ')'.
|
|
BDT.consumeClose();
|
|
}
|
|
|
|
void Parser::parseOMPTraitSetKind(OMPTraitSet &TISet,
|
|
llvm::StringMap<SourceLocation> &Seen) {
|
|
TISet.Kind = TraitSet::invalid;
|
|
|
|
SourceLocation NameLoc = Tok.getLocation();
|
|
StringRef Name = getNameFromIdOrString(*this, Tok, CONTEXT_SELECTOR_SET_LVL);
|
|
if (Name.empty()) {
|
|
Diag(Tok.getLocation(), diag::note_omp_declare_variant_ctx_options)
|
|
<< CONTEXT_SELECTOR_SET_LVL << listOpenMPContextTraitSets();
|
|
return;
|
|
}
|
|
|
|
TISet.Kind = getOpenMPContextTraitSetKind(Name);
|
|
if (TISet.Kind != TraitSet::invalid) {
|
|
if (checkForDuplicates(*this, Name, NameLoc, Seen,
|
|
CONTEXT_SELECTOR_SET_LVL))
|
|
TISet.Kind = TraitSet::invalid;
|
|
return;
|
|
}
|
|
|
|
// It follows diagnosis and helping notes.
|
|
Diag(NameLoc, diag::warn_omp_declare_variant_ctx_not_a_set) << Name;
|
|
|
|
TraitSelector SelectorForName = getOpenMPContextTraitSelectorKind(Name);
|
|
if (SelectorForName != TraitSelector::invalid) {
|
|
Diag(NameLoc, diag::note_omp_declare_variant_ctx_is_a)
|
|
<< Name << CONTEXT_SELECTOR_LVL << CONTEXT_SELECTOR_SET_LVL;
|
|
bool AllowsTraitScore = false;
|
|
bool RequiresProperty = false;
|
|
isValidTraitSelectorForTraitSet(
|
|
SelectorForName, getOpenMPContextTraitSetForSelector(SelectorForName),
|
|
AllowsTraitScore, RequiresProperty);
|
|
Diag(NameLoc, diag::note_omp_declare_variant_ctx_try)
|
|
<< getOpenMPContextTraitSetName(
|
|
getOpenMPContextTraitSetForSelector(SelectorForName))
|
|
<< Name << (RequiresProperty ? "(<property-name>)" : "");
|
|
return;
|
|
}
|
|
for (const auto &PotentialSet :
|
|
{TraitSet::construct, TraitSet::user, TraitSet::implementation,
|
|
TraitSet::device}) {
|
|
TraitProperty PropertyForName = getOpenMPContextTraitPropertyKind(
|
|
PotentialSet, TraitSelector::invalid, Name);
|
|
if (PropertyForName == TraitProperty::invalid)
|
|
continue;
|
|
Diag(NameLoc, diag::note_omp_declare_variant_ctx_is_a)
|
|
<< Name << CONTEXT_TRAIT_LVL << CONTEXT_SELECTOR_SET_LVL;
|
|
Diag(NameLoc, diag::note_omp_declare_variant_ctx_try)
|
|
<< getOpenMPContextTraitSetName(
|
|
getOpenMPContextTraitSetForProperty(PropertyForName))
|
|
<< getOpenMPContextTraitSelectorName(
|
|
getOpenMPContextTraitSelectorForProperty(PropertyForName))
|
|
<< ("(" + Name + ")").str();
|
|
return;
|
|
}
|
|
Diag(NameLoc, diag::note_omp_declare_variant_ctx_options)
|
|
<< CONTEXT_SELECTOR_SET_LVL << listOpenMPContextTraitSets();
|
|
}
|
|
|
|
/// Parses an OpenMP context selector set.
|
|
///
|
|
/// <trait-set-selector-name> '=' '{' <trait-selector> [, <trait-selector>]* '}'
|
|
void Parser::parseOMPContextSelectorSet(
|
|
OMPTraitSet &TISet, llvm::StringMap<SourceLocation> &SeenSets) {
|
|
auto OuterBC = BraceCount;
|
|
|
|
// If anything went wrong we issue an error or warning and then skip the rest
|
|
// of the set. However, commas are ambiguous so we look for the nesting
|
|
// of braces here as well.
|
|
auto FinishSelectorSet = [this, OuterBC]() -> void {
|
|
bool Done = false;
|
|
while (!Done) {
|
|
while (!SkipUntil({tok::comma, tok::r_brace, tok::r_paren,
|
|
tok::annot_pragma_openmp_end},
|
|
StopBeforeMatch))
|
|
;
|
|
if (Tok.is(tok::r_brace) && OuterBC > BraceCount)
|
|
(void)ConsumeBrace();
|
|
if (OuterBC <= BraceCount) {
|
|
Done = true;
|
|
break;
|
|
}
|
|
if (!Tok.is(tok::comma) && !Tok.is(tok::r_brace)) {
|
|
Done = true;
|
|
break;
|
|
}
|
|
(void)ConsumeAnyToken();
|
|
}
|
|
Diag(Tok.getLocation(), diag::note_omp_declare_variant_ctx_continue_here)
|
|
<< CONTEXT_SELECTOR_SET_LVL;
|
|
};
|
|
|
|
parseOMPTraitSetKind(TISet, SeenSets);
|
|
if (TISet.Kind == TraitSet::invalid)
|
|
return FinishSelectorSet();
|
|
|
|
// Parse '='.
|
|
if (!TryConsumeToken(tok::equal))
|
|
Diag(Tok.getLocation(), diag::warn_omp_declare_variant_expected)
|
|
<< "="
|
|
<< ("context set name \"" + getOpenMPContextTraitSetName(TISet.Kind) +
|
|
"\"")
|
|
.str();
|
|
|
|
// Parse '{'.
|
|
if (Tok.is(tok::l_brace)) {
|
|
(void)ConsumeBrace();
|
|
} else {
|
|
Diag(Tok.getLocation(), diag::warn_omp_declare_variant_expected)
|
|
<< "{"
|
|
<< ("'=' that follows the context set name \"" +
|
|
getOpenMPContextTraitSetName(TISet.Kind) + "\"")
|
|
.str();
|
|
}
|
|
|
|
llvm::StringMap<SourceLocation> SeenSelectors;
|
|
do {
|
|
OMPTraitSelector TISelector;
|
|
parseOMPContextSelector(TISelector, TISet.Kind, SeenSelectors);
|
|
if (TISelector.Kind != TraitSelector::invalid &&
|
|
!TISelector.Properties.empty())
|
|
TISet.Selectors.push_back(TISelector);
|
|
} while (TryConsumeToken(tok::comma));
|
|
|
|
// Parse '}'.
|
|
if (Tok.is(tok::r_brace)) {
|
|
(void)ConsumeBrace();
|
|
} else {
|
|
Diag(Tok.getLocation(), diag::warn_omp_declare_variant_expected)
|
|
<< "}"
|
|
<< ("context selectors for the context set \"" +
|
|
getOpenMPContextTraitSetName(TISet.Kind) + "\"")
|
|
.str();
|
|
}
|
|
}
|
|
|
|
/// Parse OpenMP context selectors:
|
|
///
|
|
/// <trait-set-selector> [, <trait-set-selector>]*
|
|
bool Parser::parseOMPContextSelectors(SourceLocation Loc, OMPTraitInfo &TI) {
|
|
llvm::StringMap<SourceLocation> SeenSets;
|
|
do {
|
|
OMPTraitSet TISet;
|
|
parseOMPContextSelectorSet(TISet, SeenSets);
|
|
if (TISet.Kind != TraitSet::invalid && !TISet.Selectors.empty())
|
|
TI.Sets.push_back(TISet);
|
|
} while (TryConsumeToken(tok::comma));
|
|
|
|
return false;
|
|
}
|
|
|
|
/// Parse clauses for '#pragma omp declare variant ( variant-func-id ) clause'.
|
|
void Parser::ParseOMPDeclareVariantClauses(Parser::DeclGroupPtrTy Ptr,
|
|
CachedTokens &Toks,
|
|
SourceLocation Loc) {
|
|
PP.EnterToken(Tok, /*IsReinject*/ true);
|
|
PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true,
|
|
/*IsReinject*/ true);
|
|
// Consume the previously pushed token.
|
|
ConsumeAnyToken(/*ConsumeCodeCompletionTok=*/true);
|
|
ConsumeAnyToken(/*ConsumeCodeCompletionTok=*/true);
|
|
|
|
FNContextRAII FnContext(*this, Ptr);
|
|
// Parse function declaration id.
|
|
SourceLocation RLoc;
|
|
// Parse with IsAddressOfOperand set to true to parse methods as DeclRefExprs
|
|
// instead of MemberExprs.
|
|
ExprResult AssociatedFunction;
|
|
{
|
|
// Do not mark function as is used to prevent its emission if this is the
|
|
// only place where it is used.
|
|
EnterExpressionEvaluationContext Unevaluated(
|
|
Actions, Sema::ExpressionEvaluationContext::Unevaluated);
|
|
AssociatedFunction = ParseOpenMPParensExpr(
|
|
getOpenMPDirectiveName(OMPD_declare_variant), RLoc,
|
|
/*IsAddressOfOperand=*/true);
|
|
}
|
|
if (!AssociatedFunction.isUsable()) {
|
|
if (!Tok.is(tok::annot_pragma_openmp_end))
|
|
while (!SkipUntil(tok::annot_pragma_openmp_end, StopBeforeMatch))
|
|
;
|
|
// Skip the last annot_pragma_openmp_end.
|
|
(void)ConsumeAnnotationToken();
|
|
return;
|
|
}
|
|
|
|
OMPTraitInfo *ParentTI = Actions.getOMPTraitInfoForSurroundingScope();
|
|
ASTContext &ASTCtx = Actions.getASTContext();
|
|
OMPTraitInfo &TI = ASTCtx.getNewOMPTraitInfo();
|
|
if (parseOMPDeclareVariantMatchClause(Loc, TI, ParentTI))
|
|
return;
|
|
|
|
Optional<std::pair<FunctionDecl *, Expr *>> DeclVarData =
|
|
Actions.checkOpenMPDeclareVariantFunction(
|
|
Ptr, AssociatedFunction.get(), TI,
|
|
SourceRange(Loc, Tok.getLocation()));
|
|
|
|
// Skip last tokens.
|
|
while (Tok.isNot(tok::annot_pragma_openmp_end))
|
|
ConsumeAnyToken();
|
|
if (DeclVarData && !TI.Sets.empty())
|
|
Actions.ActOnOpenMPDeclareVariantDirective(
|
|
DeclVarData->first, DeclVarData->second, TI,
|
|
SourceRange(Loc, Tok.getLocation()));
|
|
|
|
// Skip the last annot_pragma_openmp_end.
|
|
(void)ConsumeAnnotationToken();
|
|
}
|
|
|
|
bool Parser::parseOMPDeclareVariantMatchClause(SourceLocation Loc,
|
|
OMPTraitInfo &TI,
|
|
OMPTraitInfo *ParentTI) {
|
|
// Parse 'match'.
|
|
OpenMPClauseKind CKind = Tok.isAnnotation()
|
|
? OMPC_unknown
|
|
: getOpenMPClauseKind(PP.getSpelling(Tok));
|
|
if (CKind != OMPC_match) {
|
|
Diag(Tok.getLocation(), diag::err_omp_declare_variant_wrong_clause)
|
|
<< getOpenMPClauseName(OMPC_match);
|
|
while (!SkipUntil(tok::annot_pragma_openmp_end, Parser::StopBeforeMatch))
|
|
;
|
|
// Skip the last annot_pragma_openmp_end.
|
|
(void)ConsumeAnnotationToken();
|
|
return true;
|
|
}
|
|
(void)ConsumeToken();
|
|
// Parse '('.
|
|
BalancedDelimiterTracker T(*this, tok::l_paren, tok::annot_pragma_openmp_end);
|
|
if (T.expectAndConsume(diag::err_expected_lparen_after,
|
|
getOpenMPClauseName(OMPC_match).data())) {
|
|
while (!SkipUntil(tok::annot_pragma_openmp_end, StopBeforeMatch))
|
|
;
|
|
// Skip the last annot_pragma_openmp_end.
|
|
(void)ConsumeAnnotationToken();
|
|
return true;
|
|
}
|
|
|
|
// Parse inner context selectors.
|
|
parseOMPContextSelectors(Loc, TI);
|
|
|
|
// Parse ')'
|
|
(void)T.consumeClose();
|
|
|
|
if (!ParentTI)
|
|
return false;
|
|
|
|
// Merge the parent/outer trait info into the one we just parsed and diagnose
|
|
// problems.
|
|
// TODO: Keep some source location in the TI to provide better diagnostics.
|
|
// TODO: Perform some kind of equivalence check on the condition and score
|
|
// expressions.
|
|
for (const OMPTraitSet &ParentSet : ParentTI->Sets) {
|
|
bool MergedSet = false;
|
|
for (OMPTraitSet &Set : TI.Sets) {
|
|
if (Set.Kind != ParentSet.Kind)
|
|
continue;
|
|
MergedSet = true;
|
|
for (const OMPTraitSelector &ParentSelector : ParentSet.Selectors) {
|
|
bool MergedSelector = false;
|
|
for (OMPTraitSelector &Selector : Set.Selectors) {
|
|
if (Selector.Kind != ParentSelector.Kind)
|
|
continue;
|
|
MergedSelector = true;
|
|
for (const OMPTraitProperty &ParentProperty :
|
|
ParentSelector.Properties) {
|
|
bool MergedProperty = false;
|
|
for (OMPTraitProperty &Property : Selector.Properties) {
|
|
// Ignore "equivalent" properties.
|
|
if (Property.Kind != ParentProperty.Kind)
|
|
continue;
|
|
|
|
// If the kind is the same but the raw string not, we don't want
|
|
// to skip out on the property.
|
|
MergedProperty |= Property.RawString == ParentProperty.RawString;
|
|
|
|
if (Property.RawString == ParentProperty.RawString &&
|
|
Selector.ScoreOrCondition == ParentSelector.ScoreOrCondition)
|
|
continue;
|
|
|
|
if (Selector.Kind == llvm::omp::TraitSelector::user_condition) {
|
|
Diag(Loc, diag::err_omp_declare_variant_nested_user_condition);
|
|
} else if (Selector.ScoreOrCondition !=
|
|
ParentSelector.ScoreOrCondition) {
|
|
Diag(Loc, diag::err_omp_declare_variant_duplicate_nested_trait)
|
|
<< getOpenMPContextTraitPropertyName(
|
|
ParentProperty.Kind, ParentProperty.RawString)
|
|
<< getOpenMPContextTraitSelectorName(ParentSelector.Kind)
|
|
<< getOpenMPContextTraitSetName(ParentSet.Kind);
|
|
}
|
|
}
|
|
if (!MergedProperty)
|
|
Selector.Properties.push_back(ParentProperty);
|
|
}
|
|
}
|
|
if (!MergedSelector)
|
|
Set.Selectors.push_back(ParentSelector);
|
|
}
|
|
}
|
|
if (!MergedSet)
|
|
TI.Sets.push_back(ParentSet);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/// `omp assumes` or `omp begin/end assumes` <clause> [[,]<clause>]...
|
|
/// where
|
|
///
|
|
/// clause:
|
|
/// 'ext_IMPL_DEFINED'
|
|
/// 'absent' '(' directive-name [, directive-name]* ')'
|
|
/// 'contains' '(' directive-name [, directive-name]* ')'
|
|
/// 'holds' '(' scalar-expression ')'
|
|
/// 'no_openmp'
|
|
/// 'no_openmp_routines'
|
|
/// 'no_parallelism'
|
|
///
|
|
void Parser::ParseOpenMPAssumesDirective(OpenMPDirectiveKind DKind,
|
|
SourceLocation Loc) {
|
|
SmallVector<StringRef, 4> Assumptions;
|
|
bool SkippedClauses = false;
|
|
|
|
auto SkipBraces = [&](llvm::StringRef Spelling, bool IssueNote) {
|
|
BalancedDelimiterTracker T(*this, tok::l_paren,
|
|
tok::annot_pragma_openmp_end);
|
|
if (T.expectAndConsume(diag::err_expected_lparen_after, Spelling.data()))
|
|
return;
|
|
T.skipToEnd();
|
|
if (IssueNote && T.getCloseLocation().isValid())
|
|
Diag(T.getCloseLocation(),
|
|
diag::note_omp_assumption_clause_continue_here);
|
|
};
|
|
|
|
/// Helper to determine which AssumptionClauseMapping (ACM) in the
|
|
/// AssumptionClauseMappings table matches \p RawString. The return value is
|
|
/// the index of the matching ACM into the table or -1 if there was no match.
|
|
auto MatchACMClause = [&](StringRef RawString) {
|
|
llvm::StringSwitch<int> SS(RawString);
|
|
unsigned ACMIdx = 0;
|
|
for (const AssumptionClauseMappingInfo &ACMI : AssumptionClauseMappings) {
|
|
if (ACMI.StartsWith)
|
|
SS.StartsWith(ACMI.Identifier, ACMIdx++);
|
|
else
|
|
SS.Case(ACMI.Identifier, ACMIdx++);
|
|
}
|
|
return SS.Default(-1);
|
|
};
|
|
|
|
while (Tok.isNot(tok::annot_pragma_openmp_end)) {
|
|
IdentifierInfo *II = nullptr;
|
|
SourceLocation StartLoc = Tok.getLocation();
|
|
int Idx = -1;
|
|
if (Tok.isAnyIdentifier()) {
|
|
II = Tok.getIdentifierInfo();
|
|
Idx = MatchACMClause(II->getName());
|
|
}
|
|
ConsumeAnyToken();
|
|
|
|
bool NextIsLPar = Tok.is(tok::l_paren);
|
|
// Handle unknown clauses by skipping them.
|
|
if (Idx == -1) {
|
|
Diag(StartLoc, diag::warn_omp_unknown_assumption_clause_missing_id)
|
|
<< llvm::omp::getOpenMPDirectiveName(DKind)
|
|
<< llvm::omp::getAllAssumeClauseOptions() << NextIsLPar;
|
|
if (NextIsLPar)
|
|
SkipBraces(II ? II->getName() : "", /* IssueNote */ true);
|
|
SkippedClauses = true;
|
|
continue;
|
|
}
|
|
const AssumptionClauseMappingInfo &ACMI = AssumptionClauseMappings[Idx];
|
|
if (ACMI.HasDirectiveList || ACMI.HasExpression) {
|
|
// TODO: We ignore absent, contains, and holds assumptions for now. We
|
|
// also do not verify the content in the parenthesis at all.
|
|
SkippedClauses = true;
|
|
SkipBraces(II->getName(), /* IssueNote */ false);
|
|
continue;
|
|
}
|
|
|
|
if (NextIsLPar) {
|
|
Diag(Tok.getLocation(),
|
|
diag::warn_omp_unknown_assumption_clause_without_args)
|
|
<< II;
|
|
SkipBraces(II->getName(), /* IssueNote */ true);
|
|
}
|
|
|
|
assert(II && "Expected an identifier clause!");
|
|
StringRef Assumption = II->getName();
|
|
if (ACMI.StartsWith)
|
|
Assumption = Assumption.substr(ACMI.Identifier.size());
|
|
Assumptions.push_back(Assumption);
|
|
}
|
|
|
|
Actions.ActOnOpenMPAssumesDirective(Loc, DKind, Assumptions, SkippedClauses);
|
|
}
|
|
|
|
void Parser::ParseOpenMPEndAssumesDirective(SourceLocation Loc) {
|
|
if (Actions.isInOpenMPAssumeScope())
|
|
Actions.ActOnOpenMPEndAssumesDirective();
|
|
else
|
|
Diag(Loc, diag::err_expected_begin_assumes);
|
|
}
|
|
|
|
/// Parsing of simple OpenMP clauses like 'default' or 'proc_bind'.
|
|
///
|
|
/// default-clause:
|
|
/// 'default' '(' 'none' | 'shared' | 'firstprivate' ')
|
|
///
|
|
/// proc_bind-clause:
|
|
/// 'proc_bind' '(' 'master' | 'close' | 'spread' ')
|
|
///
|
|
/// device_type-clause:
|
|
/// 'device_type' '(' 'host' | 'nohost' | 'any' )'
|
|
namespace {
|
|
struct SimpleClauseData {
|
|
unsigned Type;
|
|
SourceLocation Loc;
|
|
SourceLocation LOpen;
|
|
SourceLocation TypeLoc;
|
|
SourceLocation RLoc;
|
|
SimpleClauseData(unsigned Type, SourceLocation Loc, SourceLocation LOpen,
|
|
SourceLocation TypeLoc, SourceLocation RLoc)
|
|
: Type(Type), Loc(Loc), LOpen(LOpen), TypeLoc(TypeLoc), RLoc(RLoc) {}
|
|
};
|
|
} // anonymous namespace
|
|
|
|
static Optional<SimpleClauseData>
|
|
parseOpenMPSimpleClause(Parser &P, OpenMPClauseKind Kind) {
|
|
const Token &Tok = P.getCurToken();
|
|
SourceLocation Loc = Tok.getLocation();
|
|
SourceLocation LOpen = P.ConsumeToken();
|
|
// Parse '('.
|
|
BalancedDelimiterTracker T(P, tok::l_paren, tok::annot_pragma_openmp_end);
|
|
if (T.expectAndConsume(diag::err_expected_lparen_after,
|
|
getOpenMPClauseName(Kind).data()))
|
|
return llvm::None;
|
|
|
|
unsigned Type = getOpenMPSimpleClauseType(
|
|
Kind, Tok.isAnnotation() ? "" : P.getPreprocessor().getSpelling(Tok),
|
|
P.getLangOpts().OpenMP);
|
|
SourceLocation TypeLoc = Tok.getLocation();
|
|
if (Tok.isNot(tok::r_paren) && Tok.isNot(tok::comma) &&
|
|
Tok.isNot(tok::annot_pragma_openmp_end))
|
|
P.ConsumeAnyToken();
|
|
|
|
// Parse ')'.
|
|
SourceLocation RLoc = Tok.getLocation();
|
|
if (!T.consumeClose())
|
|
RLoc = T.getCloseLocation();
|
|
|
|
return SimpleClauseData(Type, Loc, LOpen, TypeLoc, RLoc);
|
|
}
|
|
|
|
void Parser::ParseOMPDeclareTargetClauses(
|
|
Sema::DeclareTargetContextInfo &DTCI) {
|
|
SourceLocation DeviceTypeLoc;
|
|
bool RequiresToOrLinkClause = false;
|
|
bool HasToOrLinkClause = false;
|
|
while (Tok.isNot(tok::annot_pragma_openmp_end)) {
|
|
OMPDeclareTargetDeclAttr::MapTypeTy MT = OMPDeclareTargetDeclAttr::MT_To;
|
|
bool HasIdentifier = Tok.is(tok::identifier);
|
|
if (HasIdentifier) {
|
|
// If we see any clause we need a to or link clause.
|
|
RequiresToOrLinkClause = true;
|
|
IdentifierInfo *II = Tok.getIdentifierInfo();
|
|
StringRef ClauseName = II->getName();
|
|
bool IsDeviceTypeClause =
|
|
getLangOpts().OpenMP >= 50 &&
|
|
getOpenMPClauseKind(ClauseName) == OMPC_device_type;
|
|
|
|
bool IsToOrLinkClause =
|
|
OMPDeclareTargetDeclAttr::ConvertStrToMapTypeTy(ClauseName, MT);
|
|
assert((!IsDeviceTypeClause || !IsToOrLinkClause) && "Cannot be both!");
|
|
|
|
if (!IsDeviceTypeClause && DTCI.Kind == OMPD_begin_declare_target) {
|
|
Diag(Tok, diag::err_omp_declare_target_unexpected_clause)
|
|
<< ClauseName << 0;
|
|
break;
|
|
}
|
|
if (!IsDeviceTypeClause && !IsToOrLinkClause) {
|
|
Diag(Tok, diag::err_omp_declare_target_unexpected_clause)
|
|
<< ClauseName << (getLangOpts().OpenMP >= 50 ? 2 : 1);
|
|
break;
|
|
}
|
|
|
|
if (IsToOrLinkClause)
|
|
HasToOrLinkClause = true;
|
|
|
|
// Parse 'device_type' clause and go to next clause if any.
|
|
if (IsDeviceTypeClause) {
|
|
Optional<SimpleClauseData> DevTypeData =
|
|
parseOpenMPSimpleClause(*this, OMPC_device_type);
|
|
if (DevTypeData.hasValue()) {
|
|
if (DeviceTypeLoc.isValid()) {
|
|
// We already saw another device_type clause, diagnose it.
|
|
Diag(DevTypeData.getValue().Loc,
|
|
diag::warn_omp_more_one_device_type_clause);
|
|
break;
|
|
}
|
|
switch (static_cast<OpenMPDeviceType>(DevTypeData.getValue().Type)) {
|
|
case OMPC_DEVICE_TYPE_any:
|
|
DTCI.DT = OMPDeclareTargetDeclAttr::DT_Any;
|
|
break;
|
|
case OMPC_DEVICE_TYPE_host:
|
|
DTCI.DT = OMPDeclareTargetDeclAttr::DT_Host;
|
|
break;
|
|
case OMPC_DEVICE_TYPE_nohost:
|
|
DTCI.DT = OMPDeclareTargetDeclAttr::DT_NoHost;
|
|
break;
|
|
case OMPC_DEVICE_TYPE_unknown:
|
|
llvm_unreachable("Unexpected device_type");
|
|
}
|
|
DeviceTypeLoc = DevTypeData.getValue().Loc;
|
|
}
|
|
continue;
|
|
}
|
|
ConsumeToken();
|
|
}
|
|
|
|
if (DTCI.Kind == OMPD_declare_target || HasIdentifier) {
|
|
auto &&Callback = [this, MT, &DTCI](CXXScopeSpec &SS,
|
|
DeclarationNameInfo NameInfo) {
|
|
NamedDecl *ND =
|
|
Actions.lookupOpenMPDeclareTargetName(getCurScope(), SS, NameInfo);
|
|
if (!ND)
|
|
return;
|
|
Sema::DeclareTargetContextInfo::MapInfo MI{MT, NameInfo.getLoc()};
|
|
bool FirstMapping = DTCI.ExplicitlyMapped.try_emplace(ND, MI).second;
|
|
if (!FirstMapping)
|
|
Diag(NameInfo.getLoc(), diag::err_omp_declare_target_multiple)
|
|
<< NameInfo.getName();
|
|
};
|
|
if (ParseOpenMPSimpleVarList(OMPD_declare_target, Callback,
|
|
/*AllowScopeSpecifier=*/true))
|
|
break;
|
|
}
|
|
|
|
if (Tok.is(tok::l_paren)) {
|
|
Diag(Tok,
|
|
diag::err_omp_begin_declare_target_unexpected_implicit_to_clause);
|
|
break;
|
|
}
|
|
if (!HasIdentifier && Tok.isNot(tok::annot_pragma_openmp_end)) {
|
|
Diag(Tok,
|
|
diag::err_omp_declare_target_unexpected_clause_after_implicit_to);
|
|
break;
|
|
}
|
|
|
|
// Consume optional ','.
|
|
if (Tok.is(tok::comma))
|
|
ConsumeToken();
|
|
}
|
|
|
|
// For declare target require at least 'to' or 'link' to be present.
|
|
if (DTCI.Kind == OMPD_declare_target && RequiresToOrLinkClause &&
|
|
!HasToOrLinkClause)
|
|
Diag(DTCI.Loc, diag::err_omp_declare_target_missing_to_or_link_clause);
|
|
|
|
SkipUntil(tok::annot_pragma_openmp_end, StopBeforeMatch);
|
|
}
|
|
|
|
void Parser::skipUntilPragmaOpenMPEnd(OpenMPDirectiveKind DKind) {
|
|
// The last seen token is annot_pragma_openmp_end - need to check for
|
|
// extra tokens.
|
|
if (Tok.is(tok::annot_pragma_openmp_end))
|
|
return;
|
|
|
|
Diag(Tok, diag::warn_omp_extra_tokens_at_eol)
|
|
<< getOpenMPDirectiveName(DKind);
|
|
while (Tok.isNot(tok::annot_pragma_openmp_end))
|
|
ConsumeAnyToken();
|
|
}
|
|
|
|
void Parser::parseOMPEndDirective(OpenMPDirectiveKind BeginKind,
|
|
OpenMPDirectiveKind ExpectedKind,
|
|
OpenMPDirectiveKind FoundKind,
|
|
SourceLocation BeginLoc,
|
|
SourceLocation FoundLoc,
|
|
bool SkipUntilOpenMPEnd) {
|
|
int DiagSelection = ExpectedKind == OMPD_end_declare_target ? 0 : 1;
|
|
|
|
if (FoundKind == ExpectedKind) {
|
|
ConsumeAnyToken();
|
|
skipUntilPragmaOpenMPEnd(ExpectedKind);
|
|
return;
|
|
}
|
|
|
|
Diag(FoundLoc, diag::err_expected_end_declare_target_or_variant)
|
|
<< DiagSelection;
|
|
Diag(BeginLoc, diag::note_matching)
|
|
<< ("'#pragma omp " + getOpenMPDirectiveName(BeginKind) + "'").str();
|
|
if (SkipUntilOpenMPEnd)
|
|
SkipUntil(tok::annot_pragma_openmp_end, StopBeforeMatch);
|
|
}
|
|
|
|
void Parser::ParseOMPEndDeclareTargetDirective(OpenMPDirectiveKind BeginDKind,
|
|
OpenMPDirectiveKind EndDKind,
|
|
SourceLocation DKLoc) {
|
|
parseOMPEndDirective(BeginDKind, OMPD_end_declare_target, EndDKind, DKLoc,
|
|
Tok.getLocation(),
|
|
/* SkipUntilOpenMPEnd */ false);
|
|
// Skip the last annot_pragma_openmp_end.
|
|
if (Tok.is(tok::annot_pragma_openmp_end))
|
|
ConsumeAnnotationToken();
|
|
}
|
|
|
|
/// Parsing of declarative OpenMP directives.
|
|
///
|
|
/// threadprivate-directive:
|
|
/// annot_pragma_openmp 'threadprivate' simple-variable-list
|
|
/// annot_pragma_openmp_end
|
|
///
|
|
/// allocate-directive:
|
|
/// annot_pragma_openmp 'allocate' simple-variable-list [<clause>]
|
|
/// annot_pragma_openmp_end
|
|
///
|
|
/// declare-reduction-directive:
|
|
/// annot_pragma_openmp 'declare' 'reduction' [...]
|
|
/// annot_pragma_openmp_end
|
|
///
|
|
/// declare-mapper-directive:
|
|
/// annot_pragma_openmp 'declare' 'mapper' '(' [<mapper-identifer> ':']
|
|
/// <type> <var> ')' [<clause>[[,] <clause>] ... ]
|
|
/// annot_pragma_openmp_end
|
|
///
|
|
/// declare-simd-directive:
|
|
/// annot_pragma_openmp 'declare simd' {<clause> [,]}
|
|
/// annot_pragma_openmp_end
|
|
/// <function declaration/definition>
|
|
///
|
|
/// requires directive:
|
|
/// annot_pragma_openmp 'requires' <clause> [[[,] <clause>] ... ]
|
|
/// annot_pragma_openmp_end
|
|
///
|
|
/// assumes directive:
|
|
/// annot_pragma_openmp 'assumes' <clause> [[[,] <clause>] ... ]
|
|
/// annot_pragma_openmp_end
|
|
/// or
|
|
/// annot_pragma_openmp 'begin assumes' <clause> [[[,] <clause>] ... ]
|
|
/// annot_pragma_openmp 'end assumes'
|
|
/// annot_pragma_openmp_end
|
|
///
|
|
Parser::DeclGroupPtrTy Parser::ParseOpenMPDeclarativeDirectiveWithExtDecl(
|
|
AccessSpecifier &AS, ParsedAttributesWithRange &Attrs, bool Delayed,
|
|
DeclSpec::TST TagType, Decl *Tag) {
|
|
assert(Tok.is(tok::annot_pragma_openmp) && "Not an OpenMP directive!");
|
|
ParsingOpenMPDirectiveRAII DirScope(*this);
|
|
ParenBraceBracketBalancer BalancerRAIIObj(*this);
|
|
|
|
SourceLocation Loc;
|
|
OpenMPDirectiveKind DKind;
|
|
if (Delayed) {
|
|
TentativeParsingAction TPA(*this);
|
|
Loc = ConsumeAnnotationToken();
|
|
DKind = parseOpenMPDirectiveKind(*this);
|
|
if (DKind == OMPD_declare_reduction || DKind == OMPD_declare_mapper) {
|
|
// Need to delay parsing until completion of the parent class.
|
|
TPA.Revert();
|
|
CachedTokens Toks;
|
|
unsigned Cnt = 1;
|
|
Toks.push_back(Tok);
|
|
while (Cnt && Tok.isNot(tok::eof)) {
|
|
(void)ConsumeAnyToken();
|
|
if (Tok.is(tok::annot_pragma_openmp))
|
|
++Cnt;
|
|
else if (Tok.is(tok::annot_pragma_openmp_end))
|
|
--Cnt;
|
|
Toks.push_back(Tok);
|
|
}
|
|
// Skip last annot_pragma_openmp_end.
|
|
if (Cnt == 0)
|
|
(void)ConsumeAnyToken();
|
|
auto *LP = new LateParsedPragma(this, AS);
|
|
LP->takeToks(Toks);
|
|
getCurrentClass().LateParsedDeclarations.push_back(LP);
|
|
return nullptr;
|
|
}
|
|
TPA.Commit();
|
|
} else {
|
|
Loc = ConsumeAnnotationToken();
|
|
DKind = parseOpenMPDirectiveKind(*this);
|
|
}
|
|
|
|
switch (DKind) {
|
|
case OMPD_threadprivate: {
|
|
ConsumeToken();
|
|
DeclDirectiveListParserHelper Helper(this, DKind);
|
|
if (!ParseOpenMPSimpleVarList(DKind, Helper,
|
|
/*AllowScopeSpecifier=*/true)) {
|
|
skipUntilPragmaOpenMPEnd(DKind);
|
|
// Skip the last annot_pragma_openmp_end.
|
|
ConsumeAnnotationToken();
|
|
return Actions.ActOnOpenMPThreadprivateDirective(Loc,
|
|
Helper.getIdentifiers());
|
|
}
|
|
break;
|
|
}
|
|
case OMPD_allocate: {
|
|
ConsumeToken();
|
|
DeclDirectiveListParserHelper Helper(this, DKind);
|
|
if (!ParseOpenMPSimpleVarList(DKind, Helper,
|
|
/*AllowScopeSpecifier=*/true)) {
|
|
SmallVector<OMPClause *, 1> Clauses;
|
|
if (Tok.isNot(tok::annot_pragma_openmp_end)) {
|
|
SmallVector<llvm::PointerIntPair<OMPClause *, 1, bool>,
|
|
llvm::omp::Clause_enumSize + 1>
|
|
FirstClauses(llvm::omp::Clause_enumSize + 1);
|
|
while (Tok.isNot(tok::annot_pragma_openmp_end)) {
|
|
OpenMPClauseKind CKind =
|
|
Tok.isAnnotation() ? OMPC_unknown
|
|
: getOpenMPClauseKind(PP.getSpelling(Tok));
|
|
Actions.StartOpenMPClause(CKind);
|
|
OMPClause *Clause = ParseOpenMPClause(
|
|
OMPD_allocate, CKind, !FirstClauses[unsigned(CKind)].getInt());
|
|
SkipUntil(tok::comma, tok::identifier, tok::annot_pragma_openmp_end,
|
|
StopBeforeMatch);
|
|
FirstClauses[unsigned(CKind)].setInt(true);
|
|
if (Clause != nullptr)
|
|
Clauses.push_back(Clause);
|
|
if (Tok.is(tok::annot_pragma_openmp_end)) {
|
|
Actions.EndOpenMPClause();
|
|
break;
|
|
}
|
|
// Skip ',' if any.
|
|
if (Tok.is(tok::comma))
|
|
ConsumeToken();
|
|
Actions.EndOpenMPClause();
|
|
}
|
|
skipUntilPragmaOpenMPEnd(DKind);
|
|
}
|
|
// Skip the last annot_pragma_openmp_end.
|
|
ConsumeAnnotationToken();
|
|
return Actions.ActOnOpenMPAllocateDirective(Loc, Helper.getIdentifiers(),
|
|
Clauses);
|
|
}
|
|
break;
|
|
}
|
|
case OMPD_requires: {
|
|
SourceLocation StartLoc = ConsumeToken();
|
|
SmallVector<OMPClause *, 5> Clauses;
|
|
SmallVector<llvm::PointerIntPair<OMPClause *, 1, bool>,
|
|
llvm::omp::Clause_enumSize + 1>
|
|
FirstClauses(llvm::omp::Clause_enumSize + 1);
|
|
if (Tok.is(tok::annot_pragma_openmp_end)) {
|
|
Diag(Tok, diag::err_omp_expected_clause)
|
|
<< getOpenMPDirectiveName(OMPD_requires);
|
|
break;
|
|
}
|
|
while (Tok.isNot(tok::annot_pragma_openmp_end)) {
|
|
OpenMPClauseKind CKind = Tok.isAnnotation()
|
|
? OMPC_unknown
|
|
: getOpenMPClauseKind(PP.getSpelling(Tok));
|
|
Actions.StartOpenMPClause(CKind);
|
|
OMPClause *Clause = ParseOpenMPClause(
|
|
OMPD_requires, CKind, !FirstClauses[unsigned(CKind)].getInt());
|
|
SkipUntil(tok::comma, tok::identifier, tok::annot_pragma_openmp_end,
|
|
StopBeforeMatch);
|
|
FirstClauses[unsigned(CKind)].setInt(true);
|
|
if (Clause != nullptr)
|
|
Clauses.push_back(Clause);
|
|
if (Tok.is(tok::annot_pragma_openmp_end)) {
|
|
Actions.EndOpenMPClause();
|
|
break;
|
|
}
|
|
// Skip ',' if any.
|
|
if (Tok.is(tok::comma))
|
|
ConsumeToken();
|
|
Actions.EndOpenMPClause();
|
|
}
|
|
// Consume final annot_pragma_openmp_end
|
|
if (Clauses.empty()) {
|
|
Diag(Tok, diag::err_omp_expected_clause)
|
|
<< getOpenMPDirectiveName(OMPD_requires);
|
|
ConsumeAnnotationToken();
|
|
return nullptr;
|
|
}
|
|
ConsumeAnnotationToken();
|
|
return Actions.ActOnOpenMPRequiresDirective(StartLoc, Clauses);
|
|
}
|
|
case OMPD_assumes:
|
|
case OMPD_begin_assumes:
|
|
ParseOpenMPAssumesDirective(DKind, ConsumeToken());
|
|
break;
|
|
case OMPD_end_assumes:
|
|
ParseOpenMPEndAssumesDirective(ConsumeToken());
|
|
break;
|
|
case OMPD_declare_reduction:
|
|
ConsumeToken();
|
|
if (DeclGroupPtrTy Res = ParseOpenMPDeclareReductionDirective(AS)) {
|
|
skipUntilPragmaOpenMPEnd(OMPD_declare_reduction);
|
|
// Skip the last annot_pragma_openmp_end.
|
|
ConsumeAnnotationToken();
|
|
return Res;
|
|
}
|
|
break;
|
|
case OMPD_declare_mapper: {
|
|
ConsumeToken();
|
|
if (DeclGroupPtrTy Res = ParseOpenMPDeclareMapperDirective(AS)) {
|
|
// Skip the last annot_pragma_openmp_end.
|
|
ConsumeAnnotationToken();
|
|
return Res;
|
|
}
|
|
break;
|
|
}
|
|
case OMPD_begin_declare_variant: {
|
|
// The syntax is:
|
|
// { #pragma omp begin declare variant clause }
|
|
// <function-declaration-or-definition-sequence>
|
|
// { #pragma omp end declare variant }
|
|
//
|
|
ConsumeToken();
|
|
OMPTraitInfo *ParentTI = Actions.getOMPTraitInfoForSurroundingScope();
|
|
ASTContext &ASTCtx = Actions.getASTContext();
|
|
OMPTraitInfo &TI = ASTCtx.getNewOMPTraitInfo();
|
|
if (parseOMPDeclareVariantMatchClause(Loc, TI, ParentTI))
|
|
break;
|
|
|
|
// Skip last tokens.
|
|
skipUntilPragmaOpenMPEnd(OMPD_begin_declare_variant);
|
|
|
|
ParsingOpenMPDirectiveRAII NormalScope(*this, /*Value=*/false);
|
|
|
|
VariantMatchInfo VMI;
|
|
TI.getAsVariantMatchInfo(ASTCtx, VMI);
|
|
|
|
std::function<void(StringRef)> DiagUnknownTrait = [this, Loc](
|
|
StringRef ISATrait) {
|
|
// TODO Track the selector locations in a way that is accessible here to
|
|
// improve the diagnostic location.
|
|
Diag(Loc, diag::warn_unknown_begin_declare_variant_isa_trait) << ISATrait;
|
|
};
|
|
TargetOMPContext OMPCtx(ASTCtx, std::move(DiagUnknownTrait),
|
|
/* CurrentFunctionDecl */ nullptr);
|
|
|
|
if (isVariantApplicableInContext(VMI, OMPCtx, /* DeviceSetOnly */ true)) {
|
|
Actions.ActOnOpenMPBeginDeclareVariant(Loc, TI);
|
|
break;
|
|
}
|
|
|
|
// Elide all the code till the matching end declare variant was found.
|
|
unsigned Nesting = 1;
|
|
SourceLocation DKLoc;
|
|
OpenMPDirectiveKind DK = OMPD_unknown;
|
|
do {
|
|
DKLoc = Tok.getLocation();
|
|
DK = parseOpenMPDirectiveKind(*this);
|
|
if (DK == OMPD_end_declare_variant)
|
|
--Nesting;
|
|
else if (DK == OMPD_begin_declare_variant)
|
|
++Nesting;
|
|
if (!Nesting || isEofOrEom())
|
|
break;
|
|
ConsumeAnyToken();
|
|
} while (true);
|
|
|
|
parseOMPEndDirective(OMPD_begin_declare_variant, OMPD_end_declare_variant,
|
|
DK, Loc, DKLoc, /* SkipUntilOpenMPEnd */ true);
|
|
if (isEofOrEom())
|
|
return nullptr;
|
|
break;
|
|
}
|
|
case OMPD_end_declare_variant: {
|
|
if (Actions.isInOpenMPDeclareVariantScope())
|
|
Actions.ActOnOpenMPEndDeclareVariant();
|
|
else
|
|
Diag(Loc, diag::err_expected_begin_declare_variant);
|
|
ConsumeToken();
|
|
break;
|
|
}
|
|
case OMPD_declare_variant:
|
|
case OMPD_declare_simd: {
|
|
// The syntax is:
|
|
// { #pragma omp declare {simd|variant} }
|
|
// <function-declaration-or-definition>
|
|
//
|
|
CachedTokens Toks;
|
|
Toks.push_back(Tok);
|
|
ConsumeToken();
|
|
while (Tok.isNot(tok::annot_pragma_openmp_end)) {
|
|
Toks.push_back(Tok);
|
|
ConsumeAnyToken();
|
|
}
|
|
Toks.push_back(Tok);
|
|
ConsumeAnyToken();
|
|
|
|
DeclGroupPtrTy Ptr;
|
|
if (Tok.is(tok::annot_pragma_openmp)) {
|
|
Ptr = ParseOpenMPDeclarativeDirectiveWithExtDecl(AS, Attrs, Delayed,
|
|
TagType, Tag);
|
|
} else if (Tok.isNot(tok::r_brace) && !isEofOrEom()) {
|
|
// Here we expect to see some function declaration.
|
|
if (AS == AS_none) {
|
|
assert(TagType == DeclSpec::TST_unspecified);
|
|
MaybeParseCXX11Attributes(Attrs);
|
|
ParsingDeclSpec PDS(*this);
|
|
Ptr = ParseExternalDeclaration(Attrs, &PDS);
|
|
} else {
|
|
Ptr =
|
|
ParseCXXClassMemberDeclarationWithPragmas(AS, Attrs, TagType, Tag);
|
|
}
|
|
}
|
|
if (!Ptr) {
|
|
Diag(Loc, diag::err_omp_decl_in_declare_simd_variant)
|
|
<< (DKind == OMPD_declare_simd ? 0 : 1);
|
|
return DeclGroupPtrTy();
|
|
}
|
|
if (DKind == OMPD_declare_simd)
|
|
return ParseOMPDeclareSimdClauses(Ptr, Toks, Loc);
|
|
assert(DKind == OMPD_declare_variant &&
|
|
"Expected declare variant directive only");
|
|
ParseOMPDeclareVariantClauses(Ptr, Toks, Loc);
|
|
return Ptr;
|
|
}
|
|
case OMPD_begin_declare_target:
|
|
case OMPD_declare_target: {
|
|
SourceLocation DTLoc = ConsumeAnyToken();
|
|
bool HasClauses = Tok.isNot(tok::annot_pragma_openmp_end);
|
|
bool HasImplicitMappings =
|
|
DKind == OMPD_begin_declare_target || !HasClauses;
|
|
Sema::DeclareTargetContextInfo DTCI(DKind, DTLoc);
|
|
if (HasClauses)
|
|
ParseOMPDeclareTargetClauses(DTCI);
|
|
|
|
// Skip the last annot_pragma_openmp_end.
|
|
ConsumeAnyToken();
|
|
|
|
if (HasImplicitMappings) {
|
|
Actions.ActOnStartOpenMPDeclareTargetContext(DTCI);
|
|
return nullptr;
|
|
}
|
|
|
|
Actions.ActOnFinishedOpenMPDeclareTargetContext(DTCI);
|
|
llvm::SmallVector<Decl *, 4> Decls;
|
|
for (auto &It : DTCI.ExplicitlyMapped)
|
|
Decls.push_back(It.first);
|
|
return Actions.BuildDeclaratorGroup(Decls);
|
|
}
|
|
case OMPD_end_declare_target: {
|
|
if (!Actions.isInOpenMPDeclareTargetContext()) {
|
|
Diag(Tok, diag::err_omp_unexpected_directive)
|
|
<< 1 << getOpenMPDirectiveName(DKind);
|
|
break;
|
|
}
|
|
const Sema::DeclareTargetContextInfo &DTCI =
|
|
Actions.ActOnOpenMPEndDeclareTargetDirective();
|
|
ParseOMPEndDeclareTargetDirective(DTCI.Kind, DKind, DTCI.Loc);
|
|
return nullptr;
|
|
}
|
|
case OMPD_unknown:
|
|
Diag(Tok, diag::err_omp_unknown_directive);
|
|
break;
|
|
case OMPD_parallel:
|
|
case OMPD_simd:
|
|
case OMPD_tile:
|
|
case OMPD_unroll:
|
|
case OMPD_task:
|
|
case OMPD_taskyield:
|
|
case OMPD_barrier:
|
|
case OMPD_taskwait:
|
|
case OMPD_taskgroup:
|
|
case OMPD_flush:
|
|
case OMPD_depobj:
|
|
case OMPD_scan:
|
|
case OMPD_for:
|
|
case OMPD_for_simd:
|
|
case OMPD_sections:
|
|
case OMPD_section:
|
|
case OMPD_single:
|
|
case OMPD_master:
|
|
case OMPD_ordered:
|
|
case OMPD_critical:
|
|
case OMPD_parallel_for:
|
|
case OMPD_parallel_for_simd:
|
|
case OMPD_parallel_sections:
|
|
case OMPD_parallel_master:
|
|
case OMPD_atomic:
|
|
case OMPD_target:
|
|
case OMPD_teams:
|
|
case OMPD_cancellation_point:
|
|
case OMPD_cancel:
|
|
case OMPD_target_data:
|
|
case OMPD_target_enter_data:
|
|
case OMPD_target_exit_data:
|
|
case OMPD_target_parallel:
|
|
case OMPD_target_parallel_for:
|
|
case OMPD_taskloop:
|
|
case OMPD_taskloop_simd:
|
|
case OMPD_master_taskloop:
|
|
case OMPD_master_taskloop_simd:
|
|
case OMPD_parallel_master_taskloop:
|
|
case OMPD_parallel_master_taskloop_simd:
|
|
case OMPD_distribute:
|
|
case OMPD_target_update:
|
|
case OMPD_distribute_parallel_for:
|
|
case OMPD_distribute_parallel_for_simd:
|
|
case OMPD_distribute_simd:
|
|
case OMPD_target_parallel_for_simd:
|
|
case OMPD_target_simd:
|
|
case OMPD_teams_distribute:
|
|
case OMPD_teams_distribute_simd:
|
|
case OMPD_teams_distribute_parallel_for_simd:
|
|
case OMPD_teams_distribute_parallel_for:
|
|
case OMPD_target_teams:
|
|
case OMPD_target_teams_distribute:
|
|
case OMPD_target_teams_distribute_parallel_for:
|
|
case OMPD_target_teams_distribute_parallel_for_simd:
|
|
case OMPD_target_teams_distribute_simd:
|
|
case OMPD_dispatch:
|
|
case OMPD_masked:
|
|
Diag(Tok, diag::err_omp_unexpected_directive)
|
|
<< 1 << getOpenMPDirectiveName(DKind);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
while (Tok.isNot(tok::annot_pragma_openmp_end))
|
|
ConsumeAnyToken();
|
|
ConsumeAnyToken();
|
|
return nullptr;
|
|
}
|
|
|
|
/// Parsing of declarative or executable OpenMP directives.
|
|
///
|
|
/// threadprivate-directive:
|
|
/// annot_pragma_openmp 'threadprivate' simple-variable-list
|
|
/// annot_pragma_openmp_end
|
|
///
|
|
/// allocate-directive:
|
|
/// annot_pragma_openmp 'allocate' simple-variable-list
|
|
/// annot_pragma_openmp_end
|
|
///
|
|
/// declare-reduction-directive:
|
|
/// annot_pragma_openmp 'declare' 'reduction' '(' <reduction_id> ':'
|
|
/// <type> {',' <type>} ':' <expression> ')' ['initializer' '('
|
|
/// ('omp_priv' '=' <expression>|<function_call>) ')']
|
|
/// annot_pragma_openmp_end
|
|
///
|
|
/// declare-mapper-directive:
|
|
/// annot_pragma_openmp 'declare' 'mapper' '(' [<mapper-identifer> ':']
|
|
/// <type> <var> ')' [<clause>[[,] <clause>] ... ]
|
|
/// annot_pragma_openmp_end
|
|
///
|
|
/// executable-directive:
|
|
/// annot_pragma_openmp 'parallel' | 'simd' | 'for' | 'sections' |
|
|
/// 'section' | 'single' | 'master' | 'critical' [ '(' <name> ')' ] |
|
|
/// 'parallel for' | 'parallel sections' | 'parallel master' | 'task' |
|
|
/// 'taskyield' | 'barrier' | 'taskwait' | 'flush' | 'ordered' |
|
|
/// 'atomic' | 'for simd' | 'parallel for simd' | 'target' | 'target
|
|
/// data' | 'taskgroup' | 'teams' | 'taskloop' | 'taskloop simd' |
|
|
/// 'master taskloop' | 'master taskloop simd' | 'parallel master
|
|
/// taskloop' | 'parallel master taskloop simd' | 'distribute' | 'target
|
|
/// enter data' | 'target exit data' | 'target parallel' | 'target
|
|
/// parallel for' | 'target update' | 'distribute parallel for' |
|
|
/// 'distribute paralle for simd' | 'distribute simd' | 'target parallel
|
|
/// for simd' | 'target simd' | 'teams distribute' | 'teams distribute
|
|
/// simd' | 'teams distribute parallel for simd' | 'teams distribute
|
|
/// parallel for' | 'target teams' | 'target teams distribute' | 'target
|
|
/// teams distribute parallel for' | 'target teams distribute parallel
|
|
/// for simd' | 'target teams distribute simd' | 'masked' {clause}
|
|
/// annot_pragma_openmp_end
|
|
///
|
|
StmtResult
|
|
Parser::ParseOpenMPDeclarativeOrExecutableDirective(ParsedStmtContext StmtCtx) {
|
|
assert(Tok.is(tok::annot_pragma_openmp) && "Not an OpenMP directive!");
|
|
ParsingOpenMPDirectiveRAII DirScope(*this);
|
|
ParenBraceBracketBalancer BalancerRAIIObj(*this);
|
|
SmallVector<OMPClause *, 5> Clauses;
|
|
SmallVector<llvm::PointerIntPair<OMPClause *, 1, bool>,
|
|
llvm::omp::Clause_enumSize + 1>
|
|
FirstClauses(llvm::omp::Clause_enumSize + 1);
|
|
unsigned ScopeFlags = Scope::FnScope | Scope::DeclScope |
|
|
Scope::CompoundStmtScope | Scope::OpenMPDirectiveScope;
|
|
SourceLocation Loc = ConsumeAnnotationToken(), EndLoc;
|
|
OpenMPDirectiveKind DKind = parseOpenMPDirectiveKind(*this);
|
|
OpenMPDirectiveKind CancelRegion = OMPD_unknown;
|
|
// Name of critical directive.
|
|
DeclarationNameInfo DirName;
|
|
StmtResult Directive = StmtError();
|
|
bool HasAssociatedStatement = true;
|
|
|
|
switch (DKind) {
|
|
case OMPD_threadprivate: {
|
|
// FIXME: Should this be permitted in C++?
|
|
if ((StmtCtx & ParsedStmtContext::AllowDeclarationsInC) ==
|
|
ParsedStmtContext()) {
|
|
Diag(Tok, diag::err_omp_immediate_directive)
|
|
<< getOpenMPDirectiveName(DKind) << 0;
|
|
}
|
|
ConsumeToken();
|
|
DeclDirectiveListParserHelper Helper(this, DKind);
|
|
if (!ParseOpenMPSimpleVarList(DKind, Helper,
|
|
/*AllowScopeSpecifier=*/false)) {
|
|
skipUntilPragmaOpenMPEnd(DKind);
|
|
DeclGroupPtrTy Res = Actions.ActOnOpenMPThreadprivateDirective(
|
|
Loc, Helper.getIdentifiers());
|
|
Directive = Actions.ActOnDeclStmt(Res, Loc, Tok.getLocation());
|
|
}
|
|
SkipUntil(tok::annot_pragma_openmp_end);
|
|
break;
|
|
}
|
|
case OMPD_allocate: {
|
|
// FIXME: Should this be permitted in C++?
|
|
if ((StmtCtx & ParsedStmtContext::AllowDeclarationsInC) ==
|
|
ParsedStmtContext()) {
|
|
Diag(Tok, diag::err_omp_immediate_directive)
|
|
<< getOpenMPDirectiveName(DKind) << 0;
|
|
}
|
|
ConsumeToken();
|
|
DeclDirectiveListParserHelper Helper(this, DKind);
|
|
if (!ParseOpenMPSimpleVarList(DKind, Helper,
|
|
/*AllowScopeSpecifier=*/false)) {
|
|
SmallVector<OMPClause *, 1> Clauses;
|
|
if (Tok.isNot(tok::annot_pragma_openmp_end)) {
|
|
SmallVector<llvm::PointerIntPair<OMPClause *, 1, bool>,
|
|
llvm::omp::Clause_enumSize + 1>
|
|
FirstClauses(llvm::omp::Clause_enumSize + 1);
|
|
while (Tok.isNot(tok::annot_pragma_openmp_end)) {
|
|
OpenMPClauseKind CKind =
|
|
Tok.isAnnotation() ? OMPC_unknown
|
|
: getOpenMPClauseKind(PP.getSpelling(Tok));
|
|
Actions.StartOpenMPClause(CKind);
|
|
OMPClause *Clause = ParseOpenMPClause(
|
|
OMPD_allocate, CKind, !FirstClauses[unsigned(CKind)].getInt());
|
|
SkipUntil(tok::comma, tok::identifier, tok::annot_pragma_openmp_end,
|
|
StopBeforeMatch);
|
|
FirstClauses[unsigned(CKind)].setInt(true);
|
|
if (Clause != nullptr)
|
|
Clauses.push_back(Clause);
|
|
if (Tok.is(tok::annot_pragma_openmp_end)) {
|
|
Actions.EndOpenMPClause();
|
|
break;
|
|
}
|
|
// Skip ',' if any.
|
|
if (Tok.is(tok::comma))
|
|
ConsumeToken();
|
|
Actions.EndOpenMPClause();
|
|
}
|
|
skipUntilPragmaOpenMPEnd(DKind);
|
|
}
|
|
DeclGroupPtrTy Res = Actions.ActOnOpenMPAllocateDirective(
|
|
Loc, Helper.getIdentifiers(), Clauses);
|
|
Directive = Actions.ActOnDeclStmt(Res, Loc, Tok.getLocation());
|
|
}
|
|
SkipUntil(tok::annot_pragma_openmp_end);
|
|
break;
|
|
}
|
|
case OMPD_declare_reduction:
|
|
ConsumeToken();
|
|
if (DeclGroupPtrTy Res =
|
|
ParseOpenMPDeclareReductionDirective(/*AS=*/AS_none)) {
|
|
skipUntilPragmaOpenMPEnd(OMPD_declare_reduction);
|
|
ConsumeAnyToken();
|
|
Directive = Actions.ActOnDeclStmt(Res, Loc, Tok.getLocation());
|
|
} else {
|
|
SkipUntil(tok::annot_pragma_openmp_end);
|
|
}
|
|
break;
|
|
case OMPD_declare_mapper: {
|
|
ConsumeToken();
|
|
if (DeclGroupPtrTy Res =
|
|
ParseOpenMPDeclareMapperDirective(/*AS=*/AS_none)) {
|
|
// Skip the last annot_pragma_openmp_end.
|
|
ConsumeAnnotationToken();
|
|
Directive = Actions.ActOnDeclStmt(Res, Loc, Tok.getLocation());
|
|
} else {
|
|
SkipUntil(tok::annot_pragma_openmp_end);
|
|
}
|
|
break;
|
|
}
|
|
case OMPD_flush:
|
|
case OMPD_depobj:
|
|
case OMPD_scan:
|
|
case OMPD_taskyield:
|
|
case OMPD_barrier:
|
|
case OMPD_taskwait:
|
|
case OMPD_cancellation_point:
|
|
case OMPD_cancel:
|
|
case OMPD_target_enter_data:
|
|
case OMPD_target_exit_data:
|
|
case OMPD_target_update:
|
|
case OMPD_interop:
|
|
if ((StmtCtx & ParsedStmtContext::AllowStandaloneOpenMPDirectives) ==
|
|
ParsedStmtContext()) {
|
|
Diag(Tok, diag::err_omp_immediate_directive)
|
|
<< getOpenMPDirectiveName(DKind) << 0;
|
|
}
|
|
HasAssociatedStatement = false;
|
|
// Fall through for further analysis.
|
|
LLVM_FALLTHROUGH;
|
|
case OMPD_parallel:
|
|
case OMPD_simd:
|
|
case OMPD_tile:
|
|
case OMPD_unroll:
|
|
case OMPD_for:
|
|
case OMPD_for_simd:
|
|
case OMPD_sections:
|
|
case OMPD_single:
|
|
case OMPD_section:
|
|
case OMPD_master:
|
|
case OMPD_critical:
|
|
case OMPD_parallel_for:
|
|
case OMPD_parallel_for_simd:
|
|
case OMPD_parallel_sections:
|
|
case OMPD_parallel_master:
|
|
case OMPD_task:
|
|
case OMPD_ordered:
|
|
case OMPD_atomic:
|
|
case OMPD_target:
|
|
case OMPD_teams:
|
|
case OMPD_taskgroup:
|
|
case OMPD_target_data:
|
|
case OMPD_target_parallel:
|
|
case OMPD_target_parallel_for:
|
|
case OMPD_taskloop:
|
|
case OMPD_taskloop_simd:
|
|
case OMPD_master_taskloop:
|
|
case OMPD_master_taskloop_simd:
|
|
case OMPD_parallel_master_taskloop:
|
|
case OMPD_parallel_master_taskloop_simd:
|
|
case OMPD_distribute:
|
|
case OMPD_distribute_parallel_for:
|
|
case OMPD_distribute_parallel_for_simd:
|
|
case OMPD_distribute_simd:
|
|
case OMPD_target_parallel_for_simd:
|
|
case OMPD_target_simd:
|
|
case OMPD_teams_distribute:
|
|
case OMPD_teams_distribute_simd:
|
|
case OMPD_teams_distribute_parallel_for_simd:
|
|
case OMPD_teams_distribute_parallel_for:
|
|
case OMPD_target_teams:
|
|
case OMPD_target_teams_distribute:
|
|
case OMPD_target_teams_distribute_parallel_for:
|
|
case OMPD_target_teams_distribute_parallel_for_simd:
|
|
case OMPD_target_teams_distribute_simd:
|
|
case OMPD_dispatch:
|
|
case OMPD_masked: {
|
|
// Special processing for flush and depobj clauses.
|
|
Token ImplicitTok;
|
|
bool ImplicitClauseAllowed = false;
|
|
if (DKind == OMPD_flush || DKind == OMPD_depobj) {
|
|
ImplicitTok = Tok;
|
|
ImplicitClauseAllowed = true;
|
|
}
|
|
ConsumeToken();
|
|
// Parse directive name of the 'critical' directive if any.
|
|
if (DKind == OMPD_critical) {
|
|
BalancedDelimiterTracker T(*this, tok::l_paren,
|
|
tok::annot_pragma_openmp_end);
|
|
if (!T.consumeOpen()) {
|
|
if (Tok.isAnyIdentifier()) {
|
|
DirName =
|
|
DeclarationNameInfo(Tok.getIdentifierInfo(), Tok.getLocation());
|
|
ConsumeAnyToken();
|
|
} else {
|
|
Diag(Tok, diag::err_omp_expected_identifier_for_critical);
|
|
}
|
|
T.consumeClose();
|
|
}
|
|
} else if (DKind == OMPD_cancellation_point || DKind == OMPD_cancel) {
|
|
CancelRegion = parseOpenMPDirectiveKind(*this);
|
|
if (Tok.isNot(tok::annot_pragma_openmp_end))
|
|
ConsumeToken();
|
|
}
|
|
|
|
if (isOpenMPLoopDirective(DKind))
|
|
ScopeFlags |= Scope::OpenMPLoopDirectiveScope;
|
|
if (isOpenMPSimdDirective(DKind))
|
|
ScopeFlags |= Scope::OpenMPSimdDirectiveScope;
|
|
ParseScope OMPDirectiveScope(this, ScopeFlags);
|
|
Actions.StartOpenMPDSABlock(DKind, DirName, Actions.getCurScope(), Loc);
|
|
|
|
while (Tok.isNot(tok::annot_pragma_openmp_end)) {
|
|
bool HasImplicitClause = false;
|
|
if (ImplicitClauseAllowed && Tok.is(tok::l_paren)) {
|
|
HasImplicitClause = true;
|
|
// Push copy of the current token back to stream to properly parse
|
|
// pseudo-clause OMPFlushClause or OMPDepobjClause.
|
|
PP.EnterToken(Tok, /*IsReinject*/ true);
|
|
PP.EnterToken(ImplicitTok, /*IsReinject*/ true);
|
|
ConsumeAnyToken();
|
|
}
|
|
OpenMPClauseKind CKind = Tok.isAnnotation()
|
|
? OMPC_unknown
|
|
: getOpenMPClauseKind(PP.getSpelling(Tok));
|
|
if (HasImplicitClause) {
|
|
assert(CKind == OMPC_unknown && "Must be unknown implicit clause.");
|
|
if (DKind == OMPD_flush) {
|
|
CKind = OMPC_flush;
|
|
} else {
|
|
assert(DKind == OMPD_depobj &&
|
|
"Expected flush or depobj directives.");
|
|
CKind = OMPC_depobj;
|
|
}
|
|
}
|
|
// No more implicit clauses allowed.
|
|
ImplicitClauseAllowed = false;
|
|
Actions.StartOpenMPClause(CKind);
|
|
HasImplicitClause = false;
|
|
OMPClause *Clause = ParseOpenMPClause(
|
|
DKind, CKind, !FirstClauses[unsigned(CKind)].getInt());
|
|
FirstClauses[unsigned(CKind)].setInt(true);
|
|
if (Clause) {
|
|
FirstClauses[unsigned(CKind)].setPointer(Clause);
|
|
Clauses.push_back(Clause);
|
|
}
|
|
|
|
// Skip ',' if any.
|
|
if (Tok.is(tok::comma))
|
|
ConsumeToken();
|
|
Actions.EndOpenMPClause();
|
|
}
|
|
// End location of the directive.
|
|
EndLoc = Tok.getLocation();
|
|
// Consume final annot_pragma_openmp_end.
|
|
ConsumeAnnotationToken();
|
|
|
|
// OpenMP [2.13.8, ordered Construct, Syntax]
|
|
// If the depend clause is specified, the ordered construct is a stand-alone
|
|
// directive.
|
|
if (DKind == OMPD_ordered && FirstClauses[unsigned(OMPC_depend)].getInt()) {
|
|
if ((StmtCtx & ParsedStmtContext::AllowStandaloneOpenMPDirectives) ==
|
|
ParsedStmtContext()) {
|
|
Diag(Loc, diag::err_omp_immediate_directive)
|
|
<< getOpenMPDirectiveName(DKind) << 1
|
|
<< getOpenMPClauseName(OMPC_depend);
|
|
}
|
|
HasAssociatedStatement = false;
|
|
}
|
|
|
|
if (DKind == OMPD_tile && !FirstClauses[unsigned(OMPC_sizes)].getInt()) {
|
|
Diag(Loc, diag::err_omp_required_clause)
|
|
<< getOpenMPDirectiveName(OMPD_tile) << "sizes";
|
|
}
|
|
|
|
StmtResult AssociatedStmt;
|
|
if (HasAssociatedStatement) {
|
|
// The body is a block scope like in Lambdas and Blocks.
|
|
Actions.ActOnOpenMPRegionStart(DKind, getCurScope());
|
|
// FIXME: We create a bogus CompoundStmt scope to hold the contents of
|
|
// the captured region. Code elsewhere assumes that any FunctionScopeInfo
|
|
// should have at least one compound statement scope within it.
|
|
ParsingOpenMPDirectiveRAII NormalScope(*this, /*Value=*/false);
|
|
{
|
|
Sema::CompoundScopeRAII Scope(Actions);
|
|
AssociatedStmt = ParseStatement();
|
|
|
|
if (AssociatedStmt.isUsable() && isOpenMPLoopDirective(DKind) &&
|
|
getLangOpts().OpenMPIRBuilder)
|
|
AssociatedStmt =
|
|
Actions.ActOnOpenMPCanonicalLoop(AssociatedStmt.get());
|
|
}
|
|
AssociatedStmt = Actions.ActOnOpenMPRegionEnd(AssociatedStmt, Clauses);
|
|
} else if (DKind == OMPD_target_update || DKind == OMPD_target_enter_data ||
|
|
DKind == OMPD_target_exit_data) {
|
|
Actions.ActOnOpenMPRegionStart(DKind, getCurScope());
|
|
AssociatedStmt = (Sema::CompoundScopeRAII(Actions),
|
|
Actions.ActOnCompoundStmt(Loc, Loc, llvm::None,
|
|
/*isStmtExpr=*/false));
|
|
AssociatedStmt = Actions.ActOnOpenMPRegionEnd(AssociatedStmt, Clauses);
|
|
}
|
|
Directive = Actions.ActOnOpenMPExecutableDirective(
|
|
DKind, DirName, CancelRegion, Clauses, AssociatedStmt.get(), Loc,
|
|
EndLoc);
|
|
|
|
// Exit scope.
|
|
Actions.EndOpenMPDSABlock(Directive.get());
|
|
OMPDirectiveScope.Exit();
|
|
break;
|
|
}
|
|
case OMPD_declare_simd:
|
|
case OMPD_declare_target:
|
|
case OMPD_begin_declare_target:
|
|
case OMPD_end_declare_target:
|
|
case OMPD_requires:
|
|
case OMPD_begin_declare_variant:
|
|
case OMPD_end_declare_variant:
|
|
case OMPD_declare_variant:
|
|
Diag(Tok, diag::err_omp_unexpected_directive)
|
|
<< 1 << getOpenMPDirectiveName(DKind);
|
|
SkipUntil(tok::annot_pragma_openmp_end);
|
|
break;
|
|
case OMPD_unknown:
|
|
default:
|
|
Diag(Tok, diag::err_omp_unknown_directive);
|
|
SkipUntil(tok::annot_pragma_openmp_end);
|
|
break;
|
|
}
|
|
return Directive;
|
|
}
|
|
|
|
// Parses simple list:
|
|
// simple-variable-list:
|
|
// '(' id-expression {, id-expression} ')'
|
|
//
|
|
bool Parser::ParseOpenMPSimpleVarList(
|
|
OpenMPDirectiveKind Kind,
|
|
const llvm::function_ref<void(CXXScopeSpec &, DeclarationNameInfo)>
|
|
&Callback,
|
|
bool AllowScopeSpecifier) {
|
|
// Parse '('.
|
|
BalancedDelimiterTracker T(*this, tok::l_paren, tok::annot_pragma_openmp_end);
|
|
if (T.expectAndConsume(diag::err_expected_lparen_after,
|
|
getOpenMPDirectiveName(Kind).data()))
|
|
return true;
|
|
bool IsCorrect = true;
|
|
bool NoIdentIsFound = true;
|
|
|
|
// Read tokens while ')' or annot_pragma_openmp_end is not found.
|
|
while (Tok.isNot(tok::r_paren) && Tok.isNot(tok::annot_pragma_openmp_end)) {
|
|
CXXScopeSpec SS;
|
|
UnqualifiedId Name;
|
|
// Read var name.
|
|
Token PrevTok = Tok;
|
|
NoIdentIsFound = false;
|
|
|
|
if (AllowScopeSpecifier && getLangOpts().CPlusPlus &&
|
|
ParseOptionalCXXScopeSpecifier(SS, /*ObjectType=*/nullptr,
|
|
/*ObjectHadErrors=*/false, false)) {
|
|
IsCorrect = false;
|
|
SkipUntil(tok::comma, tok::r_paren, tok::annot_pragma_openmp_end,
|
|
StopBeforeMatch);
|
|
} else if (ParseUnqualifiedId(SS, /*ObjectType=*/nullptr,
|
|
/*ObjectHadErrors=*/false, false, false,
|
|
false, false, nullptr, Name)) {
|
|
IsCorrect = false;
|
|
SkipUntil(tok::comma, tok::r_paren, tok::annot_pragma_openmp_end,
|
|
StopBeforeMatch);
|
|
} else if (Tok.isNot(tok::comma) && Tok.isNot(tok::r_paren) &&
|
|
Tok.isNot(tok::annot_pragma_openmp_end)) {
|
|
IsCorrect = false;
|
|
SkipUntil(tok::comma, tok::r_paren, tok::annot_pragma_openmp_end,
|
|
StopBeforeMatch);
|
|
Diag(PrevTok.getLocation(), diag::err_expected)
|
|
<< tok::identifier
|
|
<< SourceRange(PrevTok.getLocation(), PrevTokLocation);
|
|
} else {
|
|
Callback(SS, Actions.GetNameFromUnqualifiedId(Name));
|
|
}
|
|
// Consume ','.
|
|
if (Tok.is(tok::comma)) {
|
|
ConsumeToken();
|
|
}
|
|
}
|
|
|
|
if (NoIdentIsFound) {
|
|
Diag(Tok, diag::err_expected) << tok::identifier;
|
|
IsCorrect = false;
|
|
}
|
|
|
|
// Parse ')'.
|
|
IsCorrect = !T.consumeClose() && IsCorrect;
|
|
|
|
return !IsCorrect;
|
|
}
|
|
|
|
OMPClause *Parser::ParseOpenMPSizesClause() {
|
|
SourceLocation ClauseNameLoc = ConsumeToken();
|
|
SmallVector<Expr *, 4> ValExprs;
|
|
|
|
BalancedDelimiterTracker T(*this, tok::l_paren, tok::annot_pragma_openmp_end);
|
|
if (T.consumeOpen()) {
|
|
Diag(Tok, diag::err_expected) << tok::l_paren;
|
|
return nullptr;
|
|
}
|
|
|
|
while (true) {
|
|
ExprResult Val = ParseConstantExpression();
|
|
if (!Val.isUsable()) {
|
|
T.skipToEnd();
|
|
return nullptr;
|
|
}
|
|
|
|
ValExprs.push_back(Val.get());
|
|
|
|
if (Tok.is(tok::r_paren) || Tok.is(tok::annot_pragma_openmp_end))
|
|
break;
|
|
|
|
ExpectAndConsume(tok::comma);
|
|
}
|
|
|
|
T.consumeClose();
|
|
|
|
return Actions.ActOnOpenMPSizesClause(
|
|
ValExprs, ClauseNameLoc, T.getOpenLocation(), T.getCloseLocation());
|
|
}
|
|
|
|
OMPClause *Parser::ParseOpenMPUsesAllocatorClause(OpenMPDirectiveKind DKind) {
|
|
SourceLocation Loc = Tok.getLocation();
|
|
ConsumeAnyToken();
|
|
|
|
// Parse '('.
|
|
BalancedDelimiterTracker T(*this, tok::l_paren, tok::annot_pragma_openmp_end);
|
|
if (T.expectAndConsume(diag::err_expected_lparen_after, "uses_allocator"))
|
|
return nullptr;
|
|
SmallVector<Sema::UsesAllocatorsData, 4> Data;
|
|
do {
|
|
ExprResult Allocator = ParseCXXIdExpression();
|
|
if (Allocator.isInvalid()) {
|
|
SkipUntil(tok::comma, tok::r_paren, tok::annot_pragma_openmp_end,
|
|
StopBeforeMatch);
|
|
break;
|
|
}
|
|
Sema::UsesAllocatorsData &D = Data.emplace_back();
|
|
D.Allocator = Allocator.get();
|
|
if (Tok.is(tok::l_paren)) {
|
|
BalancedDelimiterTracker T(*this, tok::l_paren,
|
|
tok::annot_pragma_openmp_end);
|
|
T.consumeOpen();
|
|
ExprResult AllocatorTraits = ParseCXXIdExpression();
|
|
T.consumeClose();
|
|
if (AllocatorTraits.isInvalid()) {
|
|
SkipUntil(tok::comma, tok::r_paren, tok::annot_pragma_openmp_end,
|
|
StopBeforeMatch);
|
|
break;
|
|
}
|
|
D.AllocatorTraits = AllocatorTraits.get();
|
|
D.LParenLoc = T.getOpenLocation();
|
|
D.RParenLoc = T.getCloseLocation();
|
|
}
|
|
if (Tok.isNot(tok::comma) && Tok.isNot(tok::r_paren))
|
|
Diag(Tok, diag::err_omp_expected_punc) << "uses_allocators" << 0;
|
|
// Parse ','
|
|
if (Tok.is(tok::comma))
|
|
ConsumeAnyToken();
|
|
} while (Tok.isNot(tok::r_paren) && Tok.isNot(tok::annot_pragma_openmp_end));
|
|
T.consumeClose();
|
|
return Actions.ActOnOpenMPUsesAllocatorClause(Loc, T.getOpenLocation(),
|
|
T.getCloseLocation(), Data);
|
|
}
|
|
|
|
/// Parsing of OpenMP clauses.
|
|
///
|
|
/// clause:
|
|
/// if-clause | final-clause | num_threads-clause | safelen-clause |
|
|
/// default-clause | private-clause | firstprivate-clause | shared-clause
|
|
/// | linear-clause | aligned-clause | collapse-clause |
|
|
/// lastprivate-clause | reduction-clause | proc_bind-clause |
|
|
/// schedule-clause | copyin-clause | copyprivate-clause | untied-clause |
|
|
/// mergeable-clause | flush-clause | read-clause | write-clause |
|
|
/// update-clause | capture-clause | seq_cst-clause | device-clause |
|
|
/// simdlen-clause | threads-clause | simd-clause | num_teams-clause |
|
|
/// thread_limit-clause | priority-clause | grainsize-clause |
|
|
/// nogroup-clause | num_tasks-clause | hint-clause | to-clause |
|
|
/// from-clause | is_device_ptr-clause | task_reduction-clause |
|
|
/// in_reduction-clause | allocator-clause | allocate-clause |
|
|
/// acq_rel-clause | acquire-clause | release-clause | relaxed-clause |
|
|
/// depobj-clause | destroy-clause | detach-clause | inclusive-clause |
|
|
/// exclusive-clause | uses_allocators-clause | use_device_addr-clause
|
|
///
|
|
OMPClause *Parser::ParseOpenMPClause(OpenMPDirectiveKind DKind,
|
|
OpenMPClauseKind CKind, bool FirstClause) {
|
|
OMPClauseKind = CKind;
|
|
OMPClause *Clause = nullptr;
|
|
bool ErrorFound = false;
|
|
bool WrongDirective = false;
|
|
// Check if clause is allowed for the given directive.
|
|
if (CKind != OMPC_unknown &&
|
|
!isAllowedClauseForDirective(DKind, CKind, getLangOpts().OpenMP)) {
|
|
Diag(Tok, diag::err_omp_unexpected_clause)
|
|
<< getOpenMPClauseName(CKind) << getOpenMPDirectiveName(DKind);
|
|
ErrorFound = true;
|
|
WrongDirective = true;
|
|
}
|
|
|
|
switch (CKind) {
|
|
case OMPC_final:
|
|
case OMPC_num_threads:
|
|
case OMPC_safelen:
|
|
case OMPC_simdlen:
|
|
case OMPC_collapse:
|
|
case OMPC_ordered:
|
|
case OMPC_num_teams:
|
|
case OMPC_thread_limit:
|
|
case OMPC_priority:
|
|
case OMPC_grainsize:
|
|
case OMPC_num_tasks:
|
|
case OMPC_hint:
|
|
case OMPC_allocator:
|
|
case OMPC_depobj:
|
|
case OMPC_detach:
|
|
case OMPC_novariants:
|
|
case OMPC_nocontext:
|
|
case OMPC_filter:
|
|
case OMPC_partial:
|
|
// OpenMP [2.5, Restrictions]
|
|
// At most one num_threads clause can appear on the directive.
|
|
// OpenMP [2.8.1, simd construct, Restrictions]
|
|
// Only one safelen clause can appear on a simd directive.
|
|
// Only one simdlen clause can appear on a simd directive.
|
|
// Only one collapse clause can appear on a simd directive.
|
|
// OpenMP [2.11.1, task Construct, Restrictions]
|
|
// At most one if clause can appear on the directive.
|
|
// At most one final clause can appear on the directive.
|
|
// OpenMP [teams Construct, Restrictions]
|
|
// At most one num_teams clause can appear on the directive.
|
|
// At most one thread_limit clause can appear on the directive.
|
|
// OpenMP [2.9.1, task Construct, Restrictions]
|
|
// At most one priority clause can appear on the directive.
|
|
// OpenMP [2.9.2, taskloop Construct, Restrictions]
|
|
// At most one grainsize clause can appear on the directive.
|
|
// OpenMP [2.9.2, taskloop Construct, Restrictions]
|
|
// At most one num_tasks clause can appear on the directive.
|
|
// OpenMP [2.11.3, allocate Directive, Restrictions]
|
|
// At most one allocator clause can appear on the directive.
|
|
// OpenMP 5.0, 2.10.1 task Construct, Restrictions.
|
|
// At most one detach clause can appear on the directive.
|
|
// OpenMP 5.1, 2.3.6 dispatch Construct, Restrictions.
|
|
// At most one novariants clause can appear on a dispatch directive.
|
|
// At most one nocontext clause can appear on a dispatch directive.
|
|
if (!FirstClause) {
|
|
Diag(Tok, diag::err_omp_more_one_clause)
|
|
<< getOpenMPDirectiveName(DKind) << getOpenMPClauseName(CKind) << 0;
|
|
ErrorFound = true;
|
|
}
|
|
|
|
if ((CKind == OMPC_ordered || CKind == OMPC_partial) &&
|
|
PP.LookAhead(/*N=*/0).isNot(tok::l_paren))
|
|
Clause = ParseOpenMPClause(CKind, WrongDirective);
|
|
else
|
|
Clause = ParseOpenMPSingleExprClause(CKind, WrongDirective);
|
|
break;
|
|
case OMPC_default:
|
|
case OMPC_proc_bind:
|
|
case OMPC_atomic_default_mem_order:
|
|
case OMPC_order:
|
|
// OpenMP [2.14.3.1, Restrictions]
|
|
// Only a single default clause may be specified on a parallel, task or
|
|
// teams directive.
|
|
// OpenMP [2.5, parallel Construct, Restrictions]
|
|
// At most one proc_bind clause can appear on the directive.
|
|
// OpenMP [5.0, Requires directive, Restrictions]
|
|
// At most one atomic_default_mem_order clause can appear
|
|
// on the directive
|
|
if (!FirstClause && CKind != OMPC_order) {
|
|
Diag(Tok, diag::err_omp_more_one_clause)
|
|
<< getOpenMPDirectiveName(DKind) << getOpenMPClauseName(CKind) << 0;
|
|
ErrorFound = true;
|
|
}
|
|
|
|
Clause = ParseOpenMPSimpleClause(CKind, WrongDirective);
|
|
break;
|
|
case OMPC_device:
|
|
case OMPC_schedule:
|
|
case OMPC_dist_schedule:
|
|
case OMPC_defaultmap:
|
|
// OpenMP [2.7.1, Restrictions, p. 3]
|
|
// Only one schedule clause can appear on a loop directive.
|
|
// OpenMP 4.5 [2.10.4, Restrictions, p. 106]
|
|
// At most one defaultmap clause can appear on the directive.
|
|
// OpenMP 5.0 [2.12.5, target construct, Restrictions]
|
|
// At most one device clause can appear on the directive.
|
|
if ((getLangOpts().OpenMP < 50 || CKind != OMPC_defaultmap) &&
|
|
!FirstClause) {
|
|
Diag(Tok, diag::err_omp_more_one_clause)
|
|
<< getOpenMPDirectiveName(DKind) << getOpenMPClauseName(CKind) << 0;
|
|
ErrorFound = true;
|
|
}
|
|
LLVM_FALLTHROUGH;
|
|
case OMPC_if:
|
|
Clause = ParseOpenMPSingleExprWithArgClause(DKind, CKind, WrongDirective);
|
|
break;
|
|
case OMPC_nowait:
|
|
case OMPC_untied:
|
|
case OMPC_mergeable:
|
|
case OMPC_read:
|
|
case OMPC_write:
|
|
case OMPC_capture:
|
|
case OMPC_seq_cst:
|
|
case OMPC_acq_rel:
|
|
case OMPC_acquire:
|
|
case OMPC_release:
|
|
case OMPC_relaxed:
|
|
case OMPC_threads:
|
|
case OMPC_simd:
|
|
case OMPC_nogroup:
|
|
case OMPC_unified_address:
|
|
case OMPC_unified_shared_memory:
|
|
case OMPC_reverse_offload:
|
|
case OMPC_dynamic_allocators:
|
|
case OMPC_full:
|
|
// OpenMP [2.7.1, Restrictions, p. 9]
|
|
// Only one ordered clause can appear on a loop directive.
|
|
// OpenMP [2.7.1, Restrictions, C/C++, p. 4]
|
|
// Only one nowait clause can appear on a for directive.
|
|
// OpenMP [5.0, Requires directive, Restrictions]
|
|
// Each of the requires clauses can appear at most once on the directive.
|
|
if (!FirstClause) {
|
|
Diag(Tok, diag::err_omp_more_one_clause)
|
|
<< getOpenMPDirectiveName(DKind) << getOpenMPClauseName(CKind) << 0;
|
|
ErrorFound = true;
|
|
}
|
|
|
|
Clause = ParseOpenMPClause(CKind, WrongDirective);
|
|
break;
|
|
case OMPC_update:
|
|
if (!FirstClause) {
|
|
Diag(Tok, diag::err_omp_more_one_clause)
|
|
<< getOpenMPDirectiveName(DKind) << getOpenMPClauseName(CKind) << 0;
|
|
ErrorFound = true;
|
|
}
|
|
|
|
Clause = (DKind == OMPD_depobj)
|
|
? ParseOpenMPSimpleClause(CKind, WrongDirective)
|
|
: ParseOpenMPClause(CKind, WrongDirective);
|
|
break;
|
|
case OMPC_private:
|
|
case OMPC_firstprivate:
|
|
case OMPC_lastprivate:
|
|
case OMPC_shared:
|
|
case OMPC_reduction:
|
|
case OMPC_task_reduction:
|
|
case OMPC_in_reduction:
|
|
case OMPC_linear:
|
|
case OMPC_aligned:
|
|
case OMPC_copyin:
|
|
case OMPC_copyprivate:
|
|
case OMPC_flush:
|
|
case OMPC_depend:
|
|
case OMPC_map:
|
|
case OMPC_to:
|
|
case OMPC_from:
|
|
case OMPC_use_device_ptr:
|
|
case OMPC_use_device_addr:
|
|
case OMPC_is_device_ptr:
|
|
case OMPC_allocate:
|
|
case OMPC_nontemporal:
|
|
case OMPC_inclusive:
|
|
case OMPC_exclusive:
|
|
case OMPC_affinity:
|
|
Clause = ParseOpenMPVarListClause(DKind, CKind, WrongDirective);
|
|
break;
|
|
case OMPC_sizes:
|
|
if (!FirstClause) {
|
|
Diag(Tok, diag::err_omp_more_one_clause)
|
|
<< getOpenMPDirectiveName(DKind) << getOpenMPClauseName(CKind) << 0;
|
|
ErrorFound = true;
|
|
}
|
|
|
|
Clause = ParseOpenMPSizesClause();
|
|
break;
|
|
case OMPC_uses_allocators:
|
|
Clause = ParseOpenMPUsesAllocatorClause(DKind);
|
|
break;
|
|
case OMPC_destroy:
|
|
if (DKind != OMPD_interop) {
|
|
if (!FirstClause) {
|
|
Diag(Tok, diag::err_omp_more_one_clause)
|
|
<< getOpenMPDirectiveName(DKind) << getOpenMPClauseName(CKind) << 0;
|
|
ErrorFound = true;
|
|
}
|
|
Clause = ParseOpenMPClause(CKind, WrongDirective);
|
|
break;
|
|
}
|
|
LLVM_FALLTHROUGH;
|
|
case OMPC_init:
|
|
case OMPC_use:
|
|
Clause = ParseOpenMPInteropClause(CKind, WrongDirective);
|
|
break;
|
|
case OMPC_device_type:
|
|
case OMPC_unknown:
|
|
skipUntilPragmaOpenMPEnd(DKind);
|
|
break;
|
|
case OMPC_threadprivate:
|
|
case OMPC_uniform:
|
|
case OMPC_match:
|
|
if (!WrongDirective)
|
|
Diag(Tok, diag::err_omp_unexpected_clause)
|
|
<< getOpenMPClauseName(CKind) << getOpenMPDirectiveName(DKind);
|
|
SkipUntil(tok::comma, tok::annot_pragma_openmp_end, StopBeforeMatch);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return ErrorFound ? nullptr : Clause;
|
|
}
|
|
|
|
/// Parses simple expression in parens for single-expression clauses of OpenMP
|
|
/// constructs.
|
|
/// \param RLoc Returned location of right paren.
|
|
ExprResult Parser::ParseOpenMPParensExpr(StringRef ClauseName,
|
|
SourceLocation &RLoc,
|
|
bool IsAddressOfOperand) {
|
|
BalancedDelimiterTracker T(*this, tok::l_paren, tok::annot_pragma_openmp_end);
|
|
if (T.expectAndConsume(diag::err_expected_lparen_after, ClauseName.data()))
|
|
return ExprError();
|
|
|
|
SourceLocation ELoc = Tok.getLocation();
|
|
ExprResult LHS(
|
|
ParseCastExpression(AnyCastExpr, IsAddressOfOperand, NotTypeCast));
|
|
ExprResult Val(ParseRHSOfBinaryExpression(LHS, prec::Conditional));
|
|
Val = Actions.ActOnFinishFullExpr(Val.get(), ELoc, /*DiscardedValue*/ false);
|
|
|
|
// Parse ')'.
|
|
RLoc = Tok.getLocation();
|
|
if (!T.consumeClose())
|
|
RLoc = T.getCloseLocation();
|
|
|
|
return Val;
|
|
}
|
|
|
|
/// Parsing of OpenMP clauses with single expressions like 'final',
|
|
/// 'collapse', 'safelen', 'num_threads', 'simdlen', 'num_teams',
|
|
/// 'thread_limit', 'simdlen', 'priority', 'grainsize', 'num_tasks', 'hint' or
|
|
/// 'detach'.
|
|
///
|
|
/// final-clause:
|
|
/// 'final' '(' expression ')'
|
|
///
|
|
/// num_threads-clause:
|
|
/// 'num_threads' '(' expression ')'
|
|
///
|
|
/// safelen-clause:
|
|
/// 'safelen' '(' expression ')'
|
|
///
|
|
/// simdlen-clause:
|
|
/// 'simdlen' '(' expression ')'
|
|
///
|
|
/// collapse-clause:
|
|
/// 'collapse' '(' expression ')'
|
|
///
|
|
/// priority-clause:
|
|
/// 'priority' '(' expression ')'
|
|
///
|
|
/// grainsize-clause:
|
|
/// 'grainsize' '(' expression ')'
|
|
///
|
|
/// num_tasks-clause:
|
|
/// 'num_tasks' '(' expression ')'
|
|
///
|
|
/// hint-clause:
|
|
/// 'hint' '(' expression ')'
|
|
///
|
|
/// allocator-clause:
|
|
/// 'allocator' '(' expression ')'
|
|
///
|
|
/// detach-clause:
|
|
/// 'detach' '(' event-handler-expression ')'
|
|
///
|
|
OMPClause *Parser::ParseOpenMPSingleExprClause(OpenMPClauseKind Kind,
|
|
bool ParseOnly) {
|
|
SourceLocation Loc = ConsumeToken();
|
|
SourceLocation LLoc = Tok.getLocation();
|
|
SourceLocation RLoc;
|
|
|
|
ExprResult Val = ParseOpenMPParensExpr(getOpenMPClauseName(Kind), RLoc);
|
|
|
|
if (Val.isInvalid())
|
|
return nullptr;
|
|
|
|
if (ParseOnly)
|
|
return nullptr;
|
|
return Actions.ActOnOpenMPSingleExprClause(Kind, Val.get(), Loc, LLoc, RLoc);
|
|
}
|
|
|
|
/// Parsing of OpenMP clauses that use an interop-var.
|
|
///
|
|
/// init-clause:
|
|
/// init([interop-modifier, ]interop-type[[, interop-type] ... ]:interop-var)
|
|
///
|
|
/// destroy-clause:
|
|
/// destroy(interop-var)
|
|
///
|
|
/// use-clause:
|
|
/// use(interop-var)
|
|
///
|
|
/// interop-modifier:
|
|
/// prefer_type(preference-list)
|
|
///
|
|
/// preference-list:
|
|
/// foreign-runtime-id [, foreign-runtime-id]...
|
|
///
|
|
/// foreign-runtime-id:
|
|
/// <string-literal> | <constant-integral-expression>
|
|
///
|
|
/// interop-type:
|
|
/// target | targetsync
|
|
///
|
|
OMPClause *Parser::ParseOpenMPInteropClause(OpenMPClauseKind Kind,
|
|
bool ParseOnly) {
|
|
SourceLocation Loc = ConsumeToken();
|
|
// Parse '('.
|
|
BalancedDelimiterTracker T(*this, tok::l_paren, tok::annot_pragma_openmp_end);
|
|
if (T.expectAndConsume(diag::err_expected_lparen_after,
|
|
getOpenMPClauseName(Kind).data()))
|
|
return nullptr;
|
|
|
|
bool IsTarget = false;
|
|
bool IsTargetSync = false;
|
|
SmallVector<Expr *, 4> Prefs;
|
|
|
|
if (Kind == OMPC_init) {
|
|
|
|
// Parse optional interop-modifier.
|
|
if (Tok.is(tok::identifier) && PP.getSpelling(Tok) == "prefer_type") {
|
|
ConsumeToken();
|
|
BalancedDelimiterTracker PT(*this, tok::l_paren,
|
|
tok::annot_pragma_openmp_end);
|
|
if (PT.expectAndConsume(diag::err_expected_lparen_after, "prefer_type"))
|
|
return nullptr;
|
|
|
|
while (Tok.isNot(tok::r_paren)) {
|
|
SourceLocation Loc = Tok.getLocation();
|
|
ExprResult LHS = ParseCastExpression(AnyCastExpr);
|
|
ExprResult PTExpr = Actions.CorrectDelayedTyposInExpr(
|
|
ParseRHSOfBinaryExpression(LHS, prec::Conditional));
|
|
PTExpr = Actions.ActOnFinishFullExpr(PTExpr.get(), Loc,
|
|
/*DiscardedValue=*/false);
|
|
if (PTExpr.isUsable())
|
|
Prefs.push_back(PTExpr.get());
|
|
else
|
|
SkipUntil(tok::comma, tok::r_paren, tok::annot_pragma_openmp_end,
|
|
StopBeforeMatch);
|
|
|
|
if (Tok.is(tok::comma))
|
|
ConsumeToken();
|
|
}
|
|
PT.consumeClose();
|
|
}
|
|
|
|
if (!Prefs.empty()) {
|
|
if (Tok.is(tok::comma))
|
|
ConsumeToken();
|
|
else
|
|
Diag(Tok, diag::err_omp_expected_punc_after_interop_mod);
|
|
}
|
|
|
|
// Parse the interop-types.
|
|
bool HasError = false;
|
|
while (Tok.is(tok::identifier)) {
|
|
if (PP.getSpelling(Tok) == "target") {
|
|
// OpenMP 5.1 [2.15.1, interop Construct, Restrictions]
|
|
// Each interop-type may be specified on an action-clause at most
|
|
// once.
|
|
if (IsTarget)
|
|
Diag(Tok, diag::warn_omp_more_one_interop_type) << "target";
|
|
IsTarget = true;
|
|
} else if (PP.getSpelling(Tok) == "targetsync") {
|
|
if (IsTargetSync)
|
|
Diag(Tok, diag::warn_omp_more_one_interop_type) << "targetsync";
|
|
IsTargetSync = true;
|
|
} else {
|
|
HasError = true;
|
|
Diag(Tok, diag::err_omp_expected_interop_type);
|
|
}
|
|
ConsumeToken();
|
|
|
|
if (!Tok.is(tok::comma))
|
|
break;
|
|
ConsumeToken();
|
|
}
|
|
if (!HasError && !IsTarget && !IsTargetSync)
|
|
Diag(Tok, diag::err_omp_expected_interop_type);
|
|
|
|
if (Tok.is(tok::colon))
|
|
ConsumeToken();
|
|
else if (IsTarget || IsTargetSync)
|
|
Diag(Tok, diag::warn_pragma_expected_colon) << "interop types";
|
|
}
|
|
|
|
// Parse the variable.
|
|
SourceLocation VarLoc = Tok.getLocation();
|
|
ExprResult InteropVarExpr =
|
|
Actions.CorrectDelayedTyposInExpr(ParseAssignmentExpression());
|
|
if (!InteropVarExpr.isUsable()) {
|
|
SkipUntil(tok::comma, tok::r_paren, tok::annot_pragma_openmp_end,
|
|
StopBeforeMatch);
|
|
}
|
|
|
|
// Parse ')'.
|
|
SourceLocation RLoc = Tok.getLocation();
|
|
if (!T.consumeClose())
|
|
RLoc = T.getCloseLocation();
|
|
|
|
if (ParseOnly || !InteropVarExpr.isUsable() ||
|
|
(Kind == OMPC_init && !IsTarget && !IsTargetSync))
|
|
return nullptr;
|
|
|
|
if (Kind == OMPC_init)
|
|
return Actions.ActOnOpenMPInitClause(InteropVarExpr.get(), Prefs, IsTarget,
|
|
IsTargetSync, Loc, T.getOpenLocation(),
|
|
VarLoc, RLoc);
|
|
if (Kind == OMPC_use)
|
|
return Actions.ActOnOpenMPUseClause(InteropVarExpr.get(), Loc,
|
|
T.getOpenLocation(), VarLoc, RLoc);
|
|
|
|
if (Kind == OMPC_destroy)
|
|
return Actions.ActOnOpenMPDestroyClause(InteropVarExpr.get(), Loc,
|
|
T.getOpenLocation(), VarLoc, RLoc);
|
|
|
|
llvm_unreachable("Unexpected interop variable clause.");
|
|
}
|
|
|
|
/// Parsing of simple OpenMP clauses like 'default' or 'proc_bind'.
|
|
///
|
|
/// default-clause:
|
|
/// 'default' '(' 'none' | 'shared' | 'firstprivate' ')'
|
|
///
|
|
/// proc_bind-clause:
|
|
/// 'proc_bind' '(' 'master' | 'close' | 'spread' ')'
|
|
///
|
|
/// update-clause:
|
|
/// 'update' '(' 'in' | 'out' | 'inout' | 'mutexinoutset' ')'
|
|
///
|
|
OMPClause *Parser::ParseOpenMPSimpleClause(OpenMPClauseKind Kind,
|
|
bool ParseOnly) {
|
|
llvm::Optional<SimpleClauseData> Val = parseOpenMPSimpleClause(*this, Kind);
|
|
if (!Val || ParseOnly)
|
|
return nullptr;
|
|
if (getLangOpts().OpenMP < 51 && Kind == OMPC_default &&
|
|
static_cast<DefaultKind>(Val.getValue().Type) ==
|
|
OMP_DEFAULT_firstprivate) {
|
|
Diag(Val.getValue().LOpen, diag::err_omp_invalid_dsa)
|
|
<< getOpenMPClauseName(OMPC_firstprivate)
|
|
<< getOpenMPClauseName(OMPC_default) << "5.1";
|
|
return nullptr;
|
|
}
|
|
return Actions.ActOnOpenMPSimpleClause(
|
|
Kind, Val.getValue().Type, Val.getValue().TypeLoc, Val.getValue().LOpen,
|
|
Val.getValue().Loc, Val.getValue().RLoc);
|
|
}
|
|
|
|
/// Parsing of OpenMP clauses like 'ordered'.
|
|
///
|
|
/// ordered-clause:
|
|
/// 'ordered'
|
|
///
|
|
/// nowait-clause:
|
|
/// 'nowait'
|
|
///
|
|
/// untied-clause:
|
|
/// 'untied'
|
|
///
|
|
/// mergeable-clause:
|
|
/// 'mergeable'
|
|
///
|
|
/// read-clause:
|
|
/// 'read'
|
|
///
|
|
/// threads-clause:
|
|
/// 'threads'
|
|
///
|
|
/// simd-clause:
|
|
/// 'simd'
|
|
///
|
|
/// nogroup-clause:
|
|
/// 'nogroup'
|
|
///
|
|
OMPClause *Parser::ParseOpenMPClause(OpenMPClauseKind Kind, bool ParseOnly) {
|
|
SourceLocation Loc = Tok.getLocation();
|
|
ConsumeAnyToken();
|
|
|
|
if (ParseOnly)
|
|
return nullptr;
|
|
return Actions.ActOnOpenMPClause(Kind, Loc, Tok.getLocation());
|
|
}
|
|
|
|
/// Parsing of OpenMP clauses with single expressions and some additional
|
|
/// argument like 'schedule' or 'dist_schedule'.
|
|
///
|
|
/// schedule-clause:
|
|
/// 'schedule' '(' [ modifier [ ',' modifier ] ':' ] kind [',' expression ]
|
|
/// ')'
|
|
///
|
|
/// if-clause:
|
|
/// 'if' '(' [ directive-name-modifier ':' ] expression ')'
|
|
///
|
|
/// defaultmap:
|
|
/// 'defaultmap' '(' modifier [ ':' kind ] ')'
|
|
///
|
|
/// device-clause:
|
|
/// 'device' '(' [ device-modifier ':' ] expression ')'
|
|
///
|
|
OMPClause *Parser::ParseOpenMPSingleExprWithArgClause(OpenMPDirectiveKind DKind,
|
|
OpenMPClauseKind Kind,
|
|
bool ParseOnly) {
|
|
SourceLocation Loc = ConsumeToken();
|
|
SourceLocation DelimLoc;
|
|
// Parse '('.
|
|
BalancedDelimiterTracker T(*this, tok::l_paren, tok::annot_pragma_openmp_end);
|
|
if (T.expectAndConsume(diag::err_expected_lparen_after,
|
|
getOpenMPClauseName(Kind).data()))
|
|
return nullptr;
|
|
|
|
ExprResult Val;
|
|
SmallVector<unsigned, 4> Arg;
|
|
SmallVector<SourceLocation, 4> KLoc;
|
|
if (Kind == OMPC_schedule) {
|
|
enum { Modifier1, Modifier2, ScheduleKind, NumberOfElements };
|
|
Arg.resize(NumberOfElements);
|
|
KLoc.resize(NumberOfElements);
|
|
Arg[Modifier1] = OMPC_SCHEDULE_MODIFIER_unknown;
|
|
Arg[Modifier2] = OMPC_SCHEDULE_MODIFIER_unknown;
|
|
Arg[ScheduleKind] = OMPC_SCHEDULE_unknown;
|
|
unsigned KindModifier = getOpenMPSimpleClauseType(
|
|
Kind, Tok.isAnnotation() ? "" : PP.getSpelling(Tok),
|
|
getLangOpts().OpenMP);
|
|
if (KindModifier > OMPC_SCHEDULE_unknown) {
|
|
// Parse 'modifier'
|
|
Arg[Modifier1] = KindModifier;
|
|
KLoc[Modifier1] = Tok.getLocation();
|
|
if (Tok.isNot(tok::r_paren) && Tok.isNot(tok::comma) &&
|
|
Tok.isNot(tok::annot_pragma_openmp_end))
|
|
ConsumeAnyToken();
|
|
if (Tok.is(tok::comma)) {
|
|
// Parse ',' 'modifier'
|
|
ConsumeAnyToken();
|
|
KindModifier = getOpenMPSimpleClauseType(
|
|
Kind, Tok.isAnnotation() ? "" : PP.getSpelling(Tok),
|
|
getLangOpts().OpenMP);
|
|
Arg[Modifier2] = KindModifier > OMPC_SCHEDULE_unknown
|
|
? KindModifier
|
|
: (unsigned)OMPC_SCHEDULE_unknown;
|
|
KLoc[Modifier2] = Tok.getLocation();
|
|
if (Tok.isNot(tok::r_paren) && Tok.isNot(tok::comma) &&
|
|
Tok.isNot(tok::annot_pragma_openmp_end))
|
|
ConsumeAnyToken();
|
|
}
|
|
// Parse ':'
|
|
if (Tok.is(tok::colon))
|
|
ConsumeAnyToken();
|
|
else
|
|
Diag(Tok, diag::warn_pragma_expected_colon) << "schedule modifier";
|
|
KindModifier = getOpenMPSimpleClauseType(
|
|
Kind, Tok.isAnnotation() ? "" : PP.getSpelling(Tok),
|
|
getLangOpts().OpenMP);
|
|
}
|
|
Arg[ScheduleKind] = KindModifier;
|
|
KLoc[ScheduleKind] = Tok.getLocation();
|
|
if (Tok.isNot(tok::r_paren) && Tok.isNot(tok::comma) &&
|
|
Tok.isNot(tok::annot_pragma_openmp_end))
|
|
ConsumeAnyToken();
|
|
if ((Arg[ScheduleKind] == OMPC_SCHEDULE_static ||
|
|
Arg[ScheduleKind] == OMPC_SCHEDULE_dynamic ||
|
|
Arg[ScheduleKind] == OMPC_SCHEDULE_guided) &&
|
|
Tok.is(tok::comma))
|
|
DelimLoc = ConsumeAnyToken();
|
|
} else if (Kind == OMPC_dist_schedule) {
|
|
Arg.push_back(getOpenMPSimpleClauseType(
|
|
Kind, Tok.isAnnotation() ? "" : PP.getSpelling(Tok),
|
|
getLangOpts().OpenMP));
|
|
KLoc.push_back(Tok.getLocation());
|
|
if (Tok.isNot(tok::r_paren) && Tok.isNot(tok::comma) &&
|
|
Tok.isNot(tok::annot_pragma_openmp_end))
|
|
ConsumeAnyToken();
|
|
if (Arg.back() == OMPC_DIST_SCHEDULE_static && Tok.is(tok::comma))
|
|
DelimLoc = ConsumeAnyToken();
|
|
} else if (Kind == OMPC_defaultmap) {
|
|
// Get a defaultmap modifier
|
|
unsigned Modifier = getOpenMPSimpleClauseType(
|
|
Kind, Tok.isAnnotation() ? "" : PP.getSpelling(Tok),
|
|
getLangOpts().OpenMP);
|
|
// Set defaultmap modifier to unknown if it is either scalar, aggregate, or
|
|
// pointer
|
|
if (Modifier < OMPC_DEFAULTMAP_MODIFIER_unknown)
|
|
Modifier = OMPC_DEFAULTMAP_MODIFIER_unknown;
|
|
Arg.push_back(Modifier);
|
|
KLoc.push_back(Tok.getLocation());
|
|
if (Tok.isNot(tok::r_paren) && Tok.isNot(tok::comma) &&
|
|
Tok.isNot(tok::annot_pragma_openmp_end))
|
|
ConsumeAnyToken();
|
|
// Parse ':'
|
|
if (Tok.is(tok::colon) || getLangOpts().OpenMP < 50) {
|
|
if (Tok.is(tok::colon))
|
|
ConsumeAnyToken();
|
|
else if (Arg.back() != OMPC_DEFAULTMAP_MODIFIER_unknown)
|
|
Diag(Tok, diag::warn_pragma_expected_colon) << "defaultmap modifier";
|
|
// Get a defaultmap kind
|
|
Arg.push_back(getOpenMPSimpleClauseType(
|
|
Kind, Tok.isAnnotation() ? "" : PP.getSpelling(Tok),
|
|
getLangOpts().OpenMP));
|
|
KLoc.push_back(Tok.getLocation());
|
|
if (Tok.isNot(tok::r_paren) && Tok.isNot(tok::comma) &&
|
|
Tok.isNot(tok::annot_pragma_openmp_end))
|
|
ConsumeAnyToken();
|
|
} else {
|
|
Arg.push_back(OMPC_DEFAULTMAP_unknown);
|
|
KLoc.push_back(SourceLocation());
|
|
}
|
|
} else if (Kind == OMPC_device) {
|
|
// Only target executable directives support extended device construct.
|
|
if (isOpenMPTargetExecutionDirective(DKind) && getLangOpts().OpenMP >= 50 &&
|
|
NextToken().is(tok::colon)) {
|
|
// Parse optional <device modifier> ':'
|
|
Arg.push_back(getOpenMPSimpleClauseType(
|
|
Kind, Tok.isAnnotation() ? "" : PP.getSpelling(Tok),
|
|
getLangOpts().OpenMP));
|
|
KLoc.push_back(Tok.getLocation());
|
|
ConsumeAnyToken();
|
|
// Parse ':'
|
|
ConsumeAnyToken();
|
|
} else {
|
|
Arg.push_back(OMPC_DEVICE_unknown);
|
|
KLoc.emplace_back();
|
|
}
|
|
} else {
|
|
assert(Kind == OMPC_if);
|
|
KLoc.push_back(Tok.getLocation());
|
|
TentativeParsingAction TPA(*this);
|
|
auto DK = parseOpenMPDirectiveKind(*this);
|
|
Arg.push_back(DK);
|
|
if (DK != OMPD_unknown) {
|
|
ConsumeToken();
|
|
if (Tok.is(tok::colon) && getLangOpts().OpenMP > 40) {
|
|
TPA.Commit();
|
|
DelimLoc = ConsumeToken();
|
|
} else {
|
|
TPA.Revert();
|
|
Arg.back() = unsigned(OMPD_unknown);
|
|
}
|
|
} else {
|
|
TPA.Revert();
|
|
}
|
|
}
|
|
|
|
bool NeedAnExpression = (Kind == OMPC_schedule && DelimLoc.isValid()) ||
|
|
(Kind == OMPC_dist_schedule && DelimLoc.isValid()) ||
|
|
Kind == OMPC_if || Kind == OMPC_device;
|
|
if (NeedAnExpression) {
|
|
SourceLocation ELoc = Tok.getLocation();
|
|
ExprResult LHS(ParseCastExpression(AnyCastExpr, false, NotTypeCast));
|
|
Val = ParseRHSOfBinaryExpression(LHS, prec::Conditional);
|
|
Val =
|
|
Actions.ActOnFinishFullExpr(Val.get(), ELoc, /*DiscardedValue*/ false);
|
|
}
|
|
|
|
// Parse ')'.
|
|
SourceLocation RLoc = Tok.getLocation();
|
|
if (!T.consumeClose())
|
|
RLoc = T.getCloseLocation();
|
|
|
|
if (NeedAnExpression && Val.isInvalid())
|
|
return nullptr;
|
|
|
|
if (ParseOnly)
|
|
return nullptr;
|
|
return Actions.ActOnOpenMPSingleExprWithArgClause(
|
|
Kind, Arg, Val.get(), Loc, T.getOpenLocation(), KLoc, DelimLoc, RLoc);
|
|
}
|
|
|
|
static bool ParseReductionId(Parser &P, CXXScopeSpec &ReductionIdScopeSpec,
|
|
UnqualifiedId &ReductionId) {
|
|
if (ReductionIdScopeSpec.isEmpty()) {
|
|
auto OOK = OO_None;
|
|
switch (P.getCurToken().getKind()) {
|
|
case tok::plus:
|
|
OOK = OO_Plus;
|
|
break;
|
|
case tok::minus:
|
|
OOK = OO_Minus;
|
|
break;
|
|
case tok::star:
|
|
OOK = OO_Star;
|
|
break;
|
|
case tok::amp:
|
|
OOK = OO_Amp;
|
|
break;
|
|
case tok::pipe:
|
|
OOK = OO_Pipe;
|
|
break;
|
|
case tok::caret:
|
|
OOK = OO_Caret;
|
|
break;
|
|
case tok::ampamp:
|
|
OOK = OO_AmpAmp;
|
|
break;
|
|
case tok::pipepipe:
|
|
OOK = OO_PipePipe;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
if (OOK != OO_None) {
|
|
SourceLocation OpLoc = P.ConsumeToken();
|
|
SourceLocation SymbolLocations[] = {OpLoc, OpLoc, SourceLocation()};
|
|
ReductionId.setOperatorFunctionId(OpLoc, OOK, SymbolLocations);
|
|
return false;
|
|
}
|
|
}
|
|
return P.ParseUnqualifiedId(
|
|
ReductionIdScopeSpec, /*ObjectType=*/nullptr,
|
|
/*ObjectHadErrors=*/false, /*EnteringContext*/ false,
|
|
/*AllowDestructorName*/ false,
|
|
/*AllowConstructorName*/ false,
|
|
/*AllowDeductionGuide*/ false, nullptr, ReductionId);
|
|
}
|
|
|
|
/// Checks if the token is a valid map-type-modifier.
|
|
/// FIXME: It will return an OpenMPMapClauseKind if that's what it parses.
|
|
static OpenMPMapModifierKind isMapModifier(Parser &P) {
|
|
Token Tok = P.getCurToken();
|
|
if (!Tok.is(tok::identifier))
|
|
return OMPC_MAP_MODIFIER_unknown;
|
|
|
|
Preprocessor &PP = P.getPreprocessor();
|
|
OpenMPMapModifierKind TypeModifier =
|
|
static_cast<OpenMPMapModifierKind>(getOpenMPSimpleClauseType(
|
|
OMPC_map, PP.getSpelling(Tok), P.getLangOpts().OpenMP));
|
|
return TypeModifier;
|
|
}
|
|
|
|
/// Parse the mapper modifier in map, to, and from clauses.
|
|
bool Parser::parseMapperModifier(OpenMPVarListDataTy &Data) {
|
|
// Parse '('.
|
|
BalancedDelimiterTracker T(*this, tok::l_paren, tok::colon);
|
|
if (T.expectAndConsume(diag::err_expected_lparen_after, "mapper")) {
|
|
SkipUntil(tok::colon, tok::r_paren, tok::annot_pragma_openmp_end,
|
|
StopBeforeMatch);
|
|
return true;
|
|
}
|
|
// Parse mapper-identifier
|
|
if (getLangOpts().CPlusPlus)
|
|
ParseOptionalCXXScopeSpecifier(Data.ReductionOrMapperIdScopeSpec,
|
|
/*ObjectType=*/nullptr,
|
|
/*ObjectHadErrors=*/false,
|
|
/*EnteringContext=*/false);
|
|
if (Tok.isNot(tok::identifier) && Tok.isNot(tok::kw_default)) {
|
|
Diag(Tok.getLocation(), diag::err_omp_mapper_illegal_identifier);
|
|
SkipUntil(tok::colon, tok::r_paren, tok::annot_pragma_openmp_end,
|
|
StopBeforeMatch);
|
|
return true;
|
|
}
|
|
auto &DeclNames = Actions.getASTContext().DeclarationNames;
|
|
Data.ReductionOrMapperId = DeclarationNameInfo(
|
|
DeclNames.getIdentifier(Tok.getIdentifierInfo()), Tok.getLocation());
|
|
ConsumeToken();
|
|
// Parse ')'.
|
|
return T.consumeClose();
|
|
}
|
|
|
|
/// Parse map-type-modifiers in map clause.
|
|
/// map([ [map-type-modifier[,] [map-type-modifier[,] ...] map-type : ] list)
|
|
/// where, map-type-modifier ::= always | close | mapper(mapper-identifier) |
|
|
/// present
|
|
bool Parser::parseMapTypeModifiers(OpenMPVarListDataTy &Data) {
|
|
while (getCurToken().isNot(tok::colon)) {
|
|
OpenMPMapModifierKind TypeModifier = isMapModifier(*this);
|
|
if (TypeModifier == OMPC_MAP_MODIFIER_always ||
|
|
TypeModifier == OMPC_MAP_MODIFIER_close ||
|
|
TypeModifier == OMPC_MAP_MODIFIER_present) {
|
|
Data.MapTypeModifiers.push_back(TypeModifier);
|
|
Data.MapTypeModifiersLoc.push_back(Tok.getLocation());
|
|
ConsumeToken();
|
|
} else if (TypeModifier == OMPC_MAP_MODIFIER_mapper) {
|
|
Data.MapTypeModifiers.push_back(TypeModifier);
|
|
Data.MapTypeModifiersLoc.push_back(Tok.getLocation());
|
|
ConsumeToken();
|
|
if (parseMapperModifier(Data))
|
|
return true;
|
|
} else {
|
|
// For the case of unknown map-type-modifier or a map-type.
|
|
// Map-type is followed by a colon; the function returns when it
|
|
// encounters a token followed by a colon.
|
|
if (Tok.is(tok::comma)) {
|
|
Diag(Tok, diag::err_omp_map_type_modifier_missing);
|
|
ConsumeToken();
|
|
continue;
|
|
}
|
|
// Potential map-type token as it is followed by a colon.
|
|
if (PP.LookAhead(0).is(tok::colon))
|
|
return false;
|
|
Diag(Tok, diag::err_omp_unknown_map_type_modifier)
|
|
<< (getLangOpts().OpenMP >= 51 ? 1 : 0);
|
|
ConsumeToken();
|
|
}
|
|
if (getCurToken().is(tok::comma))
|
|
ConsumeToken();
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/// Checks if the token is a valid map-type.
|
|
/// FIXME: It will return an OpenMPMapModifierKind if that's what it parses.
|
|
static OpenMPMapClauseKind isMapType(Parser &P) {
|
|
Token Tok = P.getCurToken();
|
|
// The map-type token can be either an identifier or the C++ delete keyword.
|
|
if (!Tok.isOneOf(tok::identifier, tok::kw_delete))
|
|
return OMPC_MAP_unknown;
|
|
Preprocessor &PP = P.getPreprocessor();
|
|
OpenMPMapClauseKind MapType =
|
|
static_cast<OpenMPMapClauseKind>(getOpenMPSimpleClauseType(
|
|
OMPC_map, PP.getSpelling(Tok), P.getLangOpts().OpenMP));
|
|
return MapType;
|
|
}
|
|
|
|
/// Parse map-type in map clause.
|
|
/// map([ [map-type-modifier[,] [map-type-modifier[,] ...] map-type : ] list)
|
|
/// where, map-type ::= to | from | tofrom | alloc | release | delete
|
|
static void parseMapType(Parser &P, Parser::OpenMPVarListDataTy &Data) {
|
|
Token Tok = P.getCurToken();
|
|
if (Tok.is(tok::colon)) {
|
|
P.Diag(Tok, diag::err_omp_map_type_missing);
|
|
return;
|
|
}
|
|
Data.ExtraModifier = isMapType(P);
|
|
if (Data.ExtraModifier == OMPC_MAP_unknown)
|
|
P.Diag(Tok, diag::err_omp_unknown_map_type);
|
|
P.ConsumeToken();
|
|
}
|
|
|
|
/// Parses simple expression in parens for single-expression clauses of OpenMP
|
|
/// constructs.
|
|
ExprResult Parser::ParseOpenMPIteratorsExpr() {
|
|
assert(Tok.is(tok::identifier) && PP.getSpelling(Tok) == "iterator" &&
|
|
"Expected 'iterator' token.");
|
|
SourceLocation IteratorKwLoc = ConsumeToken();
|
|
|
|
BalancedDelimiterTracker T(*this, tok::l_paren, tok::annot_pragma_openmp_end);
|
|
if (T.expectAndConsume(diag::err_expected_lparen_after, "iterator"))
|
|
return ExprError();
|
|
|
|
SourceLocation LLoc = T.getOpenLocation();
|
|
SmallVector<Sema::OMPIteratorData, 4> Data;
|
|
while (Tok.isNot(tok::r_paren) && Tok.isNot(tok::annot_pragma_openmp_end)) {
|
|
// Check if the type parsing is required.
|
|
ParsedType IteratorType;
|
|
if (Tok.isNot(tok::identifier) || NextToken().isNot(tok::equal)) {
|
|
// identifier '=' is not found - parse type.
|
|
TypeResult TR = ParseTypeName();
|
|
if (TR.isInvalid()) {
|
|
T.skipToEnd();
|
|
return ExprError();
|
|
}
|
|
IteratorType = TR.get();
|
|
}
|
|
|
|
// Parse identifier.
|
|
IdentifierInfo *II = nullptr;
|
|
SourceLocation IdLoc;
|
|
if (Tok.is(tok::identifier)) {
|
|
II = Tok.getIdentifierInfo();
|
|
IdLoc = ConsumeToken();
|
|
} else {
|
|
Diag(Tok, diag::err_expected_unqualified_id) << 0;
|
|
}
|
|
|
|
// Parse '='.
|
|
SourceLocation AssignLoc;
|
|
if (Tok.is(tok::equal))
|
|
AssignLoc = ConsumeToken();
|
|
else
|
|
Diag(Tok, diag::err_omp_expected_equal_in_iterator);
|
|
|
|
// Parse range-specification - <begin> ':' <end> [ ':' <step> ]
|
|
ColonProtectionRAIIObject ColonRAII(*this);
|
|
// Parse <begin>
|
|
SourceLocation Loc = Tok.getLocation();
|
|
ExprResult LHS = ParseCastExpression(AnyCastExpr);
|
|
ExprResult Begin = Actions.CorrectDelayedTyposInExpr(
|
|
ParseRHSOfBinaryExpression(LHS, prec::Conditional));
|
|
Begin = Actions.ActOnFinishFullExpr(Begin.get(), Loc,
|
|
/*DiscardedValue=*/false);
|
|
// Parse ':'.
|
|
SourceLocation ColonLoc;
|
|
if (Tok.is(tok::colon))
|
|
ColonLoc = ConsumeToken();
|
|
|
|
// Parse <end>
|
|
Loc = Tok.getLocation();
|
|
LHS = ParseCastExpression(AnyCastExpr);
|
|
ExprResult End = Actions.CorrectDelayedTyposInExpr(
|
|
ParseRHSOfBinaryExpression(LHS, prec::Conditional));
|
|
End = Actions.ActOnFinishFullExpr(End.get(), Loc,
|
|
/*DiscardedValue=*/false);
|
|
|
|
SourceLocation SecColonLoc;
|
|
ExprResult Step;
|
|
// Parse optional step.
|
|
if (Tok.is(tok::colon)) {
|
|
// Parse ':'
|
|
SecColonLoc = ConsumeToken();
|
|
// Parse <step>
|
|
Loc = Tok.getLocation();
|
|
LHS = ParseCastExpression(AnyCastExpr);
|
|
Step = Actions.CorrectDelayedTyposInExpr(
|
|
ParseRHSOfBinaryExpression(LHS, prec::Conditional));
|
|
Step = Actions.ActOnFinishFullExpr(Step.get(), Loc,
|
|
/*DiscardedValue=*/false);
|
|
}
|
|
|
|
// Parse ',' or ')'
|
|
if (Tok.isNot(tok::comma) && Tok.isNot(tok::r_paren))
|
|
Diag(Tok, diag::err_omp_expected_punc_after_iterator);
|
|
if (Tok.is(tok::comma))
|
|
ConsumeToken();
|
|
|
|
Sema::OMPIteratorData &D = Data.emplace_back();
|
|
D.DeclIdent = II;
|
|
D.DeclIdentLoc = IdLoc;
|
|
D.Type = IteratorType;
|
|
D.AssignLoc = AssignLoc;
|
|
D.ColonLoc = ColonLoc;
|
|
D.SecColonLoc = SecColonLoc;
|
|
D.Range.Begin = Begin.get();
|
|
D.Range.End = End.get();
|
|
D.Range.Step = Step.get();
|
|
}
|
|
|
|
// Parse ')'.
|
|
SourceLocation RLoc = Tok.getLocation();
|
|
if (!T.consumeClose())
|
|
RLoc = T.getCloseLocation();
|
|
|
|
return Actions.ActOnOMPIteratorExpr(getCurScope(), IteratorKwLoc, LLoc, RLoc,
|
|
Data);
|
|
}
|
|
|
|
/// Parses clauses with list.
|
|
bool Parser::ParseOpenMPVarList(OpenMPDirectiveKind DKind,
|
|
OpenMPClauseKind Kind,
|
|
SmallVectorImpl<Expr *> &Vars,
|
|
OpenMPVarListDataTy &Data) {
|
|
UnqualifiedId UnqualifiedReductionId;
|
|
bool InvalidReductionId = false;
|
|
bool IsInvalidMapperModifier = false;
|
|
|
|
// Parse '('.
|
|
BalancedDelimiterTracker T(*this, tok::l_paren, tok::annot_pragma_openmp_end);
|
|
if (T.expectAndConsume(diag::err_expected_lparen_after,
|
|
getOpenMPClauseName(Kind).data()))
|
|
return true;
|
|
|
|
bool HasIterator = false;
|
|
bool NeedRParenForLinear = false;
|
|
BalancedDelimiterTracker LinearT(*this, tok::l_paren,
|
|
tok::annot_pragma_openmp_end);
|
|
// Handle reduction-identifier for reduction clause.
|
|
if (Kind == OMPC_reduction || Kind == OMPC_task_reduction ||
|
|
Kind == OMPC_in_reduction) {
|
|
Data.ExtraModifier = OMPC_REDUCTION_unknown;
|
|
if (Kind == OMPC_reduction && getLangOpts().OpenMP >= 50 &&
|
|
(Tok.is(tok::identifier) || Tok.is(tok::kw_default)) &&
|
|
NextToken().is(tok::comma)) {
|
|
// Parse optional reduction modifier.
|
|
Data.ExtraModifier = getOpenMPSimpleClauseType(Kind, PP.getSpelling(Tok),
|
|
getLangOpts().OpenMP);
|
|
Data.ExtraModifierLoc = Tok.getLocation();
|
|
ConsumeToken();
|
|
assert(Tok.is(tok::comma) && "Expected comma.");
|
|
(void)ConsumeToken();
|
|
}
|
|
ColonProtectionRAIIObject ColonRAII(*this);
|
|
if (getLangOpts().CPlusPlus)
|
|
ParseOptionalCXXScopeSpecifier(Data.ReductionOrMapperIdScopeSpec,
|
|
/*ObjectType=*/nullptr,
|
|
/*ObjectHadErrors=*/false,
|
|
/*EnteringContext=*/false);
|
|
InvalidReductionId = ParseReductionId(
|
|
*this, Data.ReductionOrMapperIdScopeSpec, UnqualifiedReductionId);
|
|
if (InvalidReductionId) {
|
|
SkipUntil(tok::colon, tok::r_paren, tok::annot_pragma_openmp_end,
|
|
StopBeforeMatch);
|
|
}
|
|
if (Tok.is(tok::colon))
|
|
Data.ColonLoc = ConsumeToken();
|
|
else
|
|
Diag(Tok, diag::warn_pragma_expected_colon) << "reduction identifier";
|
|
if (!InvalidReductionId)
|
|
Data.ReductionOrMapperId =
|
|
Actions.GetNameFromUnqualifiedId(UnqualifiedReductionId);
|
|
} else if (Kind == OMPC_depend) {
|
|
if (getLangOpts().OpenMP >= 50) {
|
|
if (Tok.is(tok::identifier) && PP.getSpelling(Tok) == "iterator") {
|
|
// Handle optional dependence modifier.
|
|
// iterator(iterators-definition)
|
|
// where iterators-definition is iterator-specifier [,
|
|
// iterators-definition ]
|
|
// where iterator-specifier is [ iterator-type ] identifier =
|
|
// range-specification
|
|
HasIterator = true;
|
|
EnterScope(Scope::OpenMPDirectiveScope | Scope::DeclScope);
|
|
ExprResult IteratorRes = ParseOpenMPIteratorsExpr();
|
|
Data.DepModOrTailExpr = IteratorRes.get();
|
|
// Parse ','
|
|
ExpectAndConsume(tok::comma);
|
|
}
|
|
}
|
|
// Handle dependency type for depend clause.
|
|
ColonProtectionRAIIObject ColonRAII(*this);
|
|
Data.ExtraModifier = getOpenMPSimpleClauseType(
|
|
Kind, Tok.is(tok::identifier) ? PP.getSpelling(Tok) : "",
|
|
getLangOpts().OpenMP);
|
|
Data.ExtraModifierLoc = Tok.getLocation();
|
|
if (Data.ExtraModifier == OMPC_DEPEND_unknown) {
|
|
SkipUntil(tok::colon, tok::r_paren, tok::annot_pragma_openmp_end,
|
|
StopBeforeMatch);
|
|
} else {
|
|
ConsumeToken();
|
|
// Special processing for depend(source) clause.
|
|
if (DKind == OMPD_ordered && Data.ExtraModifier == OMPC_DEPEND_source) {
|
|
// Parse ')'.
|
|
T.consumeClose();
|
|
return false;
|
|
}
|
|
}
|
|
if (Tok.is(tok::colon)) {
|
|
Data.ColonLoc = ConsumeToken();
|
|
} else {
|
|
Diag(Tok, DKind == OMPD_ordered ? diag::warn_pragma_expected_colon_r_paren
|
|
: diag::warn_pragma_expected_colon)
|
|
<< "dependency type";
|
|
}
|
|
} else if (Kind == OMPC_linear) {
|
|
// Try to parse modifier if any.
|
|
Data.ExtraModifier = OMPC_LINEAR_val;
|
|
if (Tok.is(tok::identifier) && PP.LookAhead(0).is(tok::l_paren)) {
|
|
Data.ExtraModifier = getOpenMPSimpleClauseType(Kind, PP.getSpelling(Tok),
|
|
getLangOpts().OpenMP);
|
|
Data.ExtraModifierLoc = ConsumeToken();
|
|
LinearT.consumeOpen();
|
|
NeedRParenForLinear = true;
|
|
}
|
|
} else if (Kind == OMPC_lastprivate) {
|
|
// Try to parse modifier if any.
|
|
Data.ExtraModifier = OMPC_LASTPRIVATE_unknown;
|
|
// Conditional modifier allowed only in OpenMP 5.0 and not supported in
|
|
// distribute and taskloop based directives.
|
|
if ((getLangOpts().OpenMP >= 50 && !isOpenMPDistributeDirective(DKind) &&
|
|
!isOpenMPTaskLoopDirective(DKind)) &&
|
|
Tok.is(tok::identifier) && PP.LookAhead(0).is(tok::colon)) {
|
|
Data.ExtraModifier = getOpenMPSimpleClauseType(Kind, PP.getSpelling(Tok),
|
|
getLangOpts().OpenMP);
|
|
Data.ExtraModifierLoc = Tok.getLocation();
|
|
ConsumeToken();
|
|
assert(Tok.is(tok::colon) && "Expected colon.");
|
|
Data.ColonLoc = ConsumeToken();
|
|
}
|
|
} else if (Kind == OMPC_map) {
|
|
// Handle map type for map clause.
|
|
ColonProtectionRAIIObject ColonRAII(*this);
|
|
|
|
// The first identifier may be a list item, a map-type or a
|
|
// map-type-modifier. The map-type can also be delete which has the same
|
|
// spelling of the C++ delete keyword.
|
|
Data.ExtraModifier = OMPC_MAP_unknown;
|
|
Data.ExtraModifierLoc = Tok.getLocation();
|
|
|
|
// Check for presence of a colon in the map clause.
|
|
TentativeParsingAction TPA(*this);
|
|
bool ColonPresent = false;
|
|
if (SkipUntil(tok::colon, tok::r_paren, tok::annot_pragma_openmp_end,
|
|
StopBeforeMatch)) {
|
|
if (Tok.is(tok::colon))
|
|
ColonPresent = true;
|
|
}
|
|
TPA.Revert();
|
|
// Only parse map-type-modifier[s] and map-type if a colon is present in
|
|
// the map clause.
|
|
if (ColonPresent) {
|
|
IsInvalidMapperModifier = parseMapTypeModifiers(Data);
|
|
if (!IsInvalidMapperModifier)
|
|
parseMapType(*this, Data);
|
|
else
|
|
SkipUntil(tok::colon, tok::annot_pragma_openmp_end, StopBeforeMatch);
|
|
}
|
|
if (Data.ExtraModifier == OMPC_MAP_unknown) {
|
|
Data.ExtraModifier = OMPC_MAP_tofrom;
|
|
Data.IsMapTypeImplicit = true;
|
|
}
|
|
|
|
if (Tok.is(tok::colon))
|
|
Data.ColonLoc = ConsumeToken();
|
|
} else if (Kind == OMPC_to || Kind == OMPC_from) {
|
|
while (Tok.is(tok::identifier)) {
|
|
auto Modifier =
|
|
static_cast<OpenMPMotionModifierKind>(getOpenMPSimpleClauseType(
|
|
Kind, PP.getSpelling(Tok), getLangOpts().OpenMP));
|
|
if (Modifier == OMPC_MOTION_MODIFIER_unknown)
|
|
break;
|
|
Data.MotionModifiers.push_back(Modifier);
|
|
Data.MotionModifiersLoc.push_back(Tok.getLocation());
|
|
ConsumeToken();
|
|
if (Modifier == OMPC_MOTION_MODIFIER_mapper) {
|
|
IsInvalidMapperModifier = parseMapperModifier(Data);
|
|
if (IsInvalidMapperModifier)
|
|
break;
|
|
}
|
|
// OpenMP < 5.1 doesn't permit a ',' or additional modifiers.
|
|
if (getLangOpts().OpenMP < 51)
|
|
break;
|
|
// OpenMP 5.1 accepts an optional ',' even if the next character is ':'.
|
|
// TODO: Is that intentional?
|
|
if (Tok.is(tok::comma))
|
|
ConsumeToken();
|
|
}
|
|
if (!Data.MotionModifiers.empty() && Tok.isNot(tok::colon)) {
|
|
if (!IsInvalidMapperModifier) {
|
|
if (getLangOpts().OpenMP < 51)
|
|
Diag(Tok, diag::warn_pragma_expected_colon) << ")";
|
|
else
|
|
Diag(Tok, diag::warn_pragma_expected_colon) << "motion modifier";
|
|
}
|
|
SkipUntil(tok::colon, tok::r_paren, tok::annot_pragma_openmp_end,
|
|
StopBeforeMatch);
|
|
}
|
|
// OpenMP 5.1 permits a ':' even without a preceding modifier. TODO: Is
|
|
// that intentional?
|
|
if ((!Data.MotionModifiers.empty() || getLangOpts().OpenMP >= 51) &&
|
|
Tok.is(tok::colon))
|
|
Data.ColonLoc = ConsumeToken();
|
|
} else if (Kind == OMPC_allocate ||
|
|
(Kind == OMPC_affinity && Tok.is(tok::identifier) &&
|
|
PP.getSpelling(Tok) == "iterator")) {
|
|
// Handle optional allocator expression followed by colon delimiter.
|
|
ColonProtectionRAIIObject ColonRAII(*this);
|
|
TentativeParsingAction TPA(*this);
|
|
// OpenMP 5.0, 2.10.1, task Construct.
|
|
// where aff-modifier is one of the following:
|
|
// iterator(iterators-definition)
|
|
ExprResult Tail;
|
|
if (Kind == OMPC_allocate) {
|
|
Tail = ParseAssignmentExpression();
|
|
} else {
|
|
HasIterator = true;
|
|
EnterScope(Scope::OpenMPDirectiveScope | Scope::DeclScope);
|
|
Tail = ParseOpenMPIteratorsExpr();
|
|
}
|
|
Tail = Actions.CorrectDelayedTyposInExpr(Tail);
|
|
Tail = Actions.ActOnFinishFullExpr(Tail.get(), T.getOpenLocation(),
|
|
/*DiscardedValue=*/false);
|
|
if (Tail.isUsable()) {
|
|
if (Tok.is(tok::colon)) {
|
|
Data.DepModOrTailExpr = Tail.get();
|
|
Data.ColonLoc = ConsumeToken();
|
|
TPA.Commit();
|
|
} else {
|
|
// Colon not found, parse only list of variables.
|
|
TPA.Revert();
|
|
}
|
|
} else {
|
|
// Parsing was unsuccessfull, revert and skip to the end of clause or
|
|
// directive.
|
|
TPA.Revert();
|
|
SkipUntil(tok::comma, tok::r_paren, tok::annot_pragma_openmp_end,
|
|
StopBeforeMatch);
|
|
}
|
|
}
|
|
|
|
bool IsComma =
|
|
(Kind != OMPC_reduction && Kind != OMPC_task_reduction &&
|
|
Kind != OMPC_in_reduction && Kind != OMPC_depend && Kind != OMPC_map) ||
|
|
(Kind == OMPC_reduction && !InvalidReductionId) ||
|
|
(Kind == OMPC_map && Data.ExtraModifier != OMPC_MAP_unknown) ||
|
|
(Kind == OMPC_depend && Data.ExtraModifier != OMPC_DEPEND_unknown);
|
|
const bool MayHaveTail = (Kind == OMPC_linear || Kind == OMPC_aligned);
|
|
while (IsComma || (Tok.isNot(tok::r_paren) && Tok.isNot(tok::colon) &&
|
|
Tok.isNot(tok::annot_pragma_openmp_end))) {
|
|
ParseScope OMPListScope(this, Scope::OpenMPDirectiveScope);
|
|
ColonProtectionRAIIObject ColonRAII(*this, MayHaveTail);
|
|
// Parse variable
|
|
ExprResult VarExpr =
|
|
Actions.CorrectDelayedTyposInExpr(ParseAssignmentExpression());
|
|
if (VarExpr.isUsable()) {
|
|
Vars.push_back(VarExpr.get());
|
|
} else {
|
|
SkipUntil(tok::comma, tok::r_paren, tok::annot_pragma_openmp_end,
|
|
StopBeforeMatch);
|
|
}
|
|
// Skip ',' if any
|
|
IsComma = Tok.is(tok::comma);
|
|
if (IsComma)
|
|
ConsumeToken();
|
|
else if (Tok.isNot(tok::r_paren) &&
|
|
Tok.isNot(tok::annot_pragma_openmp_end) &&
|
|
(!MayHaveTail || Tok.isNot(tok::colon)))
|
|
Diag(Tok, diag::err_omp_expected_punc)
|
|
<< ((Kind == OMPC_flush) ? getOpenMPDirectiveName(OMPD_flush)
|
|
: getOpenMPClauseName(Kind))
|
|
<< (Kind == OMPC_flush);
|
|
}
|
|
|
|
// Parse ')' for linear clause with modifier.
|
|
if (NeedRParenForLinear)
|
|
LinearT.consumeClose();
|
|
|
|
// Parse ':' linear-step (or ':' alignment).
|
|
const bool MustHaveTail = MayHaveTail && Tok.is(tok::colon);
|
|
if (MustHaveTail) {
|
|
Data.ColonLoc = Tok.getLocation();
|
|
SourceLocation ELoc = ConsumeToken();
|
|
ExprResult Tail = ParseAssignmentExpression();
|
|
Tail =
|
|
Actions.ActOnFinishFullExpr(Tail.get(), ELoc, /*DiscardedValue*/ false);
|
|
if (Tail.isUsable())
|
|
Data.DepModOrTailExpr = Tail.get();
|
|
else
|
|
SkipUntil(tok::comma, tok::r_paren, tok::annot_pragma_openmp_end,
|
|
StopBeforeMatch);
|
|
}
|
|
|
|
// Parse ')'.
|
|
Data.RLoc = Tok.getLocation();
|
|
if (!T.consumeClose())
|
|
Data.RLoc = T.getCloseLocation();
|
|
// Exit from scope when the iterator is used in depend clause.
|
|
if (HasIterator)
|
|
ExitScope();
|
|
return (Kind != OMPC_depend && Kind != OMPC_map && Vars.empty()) ||
|
|
(MustHaveTail && !Data.DepModOrTailExpr) || InvalidReductionId ||
|
|
IsInvalidMapperModifier;
|
|
}
|
|
|
|
/// Parsing of OpenMP clause 'private', 'firstprivate', 'lastprivate',
|
|
/// 'shared', 'copyin', 'copyprivate', 'flush', 'reduction', 'task_reduction',
|
|
/// 'in_reduction', 'nontemporal', 'exclusive' or 'inclusive'.
|
|
///
|
|
/// private-clause:
|
|
/// 'private' '(' list ')'
|
|
/// firstprivate-clause:
|
|
/// 'firstprivate' '(' list ')'
|
|
/// lastprivate-clause:
|
|
/// 'lastprivate' '(' list ')'
|
|
/// shared-clause:
|
|
/// 'shared' '(' list ')'
|
|
/// linear-clause:
|
|
/// 'linear' '(' linear-list [ ':' linear-step ] ')'
|
|
/// aligned-clause:
|
|
/// 'aligned' '(' list [ ':' alignment ] ')'
|
|
/// reduction-clause:
|
|
/// 'reduction' '(' [ modifier ',' ] reduction-identifier ':' list ')'
|
|
/// task_reduction-clause:
|
|
/// 'task_reduction' '(' reduction-identifier ':' list ')'
|
|
/// in_reduction-clause:
|
|
/// 'in_reduction' '(' reduction-identifier ':' list ')'
|
|
/// copyprivate-clause:
|
|
/// 'copyprivate' '(' list ')'
|
|
/// flush-clause:
|
|
/// 'flush' '(' list ')'
|
|
/// depend-clause:
|
|
/// 'depend' '(' in | out | inout : list | source ')'
|
|
/// map-clause:
|
|
/// 'map' '(' [ [ always [,] ] [ close [,] ]
|
|
/// [ mapper '(' mapper-identifier ')' [,] ]
|
|
/// to | from | tofrom | alloc | release | delete ':' ] list ')';
|
|
/// to-clause:
|
|
/// 'to' '(' [ mapper '(' mapper-identifier ')' ':' ] list ')'
|
|
/// from-clause:
|
|
/// 'from' '(' [ mapper '(' mapper-identifier ')' ':' ] list ')'
|
|
/// use_device_ptr-clause:
|
|
/// 'use_device_ptr' '(' list ')'
|
|
/// use_device_addr-clause:
|
|
/// 'use_device_addr' '(' list ')'
|
|
/// is_device_ptr-clause:
|
|
/// 'is_device_ptr' '(' list ')'
|
|
/// allocate-clause:
|
|
/// 'allocate' '(' [ allocator ':' ] list ')'
|
|
/// nontemporal-clause:
|
|
/// 'nontemporal' '(' list ')'
|
|
/// inclusive-clause:
|
|
/// 'inclusive' '(' list ')'
|
|
/// exclusive-clause:
|
|
/// 'exclusive' '(' list ')'
|
|
///
|
|
/// For 'linear' clause linear-list may have the following forms:
|
|
/// list
|
|
/// modifier(list)
|
|
/// where modifier is 'val' (C) or 'ref', 'val' or 'uval'(C++).
|
|
OMPClause *Parser::ParseOpenMPVarListClause(OpenMPDirectiveKind DKind,
|
|
OpenMPClauseKind Kind,
|
|
bool ParseOnly) {
|
|
SourceLocation Loc = Tok.getLocation();
|
|
SourceLocation LOpen = ConsumeToken();
|
|
SmallVector<Expr *, 4> Vars;
|
|
OpenMPVarListDataTy Data;
|
|
|
|
if (ParseOpenMPVarList(DKind, Kind, Vars, Data))
|
|
return nullptr;
|
|
|
|
if (ParseOnly)
|
|
return nullptr;
|
|
OMPVarListLocTy Locs(Loc, LOpen, Data.RLoc);
|
|
return Actions.ActOnOpenMPVarListClause(
|
|
Kind, Vars, Data.DepModOrTailExpr, Locs, Data.ColonLoc,
|
|
Data.ReductionOrMapperIdScopeSpec, Data.ReductionOrMapperId,
|
|
Data.ExtraModifier, Data.MapTypeModifiers, Data.MapTypeModifiersLoc,
|
|
Data.IsMapTypeImplicit, Data.ExtraModifierLoc, Data.MotionModifiers,
|
|
Data.MotionModifiersLoc);
|
|
}
|