[OpenMP] Initial parsing and sema support for 'masked taskloop simd' construct
This patch gives basic parsing and semantic support for "masked taskloop simd" construct introduced in OpenMP 5.1 (section 2.16.8) Differential Revision: https://reviews.llvm.org/D128693
This commit is contained in:
Fazlay Rabbi
Mike Rice
parent
178674e23a
commit
73e5d7bdff
@ -2625,16 +2625,20 @@ enum CXCursorKind {
|
||||
/** OpenMP target parallel loop directive.
|
||||
*/
|
||||
CXCursor_OMPTargetParallelGenericLoopDirective = 299,
|
||||
|
||||
|
||||
/** OpenMP parallel masked directive.
|
||||
*/
|
||||
CXCursor_OMPParallelMaskedDirective = 300,
|
||||
|
||||
|
||||
/** OpenMP masked taskloop directive.
|
||||
*/
|
||||
CXCursor_OMPMaskedTaskLoopDirective = 301,
|
||||
|
||||
CXCursor_LastStmt = CXCursor_OMPMaskedTaskLoopDirective,
|
||||
/** OpenMP masked taskloop simd directive.
|
||||
*/
|
||||
CXCursor_OMPMaskedTaskLoopSimdDirective = 302,
|
||||
|
||||
CXCursor_LastStmt = CXCursor_OMPMaskedTaskLoopSimdDirective,
|
||||
|
||||
/**
|
||||
* Cursor that represents the translation unit itself.
|
||||
|
||||
@ -3081,6 +3081,9 @@ DEF_TRAVERSE_STMT(OMPParallelMasterTaskLoopSimdDirective,
|
||||
DEF_TRAVERSE_STMT(OMPMaskedTaskLoopDirective,
|
||||
{ TRY_TO(TraverseOMPExecutableDirective(S)); })
|
||||
|
||||
DEF_TRAVERSE_STMT(OMPMaskedTaskLoopSimdDirective,
|
||||
{ TRY_TO(TraverseOMPExecutableDirective(S)); })
|
||||
|
||||
DEF_TRAVERSE_STMT(OMPDistributeDirective,
|
||||
{ TRY_TO(TraverseOMPExecutableDirective(S)); })
|
||||
|
||||
|
||||
@ -1524,6 +1524,7 @@ public:
|
||||
T->getStmtClass() == OMPTaskLoopDirectiveClass ||
|
||||
T->getStmtClass() == OMPTaskLoopSimdDirectiveClass ||
|
||||
T->getStmtClass() == OMPMaskedTaskLoopDirectiveClass ||
|
||||
T->getStmtClass() == OMPMaskedTaskLoopSimdDirectiveClass ||
|
||||
T->getStmtClass() == OMPMasterTaskLoopDirectiveClass ||
|
||||
T->getStmtClass() == OMPMasterTaskLoopSimdDirectiveClass ||
|
||||
T->getStmtClass() == OMPGenericLoopDirectiveClass ||
|
||||
@ -4000,6 +4001,71 @@ public:
|
||||
}
|
||||
};
|
||||
|
||||
/// This represents '#pragma omp masked taskloop simd' directive.
|
||||
///
|
||||
/// \code
|
||||
/// #pragma omp masked taskloop simd private(a,b) grainsize(val) num_tasks(num)
|
||||
/// \endcode
|
||||
/// In this example directive '#pragma omp masked taskloop simd' has clauses
|
||||
/// 'private' with the variables 'a' and 'b', 'grainsize' with expression 'val'
|
||||
/// and 'num_tasks' with expression 'num'.
|
||||
///
|
||||
class OMPMaskedTaskLoopSimdDirective final : public OMPLoopDirective {
|
||||
friend class ASTStmtReader;
|
||||
friend class OMPExecutableDirective;
|
||||
/// Build directive with the given start and end location.
|
||||
///
|
||||
/// \param StartLoc Starting location of the directive kind.
|
||||
/// \param EndLoc Ending location of the directive.
|
||||
/// \param CollapsedNum Number of collapsed nested loops.
|
||||
///
|
||||
OMPMaskedTaskLoopSimdDirective(SourceLocation StartLoc, SourceLocation EndLoc,
|
||||
unsigned CollapsedNum)
|
||||
: OMPLoopDirective(OMPMaskedTaskLoopSimdDirectiveClass,
|
||||
llvm::omp::OMPD_masked_taskloop_simd, StartLoc, EndLoc,
|
||||
CollapsedNum) {}
|
||||
|
||||
/// Build an empty directive.
|
||||
///
|
||||
/// \param CollapsedNum Number of collapsed nested loops.
|
||||
///
|
||||
explicit OMPMaskedTaskLoopSimdDirective(unsigned CollapsedNum)
|
||||
: OMPLoopDirective(OMPMaskedTaskLoopSimdDirectiveClass,
|
||||
llvm::omp::OMPD_masked_taskloop_simd, SourceLocation(),
|
||||
SourceLocation(), CollapsedNum) {}
|
||||
|
||||
public:
|
||||
/// Creates directive with a list of \p Clauses.
|
||||
///
|
||||
/// \param C AST context.
|
||||
/// \param StartLoc Starting location of the directive kind.
|
||||
/// \param EndLoc Ending Location of the directive.
|
||||
/// \param CollapsedNum Number of collapsed loops.
|
||||
/// \param Clauses List of clauses.
|
||||
/// \param AssociatedStmt Statement, associated with the directive.
|
||||
/// \param Exprs Helper expressions for CodeGen.
|
||||
///
|
||||
static OMPMaskedTaskLoopSimdDirective *
|
||||
Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
|
||||
unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses,
|
||||
Stmt *AssociatedStmt, const HelperExprs &Exprs);
|
||||
|
||||
/// Creates an empty directive with the place for \p NumClauses clauses.
|
||||
///
|
||||
/// \param C AST context.
|
||||
/// \param CollapsedNum Number of collapsed nested loops.
|
||||
/// \param NumClauses Number of clauses.
|
||||
///
|
||||
static OMPMaskedTaskLoopSimdDirective *CreateEmpty(const ASTContext &C,
|
||||
unsigned NumClauses,
|
||||
unsigned CollapsedNum,
|
||||
EmptyShell);
|
||||
|
||||
static bool classof(const Stmt *T) {
|
||||
return T->getStmtClass() == OMPMaskedTaskLoopSimdDirectiveClass;
|
||||
}
|
||||
};
|
||||
|
||||
/// This represents '#pragma omp parallel master taskloop' directive.
|
||||
///
|
||||
/// \code
|
||||
|
||||
@ -265,6 +265,7 @@ def OMPMasterTaskLoopSimdDirective : StmtNode<OMPLoopDirective>;
|
||||
def OMPParallelMasterTaskLoopDirective : StmtNode<OMPLoopDirective>;
|
||||
def OMPParallelMasterTaskLoopSimdDirective : StmtNode<OMPLoopDirective>;
|
||||
def OMPMaskedTaskLoopDirective : StmtNode<OMPLoopDirective>;
|
||||
def OMPMaskedTaskLoopSimdDirective : StmtNode<OMPLoopDirective>;
|
||||
def OMPDistributeDirective : StmtNode<OMPLoopDirective>;
|
||||
def OMPDistributeParallelForDirective : StmtNode<OMPLoopDirective>;
|
||||
def OMPDistributeParallelForSimdDirective : StmtNode<OMPLoopDirective>;
|
||||
|
||||
@ -11116,6 +11116,11 @@ public:
|
||||
StmtResult ActOnOpenMPMaskedTaskLoopDirective(
|
||||
ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
|
||||
SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
|
||||
/// Called on well-formed '\#pragma omp masked taskloop simd' after parsing of
|
||||
/// the associated statement.
|
||||
StmtResult ActOnOpenMPMaskedTaskLoopSimdDirective(
|
||||
ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
|
||||
SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
|
||||
/// Called on well-formed '\#pragma omp distribute' after parsing
|
||||
/// of the associated statement.
|
||||
StmtResult
|
||||
|
||||
@ -1950,6 +1950,7 @@ enum StmtCode {
|
||||
STMT_OMP_PARALLEL_MASTER_TASKLOOP_DIRECTIVE,
|
||||
STMT_OMP_PARALLEL_MASTER_TASKLOOP_SIMD_DIRECTIVE,
|
||||
STMT_OMP_MASKED_TASKLOOP_DIRECTIVE,
|
||||
STMT_OMP_MASKED_TASKLOOP_SIMD_DIRECTIVE,
|
||||
STMT_OMP_DISTRIBUTE_DIRECTIVE,
|
||||
STMT_OMP_TARGET_UPDATE_DIRECTIVE,
|
||||
STMT_OMP_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE,
|
||||
|
||||
@ -1265,6 +1265,50 @@ OMPMasterTaskLoopSimdDirective::CreateEmpty(const ASTContext &C,
|
||||
numLoopChildren(CollapsedNum, OMPD_master_taskloop_simd), CollapsedNum);
|
||||
}
|
||||
|
||||
OMPMaskedTaskLoopSimdDirective *OMPMaskedTaskLoopSimdDirective::Create(
|
||||
const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
|
||||
unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
|
||||
const HelperExprs &Exprs) {
|
||||
auto *Dir = createDirective<OMPMaskedTaskLoopSimdDirective>(
|
||||
C, Clauses, AssociatedStmt,
|
||||
numLoopChildren(CollapsedNum, OMPD_masked_taskloop_simd), StartLoc,
|
||||
EndLoc, CollapsedNum);
|
||||
Dir->setIterationVariable(Exprs.IterationVarRef);
|
||||
Dir->setLastIteration(Exprs.LastIteration);
|
||||
Dir->setCalcLastIteration(Exprs.CalcLastIteration);
|
||||
Dir->setPreCond(Exprs.PreCond);
|
||||
Dir->setCond(Exprs.Cond);
|
||||
Dir->setInit(Exprs.Init);
|
||||
Dir->setInc(Exprs.Inc);
|
||||
Dir->setIsLastIterVariable(Exprs.IL);
|
||||
Dir->setLowerBoundVariable(Exprs.LB);
|
||||
Dir->setUpperBoundVariable(Exprs.UB);
|
||||
Dir->setStrideVariable(Exprs.ST);
|
||||
Dir->setEnsureUpperBound(Exprs.EUB);
|
||||
Dir->setNextLowerBound(Exprs.NLB);
|
||||
Dir->setNextUpperBound(Exprs.NUB);
|
||||
Dir->setNumIterations(Exprs.NumIterations);
|
||||
Dir->setCounters(Exprs.Counters);
|
||||
Dir->setPrivateCounters(Exprs.PrivateCounters);
|
||||
Dir->setInits(Exprs.Inits);
|
||||
Dir->setUpdates(Exprs.Updates);
|
||||
Dir->setFinals(Exprs.Finals);
|
||||
Dir->setDependentCounters(Exprs.DependentCounters);
|
||||
Dir->setDependentInits(Exprs.DependentInits);
|
||||
Dir->setFinalsConditions(Exprs.FinalsConditions);
|
||||
Dir->setPreInits(Exprs.PreInits);
|
||||
return Dir;
|
||||
}
|
||||
|
||||
OMPMaskedTaskLoopSimdDirective *
|
||||
OMPMaskedTaskLoopSimdDirective::CreateEmpty(const ASTContext &C,
|
||||
unsigned NumClauses,
|
||||
unsigned CollapsedNum, EmptyShell) {
|
||||
return createEmptyDirective<OMPMaskedTaskLoopSimdDirective>(
|
||||
C, NumClauses, /*HasAssociatedStmt=*/true,
|
||||
numLoopChildren(CollapsedNum, OMPD_masked_taskloop_simd), CollapsedNum);
|
||||
}
|
||||
|
||||
OMPParallelMasterTaskLoopDirective *OMPParallelMasterTaskLoopDirective::Create(
|
||||
const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
|
||||
unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
|
||||
|
||||
@ -892,6 +892,12 @@ void StmtPrinter::VisitOMPMasterTaskLoopSimdDirective(
|
||||
PrintOMPExecutableDirective(Node);
|
||||
}
|
||||
|
||||
void StmtPrinter::VisitOMPMaskedTaskLoopSimdDirective(
|
||||
OMPMaskedTaskLoopSimdDirective *Node) {
|
||||
Indent() << "#pragma omp masked taskloop simd";
|
||||
PrintOMPExecutableDirective(Node);
|
||||
}
|
||||
|
||||
void StmtPrinter::VisitOMPParallelMasterTaskLoopDirective(
|
||||
OMPParallelMasterTaskLoopDirective *Node) {
|
||||
Indent() << "#pragma omp parallel master taskloop";
|
||||
|
||||
@ -1105,6 +1105,11 @@ void StmtProfiler::VisitOMPMasterTaskLoopSimdDirective(
|
||||
VisitOMPLoopDirective(S);
|
||||
}
|
||||
|
||||
void StmtProfiler::VisitOMPMaskedTaskLoopSimdDirective(
|
||||
const OMPMaskedTaskLoopSimdDirective *S) {
|
||||
VisitOMPLoopDirective(S);
|
||||
}
|
||||
|
||||
void StmtProfiler::VisitOMPParallelMasterTaskLoopDirective(
|
||||
const OMPParallelMasterTaskLoopDirective *S) {
|
||||
VisitOMPLoopDirective(S);
|
||||
|
||||
@ -484,7 +484,7 @@ bool clang::isOpenMPLoopDirective(OpenMPDirectiveKind DKind) {
|
||||
DKind == OMPD_master_taskloop || DKind == OMPD_master_taskloop_simd ||
|
||||
DKind == OMPD_parallel_master_taskloop ||
|
||||
DKind == OMPD_parallel_master_taskloop_simd ||
|
||||
DKind == OMPD_masked_taskloop ||
|
||||
DKind == OMPD_masked_taskloop || DKind == OMPD_masked_taskloop_simd ||
|
||||
DKind == OMPD_distribute || DKind == OMPD_target_parallel_for ||
|
||||
DKind == OMPD_distribute_parallel_for ||
|
||||
DKind == OMPD_distribute_parallel_for_simd ||
|
||||
@ -522,7 +522,7 @@ bool clang::isOpenMPTaskLoopDirective(OpenMPDirectiveKind DKind) {
|
||||
return DKind == OMPD_taskloop || DKind == OMPD_taskloop_simd ||
|
||||
DKind == OMPD_master_taskloop || DKind == OMPD_master_taskloop_simd ||
|
||||
DKind == OMPD_parallel_master_taskloop ||
|
||||
DKind == OMPD_masked_taskloop ||
|
||||
DKind == OMPD_masked_taskloop || DKind == OMPD_masked_taskloop_simd ||
|
||||
DKind == OMPD_parallel_master_taskloop_simd;
|
||||
}
|
||||
|
||||
@ -580,6 +580,7 @@ bool clang::isOpenMPSimdDirective(OpenMPDirectiveKind DKind) {
|
||||
return DKind == OMPD_simd || DKind == OMPD_for_simd ||
|
||||
DKind == OMPD_parallel_for_simd || DKind == OMPD_taskloop_simd ||
|
||||
DKind == OMPD_master_taskloop_simd ||
|
||||
DKind == OMPD_masked_taskloop_simd ||
|
||||
DKind == OMPD_parallel_master_taskloop_simd ||
|
||||
DKind == OMPD_distribute_parallel_for_simd ||
|
||||
DKind == OMPD_distribute_simd || DKind == OMPD_target_simd ||
|
||||
@ -703,6 +704,7 @@ void clang::getOpenMPCaptureRegions(
|
||||
case OMPD_master_taskloop:
|
||||
case OMPD_master_taskloop_simd:
|
||||
case OMPD_masked_taskloop:
|
||||
case OMPD_masked_taskloop_simd:
|
||||
CaptureRegions.push_back(OMPD_taskloop);
|
||||
break;
|
||||
case OMPD_parallel_master_taskloop:
|
||||
|
||||
@ -321,6 +321,9 @@ void CodeGenFunction::EmitStmt(const Stmt *S, ArrayRef<const Attr *> Attrs) {
|
||||
EmitOMPMasterTaskLoopSimdDirective(
|
||||
cast<OMPMasterTaskLoopSimdDirective>(*S));
|
||||
break;
|
||||
case Stmt::OMPMaskedTaskLoopSimdDirectiveClass:
|
||||
llvm_unreachable("masked taskloop simd directive not supported yet.");
|
||||
break;
|
||||
case Stmt::OMPParallelMasterTaskLoopDirectiveClass:
|
||||
EmitOMPParallelMasterTaskLoopDirective(
|
||||
cast<OMPParallelMasterTaskLoopDirective>(*S));
|
||||
|
||||
@ -180,6 +180,7 @@ static OpenMPDirectiveKindExWrapper parseOpenMPDirectiveKind(Parser &P) {
|
||||
{OMPD_master, OMPD_taskloop, OMPD_master_taskloop},
|
||||
{OMPD_masked, OMPD_taskloop, OMPD_masked_taskloop},
|
||||
{OMPD_master_taskloop, OMPD_simd, OMPD_master_taskloop_simd},
|
||||
{OMPD_masked_taskloop, OMPD_simd, OMPD_masked_taskloop_simd},
|
||||
{OMPD_parallel, OMPD_master, OMPD_parallel_master},
|
||||
{OMPD_parallel, OMPD_masked, OMPD_parallel_masked},
|
||||
{OMPD_parallel_master, OMPD_taskloop, OMPD_parallel_master_taskloop},
|
||||
@ -2387,6 +2388,7 @@ Parser::DeclGroupPtrTy Parser::ParseOpenMPDeclarativeDirectiveWithExtDecl(
|
||||
case OMPD_parallel_master_taskloop:
|
||||
case OMPD_parallel_master_taskloop_simd:
|
||||
case OMPD_masked_taskloop:
|
||||
case OMPD_masked_taskloop_simd:
|
||||
case OMPD_distribute:
|
||||
case OMPD_target_update:
|
||||
case OMPD_distribute_parallel_for:
|
||||
@ -2786,6 +2788,7 @@ StmtResult Parser::ParseOpenMPDeclarativeOrExecutableDirective(
|
||||
case OMPD_master_taskloop:
|
||||
case OMPD_masked_taskloop:
|
||||
case OMPD_master_taskloop_simd:
|
||||
case OMPD_masked_taskloop_simd:
|
||||
case OMPD_parallel_master_taskloop:
|
||||
case OMPD_parallel_master_taskloop_simd:
|
||||
case OMPD_distribute:
|
||||
|
||||
@ -1455,6 +1455,7 @@ CanThrowResult Sema::canThrow(const Stmt *S) {
|
||||
case Stmt::OMPMasterTaskLoopDirectiveClass:
|
||||
case Stmt::OMPMaskedTaskLoopDirectiveClass:
|
||||
case Stmt::OMPMasterTaskLoopSimdDirectiveClass:
|
||||
case Stmt::OMPMaskedTaskLoopSimdDirectiveClass:
|
||||
case Stmt::OMPOrderedDirectiveClass:
|
||||
case Stmt::OMPCanonicalLoopClass:
|
||||
case Stmt::OMPParallelDirectiveClass:
|
||||
|
||||
@ -4134,6 +4134,7 @@ void Sema::ActOnOpenMPRegionStart(OpenMPDirectiveKind DKind, Scope *CurScope) {
|
||||
case OMPD_taskloop_simd:
|
||||
case OMPD_master_taskloop:
|
||||
case OMPD_masked_taskloop:
|
||||
case OMPD_masked_taskloop_simd:
|
||||
case OMPD_master_taskloop_simd: {
|
||||
QualType KmpInt32Ty =
|
||||
Context.getIntTypeForBitwidth(/*DestWidth=*/32, /*Signed=*/1)
|
||||
@ -6261,6 +6262,14 @@ StmtResult Sema::ActOnOpenMPExecutableDirective(
|
||||
if (LangOpts.OpenMP >= 50)
|
||||
AllowedNameModifiers.push_back(OMPD_simd);
|
||||
break;
|
||||
case OMPD_masked_taskloop_simd:
|
||||
Res = ActOnOpenMPMaskedTaskLoopSimdDirective(
|
||||
ClausesWithImplicit, AStmt, StartLoc, EndLoc, VarsWithInheritedDSA);
|
||||
if (LangOpts.OpenMP >= 51) {
|
||||
AllowedNameModifiers.push_back(OMPD_taskloop);
|
||||
AllowedNameModifiers.push_back(OMPD_simd);
|
||||
}
|
||||
break;
|
||||
case OMPD_parallel_master_taskloop:
|
||||
Res = ActOnOpenMPParallelMasterTaskLoopDirective(
|
||||
ClausesWithImplicit, AStmt, StartLoc, EndLoc, VarsWithInheritedDSA);
|
||||
@ -13243,6 +13252,56 @@ StmtResult Sema::ActOnOpenMPMasterTaskLoopSimdDirective(
|
||||
Context, StartLoc, EndLoc, NestedLoopCount, Clauses, AStmt, B);
|
||||
}
|
||||
|
||||
StmtResult Sema::ActOnOpenMPMaskedTaskLoopSimdDirective(
|
||||
ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
|
||||
SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA) {
|
||||
if (!AStmt)
|
||||
return StmtError();
|
||||
|
||||
assert(isa<CapturedStmt>(AStmt) && "Captured statement expected");
|
||||
OMPLoopBasedDirective::HelperExprs B;
|
||||
// In presence of clause 'collapse' or 'ordered' with number of loops, it will
|
||||
// define the nested loops number.
|
||||
unsigned NestedLoopCount =
|
||||
checkOpenMPLoop(OMPD_masked_taskloop_simd, getCollapseNumberExpr(Clauses),
|
||||
/*OrderedLoopCountExpr=*/nullptr, AStmt, *this, *DSAStack,
|
||||
VarsWithImplicitDSA, B);
|
||||
if (NestedLoopCount == 0)
|
||||
return StmtError();
|
||||
|
||||
assert((CurContext->isDependentContext() || B.builtAll()) &&
|
||||
"omp for loop exprs were not built");
|
||||
|
||||
if (!CurContext->isDependentContext()) {
|
||||
// Finalize the clauses that need pre-built expressions for CodeGen.
|
||||
for (OMPClause *C : Clauses) {
|
||||
if (auto *LC = dyn_cast<OMPLinearClause>(C))
|
||||
if (FinishOpenMPLinearClause(*LC, cast<DeclRefExpr>(B.IterationVarRef),
|
||||
B.NumIterations, *this, CurScope,
|
||||
DSAStack))
|
||||
return StmtError();
|
||||
}
|
||||
}
|
||||
|
||||
// OpenMP, [2.9.2 taskloop Construct, Restrictions]
|
||||
// The grainsize clause and num_tasks clause are mutually exclusive and may
|
||||
// not appear on the same taskloop directive.
|
||||
if (checkMutuallyExclusiveClauses(*this, Clauses,
|
||||
{OMPC_grainsize, OMPC_num_tasks}))
|
||||
return StmtError();
|
||||
// OpenMP, [2.9.2 taskloop Construct, Restrictions]
|
||||
// If a reduction clause is present on the taskloop directive, the nogroup
|
||||
// clause must not be specified.
|
||||
if (checkReductionClauseWithNogroup(*this, Clauses))
|
||||
return StmtError();
|
||||
if (checkSimdlenSafelenSpecified(*this, Clauses))
|
||||
return StmtError();
|
||||
|
||||
setFunctionHasBranchProtectedScope();
|
||||
return OMPMaskedTaskLoopSimdDirective::Create(
|
||||
Context, StartLoc, EndLoc, NestedLoopCount, Clauses, AStmt, B);
|
||||
}
|
||||
|
||||
StmtResult Sema::ActOnOpenMPParallelMasterTaskLoopDirective(
|
||||
ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
|
||||
SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA) {
|
||||
@ -14875,6 +14934,7 @@ static OpenMPDirectiveKind getOpenMPCaptureRegionForClause(
|
||||
break;
|
||||
case OMPD_taskloop_simd:
|
||||
case OMPD_master_taskloop_simd:
|
||||
case OMPD_masked_taskloop_simd:
|
||||
if (OpenMPVersion <= 45)
|
||||
break;
|
||||
if (NameModifier == OMPD_unknown || NameModifier == OMPD_simd)
|
||||
@ -15004,6 +15064,7 @@ static OpenMPDirectiveKind getOpenMPCaptureRegionForClause(
|
||||
case OMPD_master_taskloop:
|
||||
case OMPD_masked_taskloop:
|
||||
case OMPD_master_taskloop_simd:
|
||||
case OMPD_masked_taskloop_simd:
|
||||
case OMPD_threadprivate:
|
||||
case OMPD_allocate:
|
||||
case OMPD_taskyield:
|
||||
@ -15077,6 +15138,7 @@ static OpenMPDirectiveKind getOpenMPCaptureRegionForClause(
|
||||
case OMPD_master_taskloop:
|
||||
case OMPD_masked_taskloop:
|
||||
case OMPD_master_taskloop_simd:
|
||||
case OMPD_masked_taskloop_simd:
|
||||
case OMPD_parallel_master_taskloop:
|
||||
case OMPD_parallel_master_taskloop_simd:
|
||||
case OMPD_target_data:
|
||||
@ -15165,6 +15227,7 @@ static OpenMPDirectiveKind getOpenMPCaptureRegionForClause(
|
||||
case OMPD_master_taskloop:
|
||||
case OMPD_masked_taskloop:
|
||||
case OMPD_master_taskloop_simd:
|
||||
case OMPD_masked_taskloop_simd:
|
||||
case OMPD_parallel_master_taskloop:
|
||||
case OMPD_parallel_master_taskloop_simd:
|
||||
case OMPD_target_data:
|
||||
@ -15251,6 +15314,7 @@ static OpenMPDirectiveKind getOpenMPCaptureRegionForClause(
|
||||
case OMPD_master_taskloop:
|
||||
case OMPD_masked_taskloop:
|
||||
case OMPD_master_taskloop_simd:
|
||||
case OMPD_masked_taskloop_simd:
|
||||
case OMPD_parallel_master_taskloop:
|
||||
case OMPD_parallel_master_taskloop_simd:
|
||||
case OMPD_target_data:
|
||||
@ -15343,6 +15407,7 @@ static OpenMPDirectiveKind getOpenMPCaptureRegionForClause(
|
||||
case OMPD_master_taskloop:
|
||||
case OMPD_masked_taskloop:
|
||||
case OMPD_master_taskloop_simd:
|
||||
case OMPD_masked_taskloop_simd:
|
||||
case OMPD_parallel_master_taskloop:
|
||||
case OMPD_parallel_master_taskloop_simd:
|
||||
case OMPD_target_data:
|
||||
@ -15440,6 +15505,7 @@ static OpenMPDirectiveKind getOpenMPCaptureRegionForClause(
|
||||
case OMPD_master_taskloop:
|
||||
case OMPD_masked_taskloop:
|
||||
case OMPD_master_taskloop_simd:
|
||||
case OMPD_masked_taskloop_simd:
|
||||
case OMPD_parallel_master_taskloop:
|
||||
case OMPD_parallel_master_taskloop_simd:
|
||||
case OMPD_cancel:
|
||||
@ -15504,6 +15570,7 @@ static OpenMPDirectiveKind getOpenMPCaptureRegionForClause(
|
||||
case OMPD_master_taskloop:
|
||||
case OMPD_masked_taskloop:
|
||||
case OMPD_master_taskloop_simd:
|
||||
case OMPD_masked_taskloop_simd:
|
||||
break;
|
||||
case OMPD_parallel_master_taskloop:
|
||||
case OMPD_parallel_master_taskloop_simd:
|
||||
|
||||
@ -9069,6 +9069,17 @@ StmtResult TreeTransform<Derived>::TransformOMPMasterTaskLoopSimdDirective(
|
||||
return Res;
|
||||
}
|
||||
|
||||
template <typename Derived>
|
||||
StmtResult TreeTransform<Derived>::TransformOMPMaskedTaskLoopSimdDirective(
|
||||
OMPMaskedTaskLoopSimdDirective *D) {
|
||||
DeclarationNameInfo DirName;
|
||||
getDerived().getSema().StartOpenMPDSABlock(OMPD_masked_taskloop_simd, DirName,
|
||||
nullptr, D->getBeginLoc());
|
||||
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
|
||||
getDerived().getSema().EndOpenMPDSABlock(Res.get());
|
||||
return Res;
|
||||
}
|
||||
|
||||
template <typename Derived>
|
||||
StmtResult TreeTransform<Derived>::TransformOMPParallelMasterTaskLoopDirective(
|
||||
OMPParallelMasterTaskLoopDirective *D) {
|
||||
|
||||
@ -2519,6 +2519,11 @@ void ASTStmtReader::VisitOMPMasterTaskLoopSimdDirective(
|
||||
VisitOMPLoopDirective(D);
|
||||
}
|
||||
|
||||
void ASTStmtReader::VisitOMPMaskedTaskLoopSimdDirective(
|
||||
OMPMaskedTaskLoopSimdDirective *D) {
|
||||
VisitOMPLoopDirective(D);
|
||||
}
|
||||
|
||||
void ASTStmtReader::VisitOMPParallelMasterTaskLoopDirective(
|
||||
OMPParallelMasterTaskLoopDirective *D) {
|
||||
VisitOMPLoopDirective(D);
|
||||
@ -3462,6 +3467,14 @@ Stmt *ASTReader::ReadStmtFromStream(ModuleFile &F) {
|
||||
break;
|
||||
}
|
||||
|
||||
case STMT_OMP_MASKED_TASKLOOP_SIMD_DIRECTIVE: {
|
||||
unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
|
||||
unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
|
||||
S = OMPMaskedTaskLoopSimdDirective::CreateEmpty(Context, NumClauses,
|
||||
CollapsedNum, Empty);
|
||||
break;
|
||||
}
|
||||
|
||||
case STMT_OMP_PARALLEL_MASTER_TASKLOOP_DIRECTIVE: {
|
||||
unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
|
||||
unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
|
||||
|
||||
@ -2471,6 +2471,12 @@ void ASTStmtWriter::VisitOMPMasterTaskLoopSimdDirective(
|
||||
Code = serialization::STMT_OMP_MASTER_TASKLOOP_SIMD_DIRECTIVE;
|
||||
}
|
||||
|
||||
void ASTStmtWriter::VisitOMPMaskedTaskLoopSimdDirective(
|
||||
OMPMaskedTaskLoopSimdDirective *D) {
|
||||
VisitOMPLoopDirective(D);
|
||||
Code = serialization::STMT_OMP_MASKED_TASKLOOP_SIMD_DIRECTIVE;
|
||||
}
|
||||
|
||||
void ASTStmtWriter::VisitOMPParallelMasterTaskLoopDirective(
|
||||
OMPParallelMasterTaskLoopDirective *D) {
|
||||
VisitOMPLoopDirective(D);
|
||||
|
||||
@ -1264,6 +1264,7 @@ void ExprEngine::Visit(const Stmt *S, ExplodedNode *Pred,
|
||||
case Stmt::OMPMasterTaskLoopDirectiveClass:
|
||||
case Stmt::OMPMaskedTaskLoopDirectiveClass:
|
||||
case Stmt::OMPMasterTaskLoopSimdDirectiveClass:
|
||||
case Stmt::OMPMaskedTaskLoopSimdDirectiveClass:
|
||||
case Stmt::OMPParallelMasterTaskLoopDirectiveClass:
|
||||
case Stmt::OMPParallelMasterTaskLoopSimdDirectiveClass:
|
||||
case Stmt::OMPDistributeDirectiveClass:
|
||||
|
||||
@ -739,6 +739,33 @@ void tls(int argc) {
|
||||
argc = x;
|
||||
}
|
||||
|
||||
// CHECK-LABEL: void maskedtaskloopsimd(int argc)
|
||||
void maskedtaskloopsimd(int argc) {
|
||||
int x, cond, fp, rd, lin, step, map;
|
||||
// CHECK-DAG: [B3]
|
||||
// CHECK-DAG: [[#MTLSB:]]: x
|
||||
// CHECK-DAG: [[#MTLSB+1]]: [B3.[[#MTLSB]]] (ImplicitCastExpr, LValueToRValue, int)
|
||||
// CHECK-DAG: [[#MTLSB+2]]: argc
|
||||
// CHECK-DAG: [[#MTLSB+3]]: [B3.[[#MTLSB+2]]] = [B3.[[#MTLSB+1]]]
|
||||
// CHECK-DAG: [B1]
|
||||
// CHECK-DAG: [[#MTLS:]]: cond
|
||||
// CHECK-DAG: [[#MTLS+1]]: [B1.[[#MTLS]]] (ImplicitCastExpr, LValueToRValue, int)
|
||||
// CHECK-DAG: [[#MTLS+2]]: [B1.[[#MTLS+1]]] (ImplicitCastExpr, IntegralToBoolean, _Bool)
|
||||
// CHECK-DAG: [[#MTLS+3]]: fp
|
||||
// CHECK-DAG: [[#MTLS+4]]: rd
|
||||
// CHECK-DAG: [[#MTLS+5]]: lin
|
||||
// CHECK-DAG: [[#MTLS+6]]: step
|
||||
// CHECK-DAG: [[#MTLS+7]]: [B1.[[#MTLS+6]]] (ImplicitCastExpr, LValueToRValue, int)
|
||||
// CHECK-DAG: [[#MTLS+8]]: [B3.[[#MTLSB+2]]]
|
||||
// CHECK-DAG: [[#MTLS+9]]: [B3.[[#MTLSB]]]
|
||||
// CHECK-DAG: [[#MTLS+10]]: #pragma omp masked taskloop simd if(cond) firstprivate(fp) reduction(+: rd) linear(lin: step)
|
||||
// CHECK-DAG: for (int i = 0;
|
||||
// CHECK-DAG: [B3.[[#MTLSB+3]]];
|
||||
#pragma omp masked taskloop simd if(cond) firstprivate(fp) reduction(+:rd) linear(lin: step)
|
||||
for (int i = 0; i < 10; ++i)
|
||||
argc = x;
|
||||
}
|
||||
|
||||
// CHECK-LABEL: void tdpf(int argc)
|
||||
void tdpf(int argc) {
|
||||
int x, cond, fp, rd, lin, step, map;
|
||||
|
||||
206
clang/test/OpenMP/masked_taskloop_simd_aligned_messages.cpp
Normal file
206
clang/test/OpenMP/masked_taskloop_simd_aligned_messages.cpp
Normal file
@ -0,0 +1,206 @@
|
||||
// RUN: %clang_cc1 -x c++ -std=c++11 -verify -fopenmp %s -Wuninitialized
|
||||
|
||||
// RUN: %clang_cc1 -x c++ -std=c++11 -verify -fopenmp-simd %s -Wuninitialized
|
||||
|
||||
struct B {
|
||||
static int ib[20]; // expected-note 0 {{'B::ib' declared here}}
|
||||
static constexpr int bfoo() { return 8; }
|
||||
};
|
||||
namespace X {
|
||||
B x; // expected-note {{'x' defined here}}
|
||||
};
|
||||
constexpr int bfoo() { return 4; }
|
||||
|
||||
int **z;
|
||||
const int C1 = 1;
|
||||
const int C2 = 2;
|
||||
void test_aligned_colons(int *&rp)
|
||||
{
|
||||
int *B = 0;
|
||||
#pragma omp masked taskloop simd aligned(B:bfoo())
|
||||
for (int i = 0; i < 10; ++i) ;
|
||||
// expected-error@+1 {{unexpected ':' in nested name specifier; did you mean '::'}}
|
||||
#pragma omp masked taskloop simd aligned(B::ib:B:bfoo())
|
||||
for (int i = 0; i < 10; ++i) ;
|
||||
#pragma omp masked taskloop simd aligned(B:B::bfoo())
|
||||
for (int i = 0; i < 10; ++i) ;
|
||||
// expected-error@+1 {{unexpected ':' in nested name specifier; did you mean '::'?}}
|
||||
#pragma omp masked taskloop simd aligned(z:B:bfoo())
|
||||
for (int i = 0; i < 10; ++i) ;
|
||||
#pragma omp masked taskloop simd aligned(B:B::bfoo())
|
||||
for (int i = 0; i < 10; ++i) ;
|
||||
// expected-error@+2 {{integral constant expression must have integral or unscoped enumeration type, not 'int **'}}
|
||||
// expected-error@+1 {{argument of aligned clause should be array, pointer, reference to array or reference to pointer, not 'B'}}
|
||||
#pragma omp masked taskloop simd aligned(X::x : ::z)
|
||||
for (int i = 0; i < 10; ++i) ;
|
||||
// expected-error@+1 {{integral constant expression must have integral or unscoped enumeration type, not 'B'}}
|
||||
#pragma omp masked taskloop simd aligned(B,rp,::z: X::x)
|
||||
for (int i = 0; i < 10; ++i) ;
|
||||
#pragma omp masked taskloop simd aligned(::z)
|
||||
for (int i = 0; i < 10; ++i) ;
|
||||
// expected-error@+1 {{expected variable name}}
|
||||
#pragma omp masked taskloop simd aligned(B::bfoo())
|
||||
for (int i = 0; i < 10; ++i) ;
|
||||
// expected-warning@+1 {{aligned clause will be ignored because the requested alignment is not a power of 2}}
|
||||
#pragma omp masked taskloop simd aligned(B::ib,B:C1+C2)
|
||||
for (int i = 0; i < 10; ++i) ;
|
||||
}
|
||||
|
||||
// expected-note@+1 {{'num' defined here}}
|
||||
template<int L, class T, class N> T test_template(T* arr, N num) {
|
||||
N i;
|
||||
T sum = (T)0;
|
||||
T ind2 = - num * L;
|
||||
// Negative number is passed as L.
|
||||
// expected-error@+1 {{argument to 'aligned' clause must be a strictly positive integer value}}
|
||||
#pragma omp masked taskloop simd aligned(arr:L)
|
||||
for (i = 0; i < num; ++i) {
|
||||
T cur = arr[(int)ind2];
|
||||
ind2 += L;
|
||||
sum += cur;
|
||||
}
|
||||
// expected-error@+1 {{argument of aligned clause should be array, pointer, reference to array or reference to pointer, not 'int'}}
|
||||
#pragma omp masked taskloop simd aligned(num:4)
|
||||
for (i = 0; i < num; ++i);
|
||||
return T();
|
||||
}
|
||||
|
||||
template<int LEN> int test_warn() {
|
||||
int *ind2 = 0;
|
||||
// expected-error@+1 {{argument to 'aligned' clause must be a strictly positive integer value}}
|
||||
#pragma omp masked taskloop simd aligned(ind2:LEN)
|
||||
for (int i = 0; i < 100; i++) {
|
||||
ind2 += LEN;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
struct S1; // expected-note 2 {{declared here}}
|
||||
extern S1 a; // expected-note {{'a' declared here}}
|
||||
class S2 {
|
||||
mutable int a;
|
||||
public:
|
||||
S2():a(0) { }
|
||||
};
|
||||
const S2 b; // expected-note 1 {{'b' defined here}}
|
||||
const S2 ba[5];
|
||||
class S3 {
|
||||
int a;
|
||||
public:
|
||||
S3():a(0) { }
|
||||
};
|
||||
const S3 ca[5];
|
||||
class S4 {
|
||||
int a;
|
||||
S4();
|
||||
public:
|
||||
S4(int v):a(v) { }
|
||||
};
|
||||
class S5 {
|
||||
int a;
|
||||
S5():a(0) {}
|
||||
public:
|
||||
S5(int v):a(v) { }
|
||||
};
|
||||
|
||||
S3 h; // expected-note 2 {{'h' defined here}}
|
||||
#pragma omp threadprivate(h)
|
||||
|
||||
template<class I, class C> int foomain(I argc, C **argv) {
|
||||
I e(argc);
|
||||
I g(argc);
|
||||
int i; // expected-note {{'i' defined here}}
|
||||
// expected-note@+1 {{declared here}}
|
||||
int &j = i;
|
||||
#pragma omp masked taskloop simd aligned // expected-error {{expected '(' after 'aligned'}}
|
||||
for (I k = 0; k < argc; ++k) ++k;
|
||||
#pragma omp masked taskloop simd aligned ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (I k = 0; k < argc; ++k) ++k;
|
||||
#pragma omp masked taskloop simd aligned () // expected-error {{expected expression}}
|
||||
for (I k = 0; k < argc; ++k) ++k;
|
||||
#pragma omp masked taskloop simd aligned (argc // expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (I k = 0; k < argc; ++k) ++k;
|
||||
#pragma omp masked taskloop simd aligned (argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (I k = 0; k < argc; ++k) ++k;
|
||||
// FIXME: Should argc really be a pointer?
|
||||
#pragma omp masked taskloop simd aligned (*argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}}
|
||||
for (I k = 0; k < argc; ++k) ++k;
|
||||
#pragma omp masked taskloop simd aligned (argc : 5) // expected-warning {{aligned clause will be ignored because the requested alignment is not a power of 2}}
|
||||
for (I k = 0; k < argc; ++k) ++k;
|
||||
#pragma omp masked taskloop simd aligned (S1) // expected-error {{'S1' does not refer to a value}}
|
||||
for (I k = 0; k < argc; ++k) ++k;
|
||||
#pragma omp masked taskloop simd aligned (argv[1]) // expected-error {{expected variable name}}
|
||||
for (I k = 0; k < argc; ++k) ++k;
|
||||
#pragma omp masked taskloop simd aligned(e, g)
|
||||
for (I k = 0; k < argc; ++k) ++k;
|
||||
// expected-error@+1 {{argument of aligned clause should be array, pointer, reference to array or reference to pointer, not 'S3'}}
|
||||
#pragma omp masked taskloop simd aligned(h)
|
||||
for (I k = 0; k < argc; ++k) ++k;
|
||||
// expected-error@+1 {{argument of aligned clause should be array, pointer, reference to array or reference to pointer, not 'int'}}
|
||||
#pragma omp masked taskloop simd aligned(i)
|
||||
for (I k = 0; k < argc; ++k) ++k;
|
||||
#pragma omp parallel
|
||||
{
|
||||
int *v = 0;
|
||||
I i;
|
||||
#pragma omp masked taskloop simd aligned(v:16)
|
||||
for (I k = 0; k < argc; ++k) { i = k; v += 2; }
|
||||
}
|
||||
float *f;
|
||||
#pragma omp masked taskloop simd aligned(f)
|
||||
for (I k = 0; k < argc; ++k) ++k;
|
||||
int v = 0;
|
||||
// expected-note@+2 {{initializer of 'j' is not a constant expression}}
|
||||
// expected-error@+1 {{integral constant expression}}
|
||||
#pragma omp masked taskloop simd aligned(f:j)
|
||||
for (I k = 0; k < argc; ++k) { ++k; v += j; }
|
||||
#pragma omp masked taskloop simd aligned(f)
|
||||
for (I k = 0; k < argc; ++k) ++k;
|
||||
return 0;
|
||||
}
|
||||
|
||||
// expected-note@+1 2 {{'argc' defined here}}
|
||||
int main(int argc, char **argv) {
|
||||
double darr[100];
|
||||
// expected-note@+1 {{in instantiation of function template specialization 'test_template<-4, double, int>' requested here}}
|
||||
test_template<-4>(darr, 4);
|
||||
test_warn<4>(); // ok
|
||||
// expected-note@+1 {{in instantiation of function template specialization 'test_warn<0>' requested here}}
|
||||
test_warn<0>();
|
||||
|
||||
int i;
|
||||
int &j = i;
|
||||
int tid = 0;
|
||||
#pragma omp masked taskloop simd aligned filter(tid) // expected-error {{expected '(' after 'aligned'}}
|
||||
for (int k = 0; k < argc; ++k) ++k;
|
||||
#pragma omp masked taskloop simd aligned ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int k = 0; k < argc; ++k) ++k;
|
||||
#pragma omp masked taskloop simd aligned () // expected-error {{expected expression}}
|
||||
for (int k = 0; k < argc; ++k) ++k;
|
||||
#pragma omp masked taskloop simd aligned (argv // expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int k = 0; k < argc; ++k) ++k;
|
||||
// expected-error@+1 {{argument of aligned clause should be array, pointer, reference to array or reference to pointer, not 'int'}}
|
||||
#pragma omp masked taskloop simd aligned (argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int k = 0; k < argc; ++k) ++k;
|
||||
#pragma omp masked taskloop simd aligned (argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}}
|
||||
for (int k = 0; k < argc; ++k) ++k;
|
||||
// expected-error@+1 {{argument of aligned clause should be array, pointer, reference to array or reference to pointer, not 'int'}}
|
||||
#pragma omp masked taskloop simd aligned (argc)
|
||||
for (int k = 0; k < argc; ++k) ++k;
|
||||
#pragma omp masked taskloop simd aligned (S1) // expected-error {{'S1' does not refer to a value}}
|
||||
for (int k = 0; k < argc; ++k) ++k;
|
||||
// expected-error@+2 {{argument of aligned clause should be array, pointer, reference to array or reference to pointer, not 'S1'}}
|
||||
// expected-error@+1 {{argument of aligned clause should be array, pointer, reference to array or reference to pointer, not 'S2'}}
|
||||
#pragma omp masked taskloop simd aligned(a, b)
|
||||
for (int k = 0; k < argc; ++k) ++k;
|
||||
#pragma omp masked taskloop simd aligned (argv[1]) // expected-error {{expected variable name}}
|
||||
for (int k = 0; k < argc; ++k) ++k;
|
||||
// expected-error@+1 {{argument of aligned clause should be array, pointer, reference to array or reference to pointer, not 'S3'}}
|
||||
#pragma omp masked taskloop simd aligned(h)
|
||||
for (int k = 0; k < argc; ++k) ++k;
|
||||
int *pargc = &argc;
|
||||
// expected-note@+1 {{in instantiation of function template specialization 'foomain<int *, char>' requested here}}
|
||||
foomain<int*,char>(pargc,argv);
|
||||
return 0;
|
||||
}
|
||||
|
||||
95
clang/test/OpenMP/masked_taskloop_simd_ast_print.cpp
Normal file
95
clang/test/OpenMP/masked_taskloop_simd_ast_print.cpp
Normal file
@ -0,0 +1,95 @@
|
||||
// RUN: %clang_cc1 -verify -fopenmp -fopenmp-version=51 -DOMP5 -ast-print %s | FileCheck %s --check-prefix CHECK --check-prefix OMP50
|
||||
// RUN: %clang_cc1 -fopenmp -fopenmp-version=51 -DOMP5 -x c++ -std=c++11 -emit-pch -o %t %s
|
||||
// RUN: %clang_cc1 -fopenmp -fopenmp-version=51 -DOMP5 -std=c++11 -include-pch %t -fsyntax-only -verify %s -ast-print | FileCheck %s --check-prefix CHECK --check-prefix OMP50
|
||||
// RUN: %clang_cc1 -verify -fopenmp -ast-print %s -DOMP5 | FileCheck %s --check-prefix CHECK --check-prefix OMP50
|
||||
// RUN: %clang_cc1 -fopenmp -x c++ -std=c++11 -emit-pch -o %t %s -DOMP5
|
||||
// RUN: %clang_cc1 -fopenmp -std=c++11 -include-pch %t -fsyntax-only -verify %s -ast-print -DOMP5 | FileCheck %s --check-prefix CHECK --check-prefix OMP50
|
||||
|
||||
// RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=51 -DOMP5 -ast-print %s | FileCheck %s --check-prefix CHECK --check-prefix OMP50
|
||||
// RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=51 -DOMP5 -x c++ -std=c++11 -emit-pch -o %t %s
|
||||
// RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=51 -DOMP5 -std=c++11 -include-pch %t -fsyntax-only -verify %s -ast-print | FileCheck %s --check-prefix CHECK --check-prefix OMP50
|
||||
// RUN: %clang_cc1 -verify -fopenmp-simd -ast-print %s -DOMP5 | FileCheck %s --check-prefix CHECK --check-prefix OMP50
|
||||
// RUN: %clang_cc1 -fopenmp-simd -x c++ -std=c++11 -emit-pch -o %t %s -DOMP5
|
||||
// RUN: %clang_cc1 -fopenmp-simd -std=c++11 -include-pch %t -fsyntax-only -verify %s -ast-print -DOMP5 | FileCheck %s --check-prefix CHECK --check-prefix OMP50
|
||||
// expected-no-diagnostics
|
||||
|
||||
#ifndef HEADER
|
||||
#define HEADER
|
||||
|
||||
void foo() {}
|
||||
|
||||
template <class T, int N>
|
||||
T tmain(T argc) {
|
||||
T b = argc, c, d, e, f, g;
|
||||
T *ptr;
|
||||
static T a;
|
||||
// CHECK: static T a;
|
||||
#pragma omp taskgroup task_reduction(+: d) allocate(d)
|
||||
#pragma omp masked taskloop simd allocate(d) if(taskloop: argc > N) default(shared) untied priority(N) safelen(N) linear(c) aligned(ptr) grainsize(N) reduction(+:g) in_reduction(+: d)
|
||||
// CHECK-NEXT: #pragma omp taskgroup task_reduction(+: d) allocate(d)
|
||||
// CHECK-NEXT: #pragma omp masked taskloop simd allocate(d) if(taskloop: argc > N) default(shared) untied priority(N) safelen(N) linear(c) aligned(ptr) grainsize(N) reduction(+: g) in_reduction(+: d){{$}}
|
||||
for (int i = 0; i < 2; ++i)
|
||||
a = 2;
|
||||
// CHECK-NEXT: for (int i = 0; i < 2; ++i)
|
||||
// CHECK-NEXT: a = 2;
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd private(argc, b), firstprivate(c, d), lastprivate(d, f) collapse(N) shared(g) if (c) final(d) mergeable priority(f) simdlen(N) nogroup num_tasks(N)
|
||||
for (int i = 0; i < 2; ++i)
|
||||
for (int j = 0; j < 2; ++j)
|
||||
for (int j = 0; j < 2; ++j)
|
||||
for (int j = 0; j < 2; ++j)
|
||||
for (int j = 0; j < 2; ++j)
|
||||
for (int i = 0; i < 2; ++i)
|
||||
for (int j = 0; j < 2; ++j)
|
||||
for (int j = 0; j < 2; ++j)
|
||||
for (int j = 0; j < 2; ++j)
|
||||
for (int j = 0; j < 2; ++j)
|
||||
foo();
|
||||
// CHECK-NEXT: #pragma omp parallel
|
||||
// CHECK-NEXT: #pragma omp masked taskloop simd private(argc,b) firstprivate(c,d) lastprivate(d,f) collapse(N) shared(g) if(c) final(d) mergeable priority(f) simdlen(N) nogroup num_tasks(N)
|
||||
// CHECK-NEXT: for (int i = 0; i < 2; ++i)
|
||||
// CHECK-NEXT: for (int j = 0; j < 2; ++j)
|
||||
// CHECK-NEXT: for (int j = 0; j < 2; ++j)
|
||||
// CHECK-NEXT: for (int j = 0; j < 2; ++j)
|
||||
// CHECK-NEXT: for (int j = 0; j < 2; ++j)
|
||||
// CHECK-NEXT: for (int i = 0; i < 2; ++i)
|
||||
// CHECK-NEXT: for (int j = 0; j < 2; ++j)
|
||||
// CHECK-NEXT: for (int j = 0; j < 2; ++j)
|
||||
// CHECK-NEXT: for (int j = 0; j < 2; ++j)
|
||||
// CHECK-NEXT: for (int j = 0; j < 2; ++j)
|
||||
// CHECK-NEXT: foo();
|
||||
return T();
|
||||
}
|
||||
|
||||
// CHECK-LABEL: int main(int argc, char **argv) {
|
||||
int main(int argc, char **argv) {
|
||||
int b = argc, c, d, e, f, g, h;
|
||||
int tid = 0;
|
||||
static int a;
|
||||
// CHECK: static int a;
|
||||
#pragma omp taskgroup task_reduction(+: d)
|
||||
#pragma omp masked taskloop simd if(taskloop: a) default(none) shared(a) final(b) priority(5) safelen(8) linear(b), aligned(argv) num_tasks(argc) reduction(*: g) in_reduction(+: d) filter(tid)
|
||||
// CHECK-NEXT: #pragma omp taskgroup task_reduction(+: d)
|
||||
// CHECK-NEXT: #pragma omp masked taskloop simd if(taskloop: a) default(none) shared(a) final(b) priority(5) safelen(8) linear(b) aligned(argv) num_tasks(argc) reduction(*: g) in_reduction(+: d) filter(tid)
|
||||
for (int i = 0; i < 2; ++i)
|
||||
a = 2;
|
||||
// CHECK-NEXT: for (int i = 0; i < 2; ++i)
|
||||
// CHECK-NEXT: a = 2;
|
||||
#pragma omp parallel
|
||||
#ifdef OMP5
|
||||
#pragma omp masked taskloop simd private(argc, b), firstprivate(argv, c), lastprivate(d, f) collapse(2) shared(g) if(simd:argc) mergeable priority(argc) simdlen(16) grainsize(argc) reduction(max: a, e) nontemporal(argc, c, d) order(concurrent) filter(tid)
|
||||
#else
|
||||
#pragma omp masked taskloop simd private(argc, b), firstprivate(argv, c), lastprivate(d, f) collapse(2) shared(g) if(argc) mergeable priority(argc) simdlen(16) grainsize(argc) reduction(max: a, e)
|
||||
#endif // OMP5
|
||||
for (int i = 0; i < 10; ++i)
|
||||
for (int j = 0; j < 10; ++j)
|
||||
foo();
|
||||
// CHECK-NEXT: #pragma omp parallel
|
||||
// OMP50-NEXT: #pragma omp masked taskloop simd private(argc,b) firstprivate(argv,c) lastprivate(d,f) collapse(2) shared(g) if(simd: argc) mergeable priority(argc) simdlen(16) grainsize(argc) reduction(max: a,e) nontemporal(argc,c,d) order(concurrent) filter(tid)
|
||||
// CHECK-NEXT: for (int i = 0; i < 10; ++i)
|
||||
// CHECK-NEXT: for (int j = 0; j < 10; ++j)
|
||||
// CHECK-NEXT: foo();
|
||||
return (tmain<int, 5>(argc) + tmain<char, 1>(argv[0][0]));
|
||||
}
|
||||
|
||||
#endif
|
||||
100
clang/test/OpenMP/masked_taskloop_simd_collapse_messages.cpp
Normal file
100
clang/test/OpenMP/masked_taskloop_simd_collapse_messages.cpp
Normal file
@ -0,0 +1,100 @@
|
||||
// RUN: %clang_cc1 -verify -fopenmp %s -Wuninitialized
|
||||
// RUN: %clang_cc1 -verify -fopenmp -std=c++98 %s -Wuninitialized
|
||||
// RUN: %clang_cc1 -verify -fopenmp -std=c++11 %s -Wuninitialized
|
||||
|
||||
// RUN: %clang_cc1 -verify -fopenmp-simd %s -Wuninitialized
|
||||
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++98 %s -Wuninitialized
|
||||
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++11 %s -Wuninitialized
|
||||
|
||||
// expected-note@* 0+{{declared here}}
|
||||
|
||||
void foo() {
|
||||
}
|
||||
|
||||
bool foobool(int argc) {
|
||||
return argc;
|
||||
}
|
||||
|
||||
struct S1;
|
||||
|
||||
template <class T, typename S, int N, int ST>
|
||||
T tmain(T argc, S **argv) {
|
||||
#pragma omp masked taskloop simd collapse // expected-error {{expected '(' after 'collapse'}}
|
||||
for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST];
|
||||
#pragma omp masked taskloop simd collapse ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST];
|
||||
#pragma omp masked taskloop simd collapse () // expected-error {{expected expression}}
|
||||
for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST];
|
||||
// expected-error@+2 {{expected ')'}} expected-note@+2 {{to match this '('}}
|
||||
// expected-error@+1 2 {{integral constant expression}} expected-note@+1 0+{{constant expression}}
|
||||
#pragma omp masked taskloop simd collapse (argc
|
||||
for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST];
|
||||
// expected-error@+1 2 {{argument to 'collapse' clause must be a strictly positive integer value}}
|
||||
#pragma omp masked taskloop simd collapse (ST // expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST];
|
||||
#pragma omp masked taskloop simd collapse (1)) // expected-warning {{extra tokens at the end of '#pragma omp masked taskloop simd' are ignored}}
|
||||
for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST];
|
||||
#pragma omp masked taskloop simd collapse ((ST > 0) ? 1 + ST : 2) // expected-note 2 {{as specified in 'collapse' clause}}
|
||||
for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST]; // expected-error 2 {{expected 2 for loops after '#pragma omp masked taskloop simd', but found only 1}}
|
||||
// expected-error@+3 2 {{directive '#pragma omp masked taskloop simd' cannot contain more than one 'collapse' clause}}
|
||||
// expected-error@+2 {{argument to 'collapse' clause must be a strictly positive integer value}}
|
||||
// expected-error@+1 2 {{integral constant expression}} expected-note@+1 0+{{constant expression}}
|
||||
#pragma omp masked taskloop simd collapse (foobool(argc)), collapse (true), collapse (-5)
|
||||
for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST];
|
||||
#pragma omp masked taskloop simd collapse (S) // expected-error {{'S' does not refer to a value}}
|
||||
for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST];
|
||||
#if __cplusplus <= 199711L
|
||||
// expected-error@+4 2 {{integral constant expression}} expected-note@+4 0+{{constant expression}}
|
||||
#else
|
||||
// expected-error@+2 2 {{integral constant expression must have integral or unscoped enumeration type, not 'char *'}}
|
||||
#endif
|
||||
#pragma omp masked taskloop simd collapse (argv[1]=2) // expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST];
|
||||
#pragma omp masked taskloop simd collapse (1)
|
||||
for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST];
|
||||
#pragma omp masked taskloop simd collapse (N) // expected-error {{argument to 'collapse' clause must be a strictly positive integer value}}
|
||||
for (T i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST];
|
||||
#pragma omp masked taskloop simd collapse (2) // expected-note {{as specified in 'collapse' clause}}
|
||||
foo(); // expected-error {{expected 2 for loops after '#pragma omp masked taskloop simd'}}
|
||||
return argc;
|
||||
}
|
||||
|
||||
int main(int argc, char **argv) {
|
||||
int tid = 0;
|
||||
#pragma omp masked taskloop simd collapse filter(tid) // expected-error {{expected '(' after 'collapse'}}
|
||||
for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4];
|
||||
#pragma omp masked taskloop simd collapse ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4];
|
||||
#pragma omp masked taskloop simd collapse () // expected-error {{expected expression}}
|
||||
for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4];
|
||||
#pragma omp masked taskloop simd collapse (4 // expected-error {{expected ')'}} expected-note {{to match this '('}} expected-note {{as specified in 'collapse' clause}}
|
||||
for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; // expected-error {{expected 4 for loops after '#pragma omp masked taskloop simd', but found only 1}}
|
||||
#pragma omp masked taskloop simd collapse (2+2)) // expected-warning {{extra tokens at the end of '#pragma omp masked taskloop simd' are ignored}} expected-note {{as specified in 'collapse' clause}}
|
||||
for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4]; // expected-error {{expected 4 for loops after '#pragma omp masked taskloop simd', but found only 1}}
|
||||
// expected-error@+1 {{integral constant expression}} expected-note@+1 0+{{constant expression}}
|
||||
#pragma omp masked taskloop simd collapse (foobool(1) > 0 ? 1 : 2)
|
||||
for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4];
|
||||
// expected-error@+3 {{integral constant expression}} expected-note@+3 0+{{constant expression}}
|
||||
// expected-error@+2 2 {{directive '#pragma omp masked taskloop simd' cannot contain more than one 'collapse' clause}}
|
||||
// expected-error@+1 {{argument to 'collapse' clause must be a strictly positive integer value}}
|
||||
#pragma omp masked taskloop simd collapse (foobool(argc)), collapse (true), collapse (-5)
|
||||
for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4];
|
||||
#pragma omp masked taskloop simd collapse (S1) // expected-error {{'S1' does not refer to a value}}
|
||||
for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4];
|
||||
#if __cplusplus <= 199711L
|
||||
// expected-error@+4 {{integral constant expression}} expected-note@+4 0+{{constant expression}}
|
||||
#else
|
||||
// expected-error@+2 {{integral constant expression must have integral or unscoped enumeration type, not 'char *'}}
|
||||
#endif
|
||||
#pragma omp masked taskloop simd collapse (argv[1]=2) // expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4];
|
||||
// expected-error@+3 {{statement after '#pragma omp masked taskloop simd' must be a for loop}}
|
||||
// expected-note@+1 {{in instantiation of function template specialization 'tmain<int, char, -1, -2>' requested here}}
|
||||
#pragma omp masked taskloop simd collapse(collapse(tmain<int, char, -1, -2>(argc, argv) // expected-error 2 {{expected ')'}} expected-note 2 {{to match this '('}}
|
||||
foo();
|
||||
#pragma omp masked taskloop simd collapse (2) // expected-note {{as specified in 'collapse' clause}}
|
||||
foo(); // expected-error {{expected 2 for loops after '#pragma omp masked taskloop simd'}}
|
||||
// expected-note@+1 {{in instantiation of function template specialization 'tmain<int, char, 1, 0>' requested here}}
|
||||
return tmain<int, char, 1, 0>(argc, argv);
|
||||
}
|
||||
|
||||
95
clang/test/OpenMP/masked_taskloop_simd_final_messages.cpp
Normal file
95
clang/test/OpenMP/masked_taskloop_simd_final_messages.cpp
Normal file
@ -0,0 +1,95 @@
|
||||
// RUN: %clang_cc1 -verify -fopenmp -ferror-limit 100 %s -Wuninitialized
|
||||
|
||||
// RUN: %clang_cc1 -verify -fopenmp-simd -ferror-limit 100 %s -Wuninitialized
|
||||
|
||||
void foo() {
|
||||
}
|
||||
|
||||
bool foobool(int argc) {
|
||||
return argc;
|
||||
}
|
||||
|
||||
struct S1; // expected-note {{declared here}}
|
||||
|
||||
template <class T, class S> // expected-note {{declared here}}
|
||||
int tmain(T argc, S **argv) {
|
||||
T z;
|
||||
#pragma omp masked taskloop simd final // expected-error {{expected '(' after 'final'}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd final( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd final() // expected-error {{expected expression}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd final(argc // expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd final(argc + z)) // expected-warning {{extra tokens at the end of '#pragma omp masked taskloop simd' are ignored}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd final(argc > 0 ? argv[1] : argv[2])
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd final(foobool(argc)), final(true) // expected-error {{directive '#pragma omp masked taskloop simd' cannot contain more than one 'final' clause}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd final(S) // expected-error {{'S' does not refer to a value}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd final(argv[1] = 2) // expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd final(argc argc) // expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd final(argc)
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int main(int argc, char **argv) {
|
||||
int z;
|
||||
int tid = 0;
|
||||
#pragma omp masked taskloop simd filter(tid) final // expected-error {{expected '(' after 'final'}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd final( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd final() // expected-error {{expected expression}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd final(argc // expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd final(z+argc)) // expected-warning {{extra tokens at the end of '#pragma omp masked taskloop simd' are ignored}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd final(argc > 0 ? argv[1] : argv[2])
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd final(foobool(argc)), final(true) // expected-error {{directive '#pragma omp masked taskloop simd' cannot contain more than one 'final' clause}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd final(S1) // expected-error {{'S1' does not refer to a value}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd final(argv[1] = 2) // expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd final(argc argc) // expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd final(1 0) // expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd final(if (tmain(argc, argv) // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
|
||||
return tmain(argc, argv);
|
||||
}
|
||||
337
clang/test/OpenMP/masked_taskloop_simd_firstprivate_messages.cpp
Normal file
337
clang/test/OpenMP/masked_taskloop_simd_firstprivate_messages.cpp
Normal file
@ -0,0 +1,337 @@
|
||||
// RUN: %clang_cc1 -verify -fopenmp %s -Wuninitialized
|
||||
|
||||
// RUN: %clang_cc1 -verify -fopenmp-simd %s -Wuninitialized
|
||||
|
||||
typedef void **omp_allocator_handle_t;
|
||||
extern const omp_allocator_handle_t omp_null_allocator;
|
||||
extern const omp_allocator_handle_t omp_default_mem_alloc;
|
||||
extern const omp_allocator_handle_t omp_large_cap_mem_alloc;
|
||||
extern const omp_allocator_handle_t omp_const_mem_alloc;
|
||||
extern const omp_allocator_handle_t omp_high_bw_mem_alloc;
|
||||
extern const omp_allocator_handle_t omp_low_lat_mem_alloc;
|
||||
extern const omp_allocator_handle_t omp_cgroup_mem_alloc;
|
||||
extern const omp_allocator_handle_t omp_pteam_mem_alloc;
|
||||
extern const omp_allocator_handle_t omp_thread_mem_alloc;
|
||||
|
||||
void foo() {
|
||||
}
|
||||
|
||||
bool foobool(int argc) {
|
||||
return argc;
|
||||
}
|
||||
|
||||
void xxx(int argc) {
|
||||
int fp; // expected-note {{initialize the variable 'fp' to silence this warning}}
|
||||
#pragma omp masked taskloop simd firstprivate(fp) // expected-warning {{variable 'fp' is uninitialized when used here}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
;
|
||||
}
|
||||
|
||||
struct S1; // expected-note 2 {{declared here}} expected-note 2 {{forward declaration of 'S1'}}
|
||||
extern S1 a;
|
||||
class S2 {
|
||||
mutable int a;
|
||||
|
||||
public:
|
||||
S2() : a(0) {}
|
||||
S2(const S2 &s2) : a(s2.a) {}
|
||||
static float S2s;
|
||||
static const float S2sc;
|
||||
};
|
||||
const float S2::S2sc = 0;
|
||||
const S2 b;
|
||||
const S2 ba[5];
|
||||
class S3 {
|
||||
int a;
|
||||
S3 &operator=(const S3 &s3);
|
||||
|
||||
public:
|
||||
S3() : a(0) {} // expected-note 2 {{candidate constructor not viable: requires 0 arguments, but 1 was provided}}
|
||||
S3(S3 &s3) : a(s3.a) {} // expected-note 2 {{candidate constructor not viable: 1st argument ('const S3') would lose const qualifier}}
|
||||
};
|
||||
const S3 c;
|
||||
const S3 ca[5];
|
||||
extern const int f;
|
||||
class S4 {
|
||||
int a;
|
||||
S4();
|
||||
S4(const S4 &s4); // expected-note 2 {{implicitly declared private here}}
|
||||
|
||||
public:
|
||||
S4(int v) : a(v) {}
|
||||
};
|
||||
class S5 {
|
||||
int a;
|
||||
S5(const S5 &s5) : a(s5.a) {} // expected-note 4 {{implicitly declared private here}}
|
||||
|
||||
public:
|
||||
S5() : a(0) {}
|
||||
S5(int v) : a(v) {}
|
||||
};
|
||||
class S6 {
|
||||
int a;
|
||||
S6() : a(0) {}
|
||||
|
||||
public:
|
||||
S6(const S6 &s6) : a(s6.a) {}
|
||||
S6(int v) : a(v) {}
|
||||
};
|
||||
|
||||
S3 h;
|
||||
#pragma omp threadprivate(h) // expected-note 2 {{defined as threadprivate or thread local}}
|
||||
|
||||
template <class I, class C>
|
||||
int foomain(int argc, char **argv) {
|
||||
I e(4);
|
||||
C g(5);
|
||||
int i, z;
|
||||
int &j = i;
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd firstprivate // expected-error {{expected '(' after 'firstprivate'}}
|
||||
for (int k = 0; k < argc; ++k)
|
||||
++k;
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd firstprivate( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int k = 0; k < argc; ++k)
|
||||
++k;
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd firstprivate() // expected-error {{expected expression}}
|
||||
for (int k = 0; k < argc; ++k)
|
||||
++k;
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd firstprivate(argc // expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int k = 0; k < argc; ++k)
|
||||
++k;
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd firstprivate(argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int k = 0; k < argc; ++k)
|
||||
++k;
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd firstprivate(argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}}
|
||||
for (int k = 0; k < argc; ++k)
|
||||
++k;
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd firstprivate(argc) allocate , allocate(, allocate(omp_default , allocate(omp_default_mem_alloc, allocate(omp_default_mem_alloc:, allocate(omp_default_mem_alloc: argc, allocate(omp_default_mem_alloc: argv), allocate(argv) // expected-error {{expected '(' after 'allocate'}} expected-error 2 {{expected expression}} expected-error 2 {{expected ')'}} expected-error {{use of undeclared identifier 'omp_default'}} expected-note 2 {{to match this '('}}
|
||||
for (int k = 0; k < argc; ++k)
|
||||
++k;
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd firstprivate(S1) // expected-error {{'S1' does not refer to a value}}
|
||||
for (int k = 0; k < argc; ++k)
|
||||
++k;
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd firstprivate(a, b) // expected-error {{firstprivate variable with incomplete type 'S1'}}
|
||||
for (int k = 0; k < argc; ++k)
|
||||
++k;
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd firstprivate(z, argv[1]) // expected-error {{expected variable name}}
|
||||
for (int k = 0; k < argc; ++k)
|
||||
++k;
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd firstprivate(e, g) // expected-error {{calling a private constructor of class 'S4'}} expected-error {{calling a private constructor of class 'S5'}}
|
||||
for (int k = 0; k < argc; ++k)
|
||||
++k;
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd firstprivate(h) // expected-error {{threadprivate or thread local variable cannot be firstprivate}}
|
||||
for (int k = 0; k < argc; ++k)
|
||||
++k;
|
||||
#pragma omp parallel
|
||||
{
|
||||
int v = 0;
|
||||
int i;
|
||||
#pragma omp masked taskloop simd allocate(omp_thread_mem_alloc: i) firstprivate(i) // expected-warning {{allocator with the 'thread' trait access has unspecified behavior on 'masked taskloop simd' directive}}
|
||||
for (int k = 0; k < argc; ++k) {
|
||||
i = k;
|
||||
v += i;
|
||||
}
|
||||
}
|
||||
#pragma omp parallel shared(i)
|
||||
#pragma omp parallel private(i)
|
||||
#pragma omp masked taskloop simd firstprivate(j)
|
||||
for (int k = 0; k < argc; ++k)
|
||||
++k;
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd firstprivate(i)
|
||||
for (int k = 0; k < argc; ++k)
|
||||
++k;
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd lastprivate(g) firstprivate(g) // expected-error {{calling a private constructor of class 'S5'}}
|
||||
for (i = 0; i < argc; ++i)
|
||||
foo();
|
||||
#pragma omp parallel private(i)
|
||||
#pragma omp masked taskloop simd firstprivate(i) // expected-note 2 {{defined as firstprivate}}
|
||||
for (i = 0; i < argc; ++i) // expected-error 2 {{loop iteration variable in the associated loop of 'omp masked taskloop simd' directive may not be firstprivate, predetermined as linear}}
|
||||
foo();
|
||||
#pragma omp parallel reduction(+ : i) // expected-note {{defined as reduction}}
|
||||
#pragma omp masked taskloop simd firstprivate(i) // expected-note {{defined as firstprivate}} expected-error {{argument of a reduction clause of a parallel construct must not appear in a firstprivate clause on a task construct}}
|
||||
for (i = 0; i < argc; ++i) // expected-error {{loop iteration variable in the associated loop of 'omp masked taskloop simd' directive may not be firstprivate, predetermined as linear}}
|
||||
foo();
|
||||
return 0;
|
||||
}
|
||||
|
||||
void bar(S4 a[2]) {
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd firstprivate(a)
|
||||
for (int i = 0; i < 2; ++i)
|
||||
foo();
|
||||
}
|
||||
|
||||
namespace A {
|
||||
double x;
|
||||
#pragma omp threadprivate(x) // expected-note {{defined as threadprivate or thread local}}
|
||||
}
|
||||
namespace B {
|
||||
using A::x;
|
||||
}
|
||||
|
||||
int main(int argc, char **argv) {
|
||||
const int d = 5;
|
||||
const int da[5] = {0};
|
||||
S4 e(4);
|
||||
S5 g(5);
|
||||
S3 m;
|
||||
S6 n(2);
|
||||
int i, z;
|
||||
int &j = i;
|
||||
int tid = 0;
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd firstprivate filter(tid) // expected-error {{expected '(' after 'firstprivate'}}
|
||||
for (i = 0; i < argc; ++i)
|
||||
foo();
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd firstprivate( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (i = 0; i < argc; ++i)
|
||||
foo();
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd firstprivate() // expected-error {{expected expression}}
|
||||
for (i = 0; i < argc; ++i)
|
||||
foo();
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd firstprivate(argc // expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (i = 0; i < argc; ++i)
|
||||
foo();
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd firstprivate(argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (i = 0; i < argc; ++i)
|
||||
foo();
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd firstprivate(argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}}
|
||||
for (i = 0; i < argc; ++i)
|
||||
foo();
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd firstprivate(argc, z)
|
||||
for (i = 0; i < argc; ++i)
|
||||
foo();
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd firstprivate(S1) // expected-error {{'S1' does not refer to a value}}
|
||||
for (i = 0; i < argc; ++i)
|
||||
foo();
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd firstprivate(a, b, c, d, f) // expected-error {{firstprivate variable with incomplete type 'S1'}} expected-error {{no matching constructor for initialization of 'S3'}}
|
||||
for (i = 0; i < argc; ++i)
|
||||
foo();
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd firstprivate(argv[1]) // expected-error {{expected variable name}}
|
||||
for (i = 0; i < argc; ++i)
|
||||
foo();
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd firstprivate(2 * 2) // expected-error {{expected variable name}}
|
||||
for (i = 0; i < argc; ++i)
|
||||
foo();
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd firstprivate(ba) // OK
|
||||
for (i = 0; i < argc; ++i)
|
||||
foo();
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd firstprivate(ca) // expected-error {{no matching constructor for initialization of 'S3'}}
|
||||
for (i = 0; i < argc; ++i)
|
||||
foo();
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd firstprivate(da) // OK
|
||||
for (i = 0; i < argc; ++i)
|
||||
foo();
|
||||
int xa;
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd firstprivate(xa) // OK
|
||||
for (i = 0; i < argc; ++i)
|
||||
foo();
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd firstprivate(S2::S2s) // OK
|
||||
for (i = 0; i < argc; ++i)
|
||||
foo();
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd firstprivate(S2::S2sc) // OK
|
||||
for (i = 0; i < argc; ++i)
|
||||
foo();
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd safelen(5)
|
||||
for (i = 0; i < argc; ++i)
|
||||
foo();
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd firstprivate(e, g) // expected-error {{calling a private constructor of class 'S4'}} expected-error {{calling a private constructor of class 'S5'}}
|
||||
for (i = 0; i < argc; ++i)
|
||||
foo();
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd firstprivate(m) // OK
|
||||
for (i = 0; i < argc; ++i)
|
||||
foo();
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd firstprivate(h) // expected-error {{threadprivate or thread local variable cannot be firstprivate}}
|
||||
for (i = 0; i < argc; ++i)
|
||||
foo();
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd private(xa), firstprivate(xa) // expected-error {{private variable cannot be firstprivate}} expected-note {{defined as private}}
|
||||
for (i = 0; i < argc; ++i)
|
||||
foo();
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd firstprivate(i) // expected-note {{defined as firstprivate}}
|
||||
for (i = 0; i < argc; ++i) // expected-error {{loop iteration variable in the associated loop of 'omp masked taskloop simd' directive may not be firstprivate, predetermined as linear}}
|
||||
foo();
|
||||
#pragma omp parallel shared(xa)
|
||||
#pragma omp masked taskloop simd firstprivate(xa) // OK: may be firstprivate
|
||||
for (i = 0; i < argc; ++i)
|
||||
foo();
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd firstprivate(j)
|
||||
for (i = 0; i < argc; ++i)
|
||||
foo();
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd lastprivate(g) firstprivate(g) // expected-error {{calling a private constructor of class 'S5'}}
|
||||
for (i = 0; i < argc; ++i)
|
||||
foo();
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd lastprivate(n) firstprivate(n) // OK
|
||||
for (i = 0; i < argc; ++i)
|
||||
foo();
|
||||
#pragma omp parallel
|
||||
{
|
||||
int v = 0;
|
||||
int i;
|
||||
#pragma omp masked taskloop simd firstprivate(i)
|
||||
for (int k = 0; k < argc; ++k) {
|
||||
i = k;
|
||||
v += i;
|
||||
}
|
||||
}
|
||||
#pragma omp parallel private(i)
|
||||
#pragma omp masked taskloop simd firstprivate(i) // expected-note {{defined as firstprivate}}
|
||||
for (i = 0; i < argc; ++i) // expected-error {{loop iteration variable in the associated loop of 'omp masked taskloop simd' directive may not be firstprivate, predetermined as linear}}
|
||||
foo();
|
||||
#pragma omp parallel reduction(+ : i) // expected-note {{defined as reduction}}
|
||||
#pragma omp masked taskloop simd firstprivate(i) // expected-error {{argument of a reduction clause of a parallel construct must not appear in a firstprivate clause on a task construct}}
|
||||
for (i = 0; i < argc; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd firstprivate(i) //expected-note {{defined as firstprivate}}
|
||||
for (i = 0; i < argc; ++i) // expected-error {{loop iteration variable in the associated loop of 'omp masked taskloop simd' directive may not be firstprivate, predetermined as linear}}
|
||||
foo();
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd firstprivate(B::x) // expected-error {{threadprivate or thread local variable cannot be firstprivate}}
|
||||
for (i = 0; i < argc; ++i)
|
||||
foo();
|
||||
static int si;
|
||||
#pragma omp masked taskloop simd firstprivate(si) // OK
|
||||
for (i = 0; i < argc; ++i)
|
||||
si = i + 1;
|
||||
|
||||
return foomain<S4, S5>(argc, argv); // expected-note {{in instantiation of function template specialization 'foomain<S4, S5>' requested here}}
|
||||
}
|
||||
|
||||
104
clang/test/OpenMP/masked_taskloop_simd_grainsize_messages.cpp
Normal file
104
clang/test/OpenMP/masked_taskloop_simd_grainsize_messages.cpp
Normal file
@ -0,0 +1,104 @@
|
||||
// RUN: %clang_cc1 -verify -fopenmp -ferror-limit 100 %s -Wuninitialized
|
||||
|
||||
// RUN: %clang_cc1 -verify -fopenmp-simd -ferror-limit 100 %s -Wuninitialized
|
||||
|
||||
void foo() {
|
||||
}
|
||||
|
||||
bool foobool(int argc) {
|
||||
return argc;
|
||||
}
|
||||
|
||||
struct S1; // expected-note {{declared here}}
|
||||
|
||||
template <class T, class S> // expected-note {{declared here}}
|
||||
int tmain(T argc, S **argv) {
|
||||
T z;
|
||||
#pragma omp masked taskloop simd grainsize // expected-error {{expected '(' after 'grainsize'}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd grainsize ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd grainsize () // expected-error {{expected expression}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd grainsize (argc // expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd grainsize (z + argc)) // expected-warning {{extra tokens at the end of '#pragma omp masked taskloop simd' are ignored}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd grainsize (argc > 0 ? argv[1][0] : argv[2][argc])
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd grainsize (foobool(argc)), grainsize (true) // expected-error {{directive '#pragma omp masked taskloop simd' cannot contain more than one 'grainsize' clause}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd grainsize (S) // expected-error {{'S' does not refer to a value}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd grainsize (argc argc) // expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd grainsize(0) // expected-error {{argument to 'grainsize' clause must be a strictly positive integer value}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd grainsize(-1) // expected-error {{argument to 'grainsize' clause must be a strictly positive integer value}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd grainsize(argc) num_tasks(argc) // expected-error {{'num_tasks' and 'grainsize' clause are mutually exclusive and may not appear on the same directive}} expected-note {{'grainsize' clause is specified here}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int main(int argc, char **argv) {
|
||||
int z;
|
||||
int tid = 0;
|
||||
#pragma omp masked taskloop simd filter(tid) grainsize // expected-error {{expected '(' after 'grainsize'}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd grainsize ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd grainsize () // expected-error {{expected expression}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd grainsize (argc // expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd grainsize (argc+z)) // expected-warning {{extra tokens at the end of '#pragma omp masked taskloop simd' are ignored}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd grainsize (argc > 0 ? argv[1][0] : argv[2][argc])
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd grainsize (foobool(argc)), grainsize (true) // expected-error {{directive '#pragma omp masked taskloop simd' cannot contain more than one 'grainsize' clause}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd grainsize (S1) // expected-error {{'S1' does not refer to a value}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd grainsize (argc argc) // expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd grainsize (1 0) // expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd grainsize(if(tmain(argc, argv) // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd grainsize(0) // expected-error {{argument to 'grainsize' clause must be a strictly positive integer value}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd grainsize(-1) // expected-error {{argument to 'grainsize' clause must be a strictly positive integer value}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd grainsize(argc) num_tasks(argc) // expected-error {{'num_tasks' and 'grainsize' clause are mutually exclusive and may not appear on the same directive}} expected-note {{'grainsize' clause is specified here}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
|
||||
return tmain(argc, argv);
|
||||
}
|
||||
392
clang/test/OpenMP/masked_taskloop_simd_in_reduction_messages.cpp
Normal file
392
clang/test/OpenMP/masked_taskloop_simd_in_reduction_messages.cpp
Normal file
@ -0,0 +1,392 @@
|
||||
// RUN: %clang_cc1 -verify -fopenmp -ferror-limit 150 -o - %s -Wuninitialized
|
||||
// RUN: %clang_cc1 -verify -fopenmp -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized
|
||||
// RUN: %clang_cc1 -verify -fopenmp -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
|
||||
|
||||
// RUN: %clang_cc1 -verify -fopenmp-simd -ferror-limit 150 -o - %s -Wuninitialized
|
||||
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized
|
||||
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
|
||||
|
||||
typedef void **omp_allocator_handle_t;
|
||||
extern const omp_allocator_handle_t omp_null_allocator;
|
||||
extern const omp_allocator_handle_t omp_default_mem_alloc;
|
||||
extern const omp_allocator_handle_t omp_large_cap_mem_alloc;
|
||||
extern const omp_allocator_handle_t omp_const_mem_alloc;
|
||||
extern const omp_allocator_handle_t omp_high_bw_mem_alloc;
|
||||
extern const omp_allocator_handle_t omp_low_lat_mem_alloc;
|
||||
extern const omp_allocator_handle_t omp_cgroup_mem_alloc;
|
||||
extern const omp_allocator_handle_t omp_pteam_mem_alloc;
|
||||
extern const omp_allocator_handle_t omp_thread_mem_alloc;
|
||||
|
||||
void foo() {
|
||||
}
|
||||
|
||||
bool foobool(int argc) {
|
||||
return argc;
|
||||
}
|
||||
|
||||
void foobar(int &ref) {
|
||||
#pragma omp taskgroup task_reduction(+:ref)
|
||||
#pragma omp masked taskloop simd in_reduction(+:ref)
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
}
|
||||
|
||||
void foobar1(int &ref) {
|
||||
#pragma omp taskgroup task_reduction(+:ref)
|
||||
#pragma omp masked taskloop simd in_reduction(-:ref)
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
}
|
||||
|
||||
#pragma omp declare reduction (red:int:omp_out += omp_in)
|
||||
|
||||
void foobar2(int &ref) {
|
||||
#pragma omp taskgroup task_reduction(+:ref) // expected-note {{previously marked as task_reduction with different reduction operation}}
|
||||
#pragma omp masked taskloop simd in_reduction(red:ref) // expected-error{{in_reduction variable must have the same reduction operation as in a task_reduction clause}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
}
|
||||
|
||||
void foobar3(int &ref) {
|
||||
#pragma omp taskgroup task_reduction(red:ref) // expected-note {{previously marked as task_reduction with different reduction operation}}
|
||||
#pragma omp masked taskloop simd in_reduction(min:ref) // expected-error{{in_reduction variable must have the same reduction operation as in a task_reduction clause}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
}
|
||||
|
||||
void foobar4(int &ref) {
|
||||
#pragma omp masked taskloop simd in_reduction(min:ref)
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
}
|
||||
|
||||
struct S1; // expected-note {{declared here}} expected-note 4 {{forward declaration of 'S1'}}
|
||||
extern S1 a;
|
||||
class S2 {
|
||||
mutable int a;
|
||||
S2 &operator+(const S2 &arg) { return (*this); } // expected-note 3 {{implicitly declared private here}}
|
||||
|
||||
public:
|
||||
S2() : a(0) {}
|
||||
S2(S2 &s2) : a(s2.a) {}
|
||||
static float S2s; // expected-note 2 {{static data member is predetermined as shared}}
|
||||
static const float S2sc; // expected-note 2 {{'S2sc' declared here}}
|
||||
};
|
||||
const float S2::S2sc = 0;
|
||||
S2 b; // expected-note 3 {{'b' defined here}}
|
||||
const S2 ba[5]; // expected-note 2 {{'ba' defined here}}
|
||||
class S3 {
|
||||
int a;
|
||||
|
||||
public:
|
||||
int b;
|
||||
S3() : a(0) {}
|
||||
S3(const S3 &s3) : a(s3.a) {}
|
||||
S3 operator+(const S3 &arg1) { return arg1; }
|
||||
};
|
||||
int operator+(const S3 &arg1, const S3 &arg2) { return 5; }
|
||||
S3 c; // expected-note 3 {{'c' defined here}}
|
||||
const S3 ca[5]; // expected-note 2 {{'ca' defined here}}
|
||||
extern const int f; // expected-note 4 {{'f' declared here}}
|
||||
class S4 {
|
||||
int a;
|
||||
S4(); // expected-note {{implicitly declared private here}}
|
||||
S4(const S4 &s4);
|
||||
S4 &operator+(const S4 &arg) { return (*this); }
|
||||
|
||||
public:
|
||||
S4(int v) : a(v) {}
|
||||
};
|
||||
S4 &operator&=(S4 &arg1, S4 &arg2) { return arg1; }
|
||||
class S5 {
|
||||
int a;
|
||||
S5() : a(0) {} // expected-note {{implicitly declared private here}}
|
||||
S5(const S5 &s5) : a(s5.a) {}
|
||||
S5 &operator+(const S5 &arg);
|
||||
|
||||
public:
|
||||
S5(int v) : a(v) {}
|
||||
};
|
||||
class S6 { // expected-note 3 {{candidate function (the implicit copy assignment operator) not viable: no known conversion from 'int' to 'const S6' for 1st argument}}
|
||||
#if __cplusplus >= 201103L // C++11 or later
|
||||
// expected-note@-2 3 {{candidate function (the implicit move assignment operator) not viable}}
|
||||
#endif
|
||||
int a;
|
||||
|
||||
public:
|
||||
S6() : a(6) {}
|
||||
operator int() { return 6; }
|
||||
} o;
|
||||
|
||||
S3 h, k;
|
||||
#pragma omp threadprivate(h) // expected-note 2 {{defined as threadprivate or thread local}}
|
||||
|
||||
template <class T> // expected-note {{declared here}}
|
||||
T tmain(T argc) {
|
||||
const T d = T(); // expected-note 4 {{'d' defined here}}
|
||||
const T da[5] = {T()}; // expected-note 2 {{'da' defined here}}
|
||||
T qa[5] = {T()};
|
||||
T i, z;
|
||||
T &j = i; // expected-note 2 {{'j' defined here}}
|
||||
S3 &p = k; // expected-note 2 {{'p' defined here}}
|
||||
const T &r = da[(int)i]; // expected-note 2 {{'r' defined here}}
|
||||
T &q = qa[(int)i];
|
||||
T fl;
|
||||
#pragma omp taskgroup task_reduction(+:argc)
|
||||
#pragma omp masked taskloop simd in_reduction // expected-error {{expected '(' after 'in_reduction'}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp taskgroup task_reduction(+:argc)
|
||||
#pragma omp masked taskloop simd in_reduction + // expected-error {{expected '(' after 'in_reduction'}} expected-warning {{extra tokens at the end of '#pragma omp masked taskloop simd' are ignored}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp taskgroup task_reduction(+:argc)
|
||||
#pragma omp masked taskloop simd in_reduction( // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp taskgroup task_reduction(+:argc)
|
||||
#pragma omp masked taskloop simd in_reduction(- // expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp taskgroup task_reduction(+:argc)
|
||||
#pragma omp masked taskloop simd in_reduction() // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp taskgroup task_reduction(+:argc)
|
||||
#pragma omp masked taskloop simd in_reduction(*) // expected-warning {{missing ':' after reduction identifier - ignoring}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp taskgroup task_reduction(+:argc)
|
||||
#pragma omp masked taskloop simd in_reduction(\) // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp taskgroup task_reduction(&:argc) // expected-error {{invalid operands to binary expression ('float' and 'float')}}
|
||||
#pragma omp masked taskloop simd in_reduction(& : argc // expected-error {{expected ')'}} expected-note {{to match this '('}} expected-error {{invalid operands to binary expression ('float' and 'float')}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp taskgroup task_reduction(|:z) // expected-error {{invalid operands to binary expression ('float' and 'float')}}
|
||||
#pragma omp masked taskloop simd in_reduction(| : z, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} expected-error {{invalid operands to binary expression ('float' and 'float')}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd in_reduction(|| : argc ? i : argc) // expected-error 2 {{expected variable name, array element or array section}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd in_reduction(foo : argc) //expected-error {{incorrect reduction identifier, expected one of '+', '-', '*', '&', '|', '^', '&&', '||', 'min' or 'max' or declare reduction for type 'float'}} expected-error {{incorrect reduction identifier, expected one of '+', '-', '*', '&', '|', '^', '&&', '||', 'min' or 'max' or declare reduction for type 'int'}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp taskgroup task_reduction(&&:argc)
|
||||
#pragma omp masked taskloop simd in_reduction(&& : argc) allocate , allocate(, allocate(omp_default , allocate(omp_default_mem_alloc, allocate(omp_default_mem_alloc:, allocate(omp_default_mem_alloc: argc, allocate(omp_default_mem_alloc: argv), allocate(argv) // expected-error {{expected '(' after 'allocate'}} expected-error 2 {{expected expression}} expected-error 2 {{expected ')'}} expected-error {{use of undeclared identifier 'omp_default'}} expected-note 2 {{to match this '('}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd in_reduction(^ : T) // expected-error {{'T' does not refer to a value}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp taskgroup task_reduction(+:c)
|
||||
#pragma omp masked taskloop simd in_reduction(+ : a, b, c, d, f) // expected-error {{a reduction list item with incomplete type 'S1'}} expected-error 3 {{const-qualified variable cannot be in_reduction}} expected-error 2 {{'operator+' is a private member of 'S2'}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd in_reduction(min : a, b, c, d, f) // expected-error {{a reduction list item with incomplete type 'S1'}} expected-error 4 {{arguments of OpenMP clause 'in_reduction' for 'min' or 'max' must be of arithmetic type}} expected-error 3 {{const-qualified variable cannot be in_reduction}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd in_reduction(max : h.b) // expected-error {{expected variable name, array element or array section}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd in_reduction(+ : ba) // expected-error {{const-qualified variable cannot be in_reduction}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd in_reduction(* : ca) // expected-error {{const-qualified variable cannot be in_reduction}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd in_reduction(- : da) // expected-error {{const-qualified variable cannot be in_reduction}} expected-error {{const-qualified variable cannot be in_reduction}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd in_reduction(^ : fl) // expected-error {{invalid operands to binary expression ('float' and 'float')}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd in_reduction(&& : S2::S2s) // expected-error {{shared variable cannot be reduction}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd in_reduction(&& : S2::S2sc) // expected-error {{const-qualified variable cannot be in_reduction}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp taskgroup task_reduction(+:k)
|
||||
#pragma omp masked taskloop simd in_reduction(+ : h, k) // expected-error {{threadprivate or thread local variable cannot be reduction}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd in_reduction(+ : o) // expected-error 2 {{no viable overloaded '='}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp parallel private(k)
|
||||
#pragma omp masked taskloop simd in_reduction(+ : p), in_reduction(+ : p) // expected-error 2 {{argument of OpenMP clause 'in_reduction' must reference the same object in all threads}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp taskgroup task_reduction(+:p)
|
||||
#pragma omp masked taskloop simd in_reduction(+ : p), in_reduction(+ : p) // expected-error 2 {{variable can appear only once in OpenMP 'in_reduction' clause}} expected-note 2 {{previously referenced here}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd in_reduction(+ : r) // expected-error 2 {{const-qualified variable cannot be in_reduction}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp parallel shared(i)
|
||||
#pragma omp parallel reduction(min : i)
|
||||
#pragma omp masked taskloop simd in_reduction(max : j) // expected-error 2 {{argument of OpenMP clause 'in_reduction' must reference the same object in all threads}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp taskgroup task_reduction(+:fl)
|
||||
{
|
||||
#pragma omp masked taskloop simd allocate(omp_thread_mem_alloc: fl) in_reduction(+ : fl) // expected-warning 2 {{allocator with the 'thread' trait access has unspecified behavior on 'masked taskloop simd' directive}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp taskgroup task_reduction(*:fl) // expected-note 2 {{previously marked as task_reduction with different reduction operation}}
|
||||
{
|
||||
#pragma omp masked taskloop simd in_reduction(+ : fl) // expected-error 2 {{in_reduction variable must have the same reduction operation as in a task_reduction clause}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
}
|
||||
}
|
||||
#pragma omp parallel
|
||||
#pragma omp for reduction(- : fl)
|
||||
for (int i = 0; i < 10; ++i)
|
||||
#pragma omp taskgroup task_reduction(+:fl)
|
||||
#pragma omp masked taskloop simd in_reduction(+ : fl)
|
||||
for (int j = 0; j < 10; ++j)
|
||||
foo();
|
||||
|
||||
return T();
|
||||
}
|
||||
|
||||
namespace A {
|
||||
double x;
|
||||
#pragma omp threadprivate(x) // expected-note {{defined as threadprivate or thread local}}
|
||||
}
|
||||
namespace B {
|
||||
using A::x;
|
||||
}
|
||||
|
||||
int main(int argc, char **argv) {
|
||||
const int d = 5; // expected-note 2 {{'d' defined here}}
|
||||
const int da[5] = {0}; // expected-note {{'da' defined here}}
|
||||
int qa[5] = {0};
|
||||
S4 e(4);
|
||||
S5 g(5);
|
||||
int i, z;
|
||||
int &j = i; // expected-note {{'j' defined here}}
|
||||
S3 &p = k; // expected-note 2 {{'p' defined here}}
|
||||
const int &r = da[i]; // expected-note {{'r' defined here}}
|
||||
int &q = qa[i];
|
||||
float fl;
|
||||
int tid = 0;
|
||||
#pragma omp masked taskloop simd in_reduction filter(tid) // expected-error {{expected '(' after 'in_reduction'}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd in_reduction + // expected-error {{expected '(' after 'in_reduction'}} expected-warning {{extra tokens at the end of '#pragma omp masked taskloop simd' are ignored}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd in_reduction( // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd in_reduction(- // expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd in_reduction() // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd in_reduction(*) // expected-warning {{missing ':' after reduction identifier - ignoring}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd in_reduction(\) // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd in_reduction(foo : argc // expected-error {{expected ')'}} expected-note {{to match this '('}} expected-error {{incorrect reduction identifier, expected one of '+', '-', '*', '&', '|', '^', '&&', '||', 'min' or 'max'}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp taskgroup task_reduction(|:argc)
|
||||
#pragma omp masked taskloop simd in_reduction(| : argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd in_reduction(|| : argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name, array element or array section}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd in_reduction(~ : argc) // expected-error {{expected unqualified-id}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp taskgroup task_reduction(&&:argc, z)
|
||||
#pragma omp masked taskloop simd in_reduction(&& : argc, z)
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd in_reduction(^ : S1) // expected-error {{'S1' does not refer to a value}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp taskgroup task_reduction(+:c)
|
||||
#pragma omp masked taskloop simd in_reduction(+ : a, b, c, d, f) // expected-error {{a reduction list item with incomplete type 'S1'}} expected-error 2 {{const-qualified variable cannot be in_reduction}} expected-error {{'operator+' is a private member of 'S2'}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd in_reduction(min : a, b, c, d, f) // expected-error {{a reduction list item with incomplete type 'S1'}} expected-error 2 {{arguments of OpenMP clause 'in_reduction' for 'min' or 'max' must be of arithmetic type}} expected-error 2 {{const-qualified variable cannot be in_reduction}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd in_reduction(max : h.b) // expected-error {{expected variable name, array element or array section}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd in_reduction(+ : ba) // expected-error {{const-qualified variable cannot be in_reduction}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd in_reduction(* : ca) // expected-error {{const-qualified variable cannot be in_reduction}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd in_reduction(- : da) // expected-error {{const-qualified variable cannot be in_reduction}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd in_reduction(^ : fl) // expected-error {{invalid operands to binary expression ('float' and 'float')}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd in_reduction(&& : S2::S2s) // expected-error {{shared variable cannot be reduction}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd in_reduction(&& : S2::S2sc) // expected-error {{const-qualified variable cannot be in_reduction}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd in_reduction(& : e, g) // expected-error {{calling a private constructor of class 'S4'}} expected-error {{calling a private constructor of class 'S5'}} expected-error {{invalid operands to binary expression ('S5' and 'S5')}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp taskgroup task_reduction(+:k)
|
||||
#pragma omp masked taskloop simd in_reduction(+ : h, k, B::x) // expected-error 2 {{threadprivate or thread local variable cannot be reduction}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd in_reduction(+ : o) // expected-error {{no viable overloaded '='}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp parallel private(k)
|
||||
#pragma omp masked taskloop simd in_reduction(+ : p), in_reduction(+ : p) // expected-error 2 {{argument of OpenMP clause 'in_reduction' must reference the same object in all threads}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp taskgroup task_reduction(+:p)
|
||||
#pragma omp masked taskloop simd in_reduction(+ : p), in_reduction(+ : p) // expected-error {{variable can appear only once in OpenMP 'in_reduction' clause}} expected-note {{previously referenced here}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd in_reduction(+ : r) // expected-error {{const-qualified variable cannot be in_reduction}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp parallel shared(i)
|
||||
#pragma omp parallel reduction(min : i)
|
||||
#pragma omp masked taskloop simd in_reduction(max : j) // expected-error {{argument of OpenMP clause 'in_reduction' must reference the same object in all threads}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp parallel
|
||||
#pragma omp for private(fl)
|
||||
for (int i = 0; i < 10; ++i)
|
||||
#pragma omp taskgroup task_reduction(+:fl)
|
||||
#pragma omp masked taskloop simd in_reduction(+ : fl)
|
||||
for (int j = 0; j < 10; ++j)
|
||||
foo();
|
||||
#pragma omp taskgroup task_reduction(+:fl)
|
||||
#pragma omp masked taskloop simd in_reduction(+ : fl)
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
static int m;
|
||||
#pragma omp taskgroup task_reduction(+:m)
|
||||
#pragma omp masked taskloop simd in_reduction(+ : m) // OK
|
||||
for (int i = 0; i < 10; ++i)
|
||||
m++;
|
||||
|
||||
return tmain(argc) + tmain(fl); // expected-note {{in instantiation of function template specialization 'tmain<int>' requested here}} expected-note {{in instantiation of function template specialization 'tmain<float>' requested here}}
|
||||
}
|
||||
307
clang/test/OpenMP/masked_taskloop_simd_lastprivate_messages.cpp
Normal file
307
clang/test/OpenMP/masked_taskloop_simd_lastprivate_messages.cpp
Normal file
@ -0,0 +1,307 @@
|
||||
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-version=45 -fopenmp %s -Wuninitialized
|
||||
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp %s -Wuninitialized
|
||||
|
||||
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-version=45 -fopenmp-simd %s -Wuninitialized
|
||||
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd %s -Wuninitialized
|
||||
|
||||
typedef void **omp_allocator_handle_t;
|
||||
extern const omp_allocator_handle_t omp_null_allocator;
|
||||
extern const omp_allocator_handle_t omp_default_mem_alloc;
|
||||
extern const omp_allocator_handle_t omp_large_cap_mem_alloc;
|
||||
extern const omp_allocator_handle_t omp_const_mem_alloc;
|
||||
extern const omp_allocator_handle_t omp_high_bw_mem_alloc;
|
||||
extern const omp_allocator_handle_t omp_low_lat_mem_alloc;
|
||||
extern const omp_allocator_handle_t omp_cgroup_mem_alloc;
|
||||
extern const omp_allocator_handle_t omp_pteam_mem_alloc;
|
||||
extern const omp_allocator_handle_t omp_thread_mem_alloc;
|
||||
|
||||
void foo() {
|
||||
}
|
||||
|
||||
bool foobool(int argc) {
|
||||
return argc;
|
||||
}
|
||||
|
||||
struct S1; // expected-note 2 {{declared here}} expected-note 2 {{forward declaration of 'S1'}}
|
||||
extern S1 a;
|
||||
class S2 {
|
||||
mutable int a;
|
||||
|
||||
public:
|
||||
S2() : a(0) {}
|
||||
S2(S2 &s2) : a(s2.a) {}
|
||||
const S2 &operator =(const S2&) const;
|
||||
S2 &operator =(const S2&);
|
||||
static float S2s; // expected-note {{static data member is predetermined as shared}}
|
||||
static const float S2sc; // expected-note {{'S2sc' declared here}}
|
||||
};
|
||||
const float S2::S2sc = 0;
|
||||
const S2 b;
|
||||
const S2 ba[5];
|
||||
class S3 {
|
||||
int a;
|
||||
S3 &operator=(const S3 &s3); // expected-note 2 {{implicitly declared private here}}
|
||||
|
||||
public:
|
||||
S3() : a(0) {}
|
||||
S3(S3 &s3) : a(s3.a) {}
|
||||
};
|
||||
const S3 c; // expected-note {{'c' defined here}}
|
||||
const S3 ca[5]; // expected-note {{'ca' defined here}}
|
||||
extern const int f; // expected-note {{'f' declared here}}
|
||||
class S4 {
|
||||
int a;
|
||||
S4(); // expected-note 3 {{implicitly declared private here}}
|
||||
S4(const S4 &s4);
|
||||
|
||||
public:
|
||||
S4(int v) : a(v) {}
|
||||
};
|
||||
class S5 {
|
||||
int a;
|
||||
S5() : a(0) {} // expected-note {{implicitly declared private here}}
|
||||
|
||||
public:
|
||||
S5(const S5 &s5) : a(s5.a) {}
|
||||
S5(int v) : a(v) {}
|
||||
};
|
||||
class S6 {
|
||||
int a;
|
||||
S6() : a(0) {}
|
||||
|
||||
public:
|
||||
S6(const S6 &s6) : a(s6.a) {}
|
||||
S6(int v) : a(v) {}
|
||||
};
|
||||
|
||||
S3 h;
|
||||
#pragma omp threadprivate(h) // expected-note 2 {{defined as threadprivate or thread local}}
|
||||
|
||||
template <class I, class C>
|
||||
int foomain(int argc, char **argv) {
|
||||
I e(4);
|
||||
I g(5);
|
||||
int i, z;
|
||||
int &j = i;
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd lastprivate // expected-error {{expected '(' after 'lastprivate'}}
|
||||
for (int k = 0; k < argc; ++k)
|
||||
++k;
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd lastprivate( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int k = 0; k < argc; ++k)
|
||||
++k;
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd lastprivate() // expected-error {{expected expression}}
|
||||
for (int k = 0; k < argc; ++k)
|
||||
++k;
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd lastprivate(argc // expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int k = 0; k < argc; ++k)
|
||||
++k;
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd lastprivate(argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int k = 0; k < argc; ++k)
|
||||
++k;
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd lastprivate(argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}}
|
||||
for (int k = 0; k < argc; ++k)
|
||||
++k;
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd lastprivate(argc) allocate , allocate(, allocate(omp_default , allocate(omp_default_mem_alloc, allocate(omp_default_mem_alloc:, allocate(omp_default_mem_alloc: argc, allocate(omp_default_mem_alloc: argv), allocate(argv) // expected-error {{expected '(' after 'allocate'}} expected-error 2 {{expected expression}} expected-error 2 {{expected ')'}} expected-error {{use of undeclared identifier 'omp_default'}} expected-note 2 {{to match this '('}}
|
||||
for (int k = 0; k < argc; ++k)
|
||||
++k;
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd lastprivate(S1) // expected-error {{'S1' does not refer to a value}}
|
||||
for (int k = 0; k < argc; ++k)
|
||||
++k;
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd lastprivate(conditional: argc) lastprivate(conditional: // expected-error 2 {{use of undeclared identifier 'conditional'}} expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int k = 0; k < argc; ++k)
|
||||
++k;
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd lastprivate(z, a, b) // expected-error {{lastprivate variable with incomplete type 'S1'}}
|
||||
for (int k = 0; k < argc; ++k)
|
||||
++k;
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd lastprivate(argv[1]) // expected-error {{expected variable name}}
|
||||
for (int k = 0; k < argc; ++k)
|
||||
++k;
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd lastprivate(e, g) // expected-error 2 {{calling a private constructor of class 'S4'}}
|
||||
for (int k = 0; k < argc; ++k)
|
||||
++k;
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd lastprivate(h) // expected-error {{threadprivate or thread local variable cannot be lastprivate}}
|
||||
for (int k = 0; k < argc; ++k)
|
||||
++k;
|
||||
#pragma omp parallel
|
||||
{
|
||||
int v = 0;
|
||||
int i;
|
||||
#pragma omp masked taskloop simd lastprivate(i) allocate(omp_thread_mem_alloc: i) // expected-warning {{allocator with the 'thread' trait access has unspecified behavior on 'masked taskloop simd' directive}}
|
||||
for (int k = 0; k < argc; ++k) {
|
||||
i = k;
|
||||
v += i;
|
||||
}
|
||||
}
|
||||
#pragma omp parallel shared(i)
|
||||
#pragma omp parallel private(i)
|
||||
#pragma omp masked taskloop simd lastprivate(j)
|
||||
for (int k = 0; k < argc; ++k)
|
||||
++k;
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd lastprivate(i)
|
||||
for (int k = 0; k < argc; ++k)
|
||||
++k;
|
||||
return 0;
|
||||
}
|
||||
|
||||
void bar(S4 a[2]) {
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd lastprivate(a)
|
||||
for (int i = 0; i < 2; ++i)
|
||||
foo();
|
||||
}
|
||||
|
||||
namespace A {
|
||||
double x;
|
||||
#pragma omp threadprivate(x) // expected-note {{defined as threadprivate or thread local}}
|
||||
}
|
||||
namespace B {
|
||||
using A::x;
|
||||
}
|
||||
|
||||
int main(int argc, char **argv) {
|
||||
const int d = 5; // expected-note {{'d' defined here}}
|
||||
const int da[5] = {0}; // expected-note {{'da' defined here}}
|
||||
S4 e(4);
|
||||
S5 g(5);
|
||||
S3 m;
|
||||
S6 n(2);
|
||||
int i, z;
|
||||
int &j = i;
|
||||
int tid = 0;
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd lastprivate filter(tid) // expected-error {{expected '(' after 'lastprivate'}}
|
||||
for (i = 0; i < argc; ++i)
|
||||
foo();
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd lastprivate( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (i = 0; i < argc; ++i)
|
||||
foo();
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd lastprivate() // expected-error {{expected expression}}
|
||||
for (i = 0; i < argc; ++i)
|
||||
foo();
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd lastprivate(argc // expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (i = 0; i < argc; ++i)
|
||||
foo();
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd lastprivate(argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (i = 0; i < argc; ++i)
|
||||
foo();
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd lastprivate(argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}}
|
||||
for (i = 0; i < argc; ++i)
|
||||
foo();
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd lastprivate(argc, z)
|
||||
for (i = 0; i < argc; ++i)
|
||||
foo();
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd lastprivate(S1) // expected-error {{'S1' does not refer to a value}}
|
||||
for (i = 0; i < argc; ++i)
|
||||
foo();
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd lastprivate(a, b, c, d, f) // expected-error {{lastprivate variable with incomplete type 'S1'}} expected-error 1 {{const-qualified variable without mutable fields cannot be lastprivate}} expected-error 2 {{const-qualified variable cannot be lastprivate}}
|
||||
for (i = 0; i < argc; ++i)
|
||||
foo();
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd lastprivate(argv[1]) // expected-error {{expected variable name}}
|
||||
for (i = 0; i < argc; ++i)
|
||||
foo();
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd lastprivate(2 * 2) // expected-error {{expected variable name}}
|
||||
for (i = 0; i < argc; ++i)
|
||||
foo();
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd lastprivate(ba)
|
||||
for (i = 0; i < argc; ++i)
|
||||
foo();
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd lastprivate(ca) // expected-error {{const-qualified variable without mutable fields cannot be lastprivate}}
|
||||
for (i = 0; i < argc; ++i)
|
||||
foo();
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd lastprivate(da) // expected-error {{const-qualified variable cannot be lastprivate}}
|
||||
for (i = 0; i < argc; ++i)
|
||||
foo();
|
||||
int xa;
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd lastprivate(xa) // OK
|
||||
for (i = 0; i < argc; ++i)
|
||||
foo();
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd lastprivate(S2::S2s) // expected-error {{shared variable cannot be lastprivate}}
|
||||
for (i = 0; i < argc; ++i)
|
||||
foo();
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd lastprivate(S2::S2sc) // expected-error {{const-qualified variable cannot be lastprivate}}
|
||||
for (i = 0; i < argc; ++i)
|
||||
foo();
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd safelen(5)
|
||||
for (i = 0; i < argc; ++i)
|
||||
foo();
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd lastprivate(e, g) // expected-error {{calling a private constructor of class 'S4'}} expected-error {{calling a private constructor of class 'S5'}}
|
||||
for (i = 0; i < argc; ++i)
|
||||
foo();
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd lastprivate(m) // expected-error {{'operator=' is a private member of 'S3'}}
|
||||
for (i = 0; i < argc; ++i)
|
||||
foo();
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd lastprivate(h) // expected-error {{threadprivate or thread local variable cannot be lastprivate}}
|
||||
for (i = 0; i < argc; ++i)
|
||||
foo();
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd lastprivate(B::x) // expected-error {{threadprivate or thread local variable cannot be lastprivate}}
|
||||
for (i = 0; i < argc; ++i)
|
||||
foo();
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd private(xa), lastprivate(xa) // expected-error {{private variable cannot be lastprivate}} expected-note {{defined as private}}
|
||||
for (i = 0; i < argc; ++i)
|
||||
foo();
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd lastprivate(i) // omp45-note {{defined as lastprivate}}
|
||||
for (i = 0; i < argc; ++i) // omp45-error {{loop iteration variable in the associated loop of 'omp masked taskloop simd' directive may not be lastprivate, predetermined as linear}}
|
||||
foo();
|
||||
#pragma omp parallel private(xa)
|
||||
#pragma omp masked taskloop simd lastprivate(xa)
|
||||
for (i = 0; i < argc; ++i)
|
||||
foo();
|
||||
#pragma omp parallel reduction(+ : xa)
|
||||
#pragma omp masked taskloop simd lastprivate(xa)
|
||||
for (i = 0; i < argc; ++i)
|
||||
foo();
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd lastprivate(j)
|
||||
for (i = 0; i < argc; ++i)
|
||||
foo();
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd firstprivate(m) lastprivate(m) // expected-error {{'operator=' is a private member of 'S3'}}
|
||||
for (i = 0; i < argc; ++i)
|
||||
foo();
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd lastprivate(n) firstprivate(n) // OK
|
||||
for (i = 0; i < argc; ++i)
|
||||
foo();
|
||||
static int si;
|
||||
#pragma omp masked taskloop simd lastprivate(si) // OK
|
||||
for (i = 0; i < argc; ++i)
|
||||
si = i + 1;
|
||||
return foomain<S4, S5>(argc, argv); // expected-note {{in instantiation of function template specialization 'foomain<S4, S5>' requested here}}
|
||||
}
|
||||
269
clang/test/OpenMP/masked_taskloop_simd_linear_messages.cpp
Normal file
269
clang/test/OpenMP/masked_taskloop_simd_linear_messages.cpp
Normal file
@ -0,0 +1,269 @@
|
||||
// RUN: %clang_cc1 -verify -fopenmp %s -Wuninitialized
|
||||
|
||||
// RUN: %clang_cc1 -verify -fopenmp-simd %s -Wuninitialized
|
||||
|
||||
typedef void **omp_allocator_handle_t;
|
||||
extern const omp_allocator_handle_t omp_null_allocator;
|
||||
extern const omp_allocator_handle_t omp_default_mem_alloc;
|
||||
extern const omp_allocator_handle_t omp_large_cap_mem_alloc;
|
||||
extern const omp_allocator_handle_t omp_const_mem_alloc;
|
||||
extern const omp_allocator_handle_t omp_high_bw_mem_alloc;
|
||||
extern const omp_allocator_handle_t omp_low_lat_mem_alloc;
|
||||
extern const omp_allocator_handle_t omp_cgroup_mem_alloc;
|
||||
extern const omp_allocator_handle_t omp_pteam_mem_alloc;
|
||||
extern const omp_allocator_handle_t omp_thread_mem_alloc;
|
||||
|
||||
void xxx(int argc) {
|
||||
int i, lin, step; // expected-note {{initialize the variable 'lin' to silence this warning}} expected-note {{initialize the variable 'step' to silence this warning}}
|
||||
#pragma omp master taskloop simd linear(i, lin : step) // expected-warning {{variable 'lin' is uninitialized when used here}} expected-warning {{variable 'step' is uninitialized when used here}}
|
||||
for (i = 0; i < 10; ++i)
|
||||
;
|
||||
}
|
||||
|
||||
namespace X {
|
||||
int x;
|
||||
};
|
||||
|
||||
struct B {
|
||||
static int ib; // expected-note {{'B::ib' declared here}}
|
||||
static int bfoo() { return 8; }
|
||||
};
|
||||
|
||||
int bfoo() { return 4; }
|
||||
|
||||
int z;
|
||||
const int C1 = 1;
|
||||
const int C2 = 2;
|
||||
void test_linear_colons()
|
||||
{
|
||||
int B = 0;
|
||||
#pragma omp master taskloop simd linear(B:bfoo())
|
||||
for (int i = 0; i < 10; ++i) ;
|
||||
// expected-error@+1 {{unexpected ':' in nested name specifier; did you mean '::'}}
|
||||
#pragma omp master taskloop simd linear(B::ib:B:bfoo())
|
||||
for (int i = 0; i < 10; ++i) ;
|
||||
// expected-error@+1 {{use of undeclared identifier 'ib'; did you mean 'B::ib'}}
|
||||
#pragma omp master taskloop simd linear(B:ib)
|
||||
for (int i = 0; i < 10; ++i) ;
|
||||
// expected-error@+1 {{unexpected ':' in nested name specifier; did you mean '::'?}}
|
||||
#pragma omp master taskloop simd linear(z:B:ib)
|
||||
for (int i = 0; i < 10; ++i) ;
|
||||
#pragma omp master taskloop simd linear(B:B::bfoo())
|
||||
for (int i = 0; i < 10; ++i) ;
|
||||
#pragma omp master taskloop simd linear(X::x : ::z)
|
||||
for (int i = 0; i < 10; ++i) ;
|
||||
#pragma omp master taskloop simd linear(B,::z, X::x)
|
||||
for (int i = 0; i < 10; ++i) ;
|
||||
#pragma omp master taskloop simd linear(::z)
|
||||
for (int i = 0; i < 10; ++i) ;
|
||||
// expected-error@+1 {{expected variable name}}
|
||||
#pragma omp master taskloop simd linear(B::bfoo())
|
||||
for (int i = 0; i < 10; ++i) ;
|
||||
#pragma omp master taskloop simd linear(B::ib,B:C1+C2)
|
||||
for (int i = 0; i < 10; ++i) ;
|
||||
}
|
||||
|
||||
template<int L, class T, class N> T test_template(T* arr, N num) {
|
||||
N i;
|
||||
T sum = (T)0;
|
||||
T ind2 = - num * L; // expected-note {{'ind2' defined here}}
|
||||
// expected-error@+1 {{argument of a linear clause should be of integral or pointer type}}
|
||||
#pragma omp master taskloop simd linear(ind2:L)
|
||||
for (i = 0; i < num; ++i) {
|
||||
T cur = arr[(int)ind2];
|
||||
ind2 += L;
|
||||
sum += cur;
|
||||
}
|
||||
return T();
|
||||
}
|
||||
|
||||
template<int LEN> int test_warn() {
|
||||
int ind2 = 0;
|
||||
// expected-warning@+1 {{zero linear step (ind2 should probably be const)}}
|
||||
#pragma omp master taskloop simd linear(ind2:LEN)
|
||||
for (int i = 0; i < 100; i++) {
|
||||
ind2 += LEN;
|
||||
}
|
||||
return ind2;
|
||||
}
|
||||
|
||||
struct S1; // expected-note 2 {{declared here}} expected-note 2 {{forward declaration of 'S1'}}
|
||||
extern S1 a;
|
||||
class S2 {
|
||||
mutable int a;
|
||||
public:
|
||||
S2():a(0) { }
|
||||
};
|
||||
const S2 b; // expected-note 2 {{'b' defined here}}
|
||||
const S2 ba[5];
|
||||
class S3 {
|
||||
int a;
|
||||
public:
|
||||
S3():a(0) { }
|
||||
};
|
||||
const S3 ca[5];
|
||||
class S4 {
|
||||
int a;
|
||||
S4();
|
||||
public:
|
||||
S4(int v):a(v) { }
|
||||
};
|
||||
class S5 {
|
||||
int a;
|
||||
S5():a(0) {}
|
||||
public:
|
||||
S5(int v):a(v) { }
|
||||
};
|
||||
|
||||
S3 h;
|
||||
#pragma omp threadprivate(h) // expected-note 2 {{defined as threadprivate or thread local}}
|
||||
|
||||
template<class I, class C> int foomain(I argc, C **argv) {
|
||||
I e(4);
|
||||
I g(5);
|
||||
int i, z;
|
||||
int &j = i;
|
||||
#pragma omp master taskloop simd linear // expected-error {{expected '(' after 'linear'}}
|
||||
for (int k = 0; k < argc; ++k) ++k;
|
||||
#pragma omp master taskloop simd linear ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int k = 0; k < argc; ++k) ++k;
|
||||
#pragma omp master taskloop simd linear (val // expected-error {{use of undeclared identifier 'val'}} expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int k = 0; k < argc; ++k) ++k;
|
||||
#pragma omp master taskloop simd linear (uval( // expected-error {{expected expression}} expected-error 2 {{expected ')'}} expected-note 2 {{to match this '('}}
|
||||
for (int k = 0; k < argc; ++k) ++k;
|
||||
#pragma omp master taskloop simd linear (ref() // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int k = 0; k < argc; ++k) ++k;
|
||||
#pragma omp master taskloop simd linear (foo() // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int k = 0; k < argc; ++k) ++k;
|
||||
#pragma omp master taskloop simd linear () // expected-error {{expected expression}}
|
||||
for (int k = 0; k < argc; ++k) ++k;
|
||||
#pragma omp master taskloop simd linear (argc // expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int k = 0; k < argc; ++k) ++k;
|
||||
#pragma omp master taskloop simd linear (val argc // expected-error {{use of undeclared identifier 'val'}} expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int k = 0; k < argc; ++k) ++k;
|
||||
#pragma omp master taskloop simd linear (val(argc, // expected-error {{expected expression}} expected-error 2 {{expected ')'}} expected-note 2 {{to match this '('}}
|
||||
for (int k = 0; k < argc; ++k) ++k;
|
||||
#pragma omp master taskloop simd linear (argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}}
|
||||
for (int k = 0; k < argc; ++k) ++k;
|
||||
#pragma omp master taskloop simd linear (argc : 5) allocate , allocate(, allocate(omp_default , allocate(omp_default_mem_alloc, allocate(omp_default_mem_alloc:, allocate(omp_default_mem_alloc: argc, allocate(omp_default_mem_alloc: argv), allocate(argv) // expected-error {{expected '(' after 'allocate'}} expected-error 2 {{expected expression}} expected-error 2 {{expected ')'}} expected-error {{use of undeclared identifier 'omp_default'}} expected-note 2 {{to match this '('}}
|
||||
for (int k = 0; k < argc; ++k) ++k;
|
||||
#pragma omp master taskloop simd linear (S1) // expected-error {{'S1' does not refer to a value}}
|
||||
for (int k = 0; k < argc; ++k) ++k;
|
||||
// expected-error@+2 {{linear variable with incomplete type 'S1'}}
|
||||
// expected-error@+1 {{argument of a linear clause should be of integral or pointer type, not 'S2'}}
|
||||
#pragma omp master taskloop simd linear (val(a, b):B::ib)
|
||||
for (int k = 0; k < argc; ++k) ++k;
|
||||
#pragma omp master taskloop simd linear (argv[1]) // expected-error {{expected variable name}}
|
||||
for (int k = 0; k < argc; ++k) ++k;
|
||||
#pragma omp master taskloop simd linear(ref(e, g)) // expected-error 2 {{variable of non-reference type 'int' can be used only with 'val' modifier, but used with 'ref'}}
|
||||
for (int k = 0; k < argc; ++k) ++k;
|
||||
#pragma omp master taskloop simd linear(h, z) // expected-error {{threadprivate or thread local variable cannot be linear}}
|
||||
for (int k = 0; k < argc; ++k) ++k;
|
||||
#pragma omp master taskloop simd linear(uval(i)) // expected-error {{variable of non-reference type 'int' can be used only with 'val' modifier, but used with 'uval'}}
|
||||
for (int k = 0; k < argc; ++k) ++k;
|
||||
#pragma omp parallel
|
||||
{
|
||||
int v = 0;
|
||||
int i;
|
||||
#pragma omp master taskloop simd allocate(omp_thread_mem_alloc: v) linear(v:i) // expected-warning {{allocator with the 'thread' trait access has unspecified behavior on 'master taskloop simd' directive}}
|
||||
for (int k = 0; k < argc; ++k) { i = k; v += i; }
|
||||
}
|
||||
#pragma omp master taskloop simd linear(ref(j))
|
||||
for (int k = 0; k < argc; ++k) ++k;
|
||||
#pragma omp master taskloop simd linear(uval(j))
|
||||
for (int k = 0; k < argc; ++k) ++k;
|
||||
int v = 0;
|
||||
#pragma omp master taskloop simd linear(v:j)
|
||||
for (int k = 0; k < argc; ++k) { ++k; v += j; }
|
||||
#pragma omp master taskloop simd linear(i)
|
||||
for (int k = 0; k < argc; ++k) ++k;
|
||||
return 0;
|
||||
}
|
||||
|
||||
namespace A {
|
||||
double x;
|
||||
#pragma omp threadprivate(x) // expected-note {{defined as threadprivate or thread local}}
|
||||
}
|
||||
namespace C {
|
||||
using A::x;
|
||||
}
|
||||
|
||||
void linear_modifiers(int argc) {
|
||||
int &f = argc;
|
||||
#pragma omp master taskloop simd linear(f)
|
||||
for (int k = 0; k < argc; ++k) ++k;
|
||||
#pragma omp master taskloop simd linear(val(f))
|
||||
for (int k = 0; k < argc; ++k) ++k;
|
||||
#pragma omp master taskloop simd linear(uval(f))
|
||||
for (int k = 0; k < argc; ++k) ++k;
|
||||
#pragma omp master taskloop simd linear(ref(f))
|
||||
for (int k = 0; k < argc; ++k) ++k;
|
||||
#pragma omp master taskloop simd linear(foo(f)) // expected-error {{expected one of 'ref', val' or 'uval' modifiers}}
|
||||
for (int k = 0; k < argc; ++k) ++k;
|
||||
}
|
||||
|
||||
int f;
|
||||
int main(int argc, char **argv) {
|
||||
double darr[100];
|
||||
// expected-note@+1 {{in instantiation of function template specialization 'test_template<-4, double, int>' requested here}}
|
||||
test_template<-4>(darr, 4);
|
||||
// expected-note@+1 {{in instantiation of function template specialization 'test_warn<0>' requested here}}
|
||||
test_warn<0>();
|
||||
|
||||
S4 e(4); // expected-note {{'e' defined here}}
|
||||
S5 g(5); // expected-note {{'g' defined here}}
|
||||
int i, z;
|
||||
int &j = i;
|
||||
#pragma omp master taskloop simd linear(f) linear(f) // expected-error {{linear variable cannot be linear}} expected-note {{defined as linear}}
|
||||
for (int k = 0; k < argc; ++k) ++k;
|
||||
#pragma omp master taskloop simd linear // expected-error {{expected '(' after 'linear'}}
|
||||
for (int k = 0; k < argc; ++k) ++k;
|
||||
#pragma omp master taskloop simd linear ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int k = 0; k < argc; ++k) ++k;
|
||||
#pragma omp master taskloop simd linear () // expected-error {{expected expression}}
|
||||
for (int k = 0; k < argc; ++k) ++k;
|
||||
#pragma omp master taskloop simd linear (val // expected-error {{use of undeclared identifier 'val'}} expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int k = 0; k < argc; ++k) ++k;
|
||||
#pragma omp master taskloop simd linear (ref()) // expected-error {{expected expression}}
|
||||
for (int k = 0; k < argc; ++k) ++k;
|
||||
#pragma omp master taskloop simd linear (foo()) // expected-error {{expected expression}}
|
||||
for (int k = 0; k < argc; ++k) ++k;
|
||||
#pragma omp master taskloop simd linear (argc // expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int k = 0; k < argc; ++k) ++k;
|
||||
#pragma omp master taskloop simd linear (argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int k = 0; k < argc; ++k) ++k;
|
||||
#pragma omp master taskloop simd linear (argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}}
|
||||
for (int k = 0; k < argc; ++k) ++k;
|
||||
#pragma omp master taskloop simd linear (argc, z)
|
||||
for (int k = 0; k < argc; ++k) ++k;
|
||||
#pragma omp master taskloop simd linear (S1) // expected-error {{'S1' does not refer to a value}}
|
||||
for (int k = 0; k < argc; ++k) ++k;
|
||||
// expected-error@+2 {{linear variable with incomplete type 'S1'}}
|
||||
// expected-error@+1 {{argument of a linear clause should be of integral or pointer type, not 'S2'}}
|
||||
#pragma omp master taskloop simd linear(a, b)
|
||||
for (int k = 0; k < argc; ++k) ++k;
|
||||
#pragma omp master taskloop simd linear (argv[1]) // expected-error {{expected variable name}}
|
||||
for (int k = 0; k < argc; ++k) ++k;
|
||||
// expected-error@+2 {{argument of a linear clause should be of integral or pointer type, not 'S4'}}
|
||||
// expected-error@+1 {{argument of a linear clause should be of integral or pointer type, not 'S5'}}
|
||||
#pragma omp master taskloop simd linear(val(e, g))
|
||||
for (int k = 0; k < argc; ++k) ++k;
|
||||
#pragma omp master taskloop simd linear(h, C::x) // expected-error 2 {{threadprivate or thread local variable cannot be linear}}
|
||||
for (int k = 0; k < argc; ++k) ++k;
|
||||
#pragma omp parallel
|
||||
{
|
||||
int i;
|
||||
#pragma omp master taskloop simd linear(val(i))
|
||||
for (int k = 0; k < argc; ++k) ++k;
|
||||
#pragma omp master taskloop simd linear(uval(i) : 4) // expected-error {{variable of non-reference type 'int' can be used only with 'val' modifier, but used with 'uval'}}
|
||||
for (int k = 0; k < argc; ++k) { ++k; i += 4; }
|
||||
}
|
||||
#pragma omp master taskloop simd linear(ref(j))
|
||||
for (int k = 0; k < argc; ++k) ++k;
|
||||
#pragma omp master taskloop simd linear(i)
|
||||
for (int k = 0; k < argc; ++k) ++k;
|
||||
|
||||
foomain<int,char>(argc,argv); // expected-note {{in instantiation of function template specialization 'foomain<int, char>' requested here}}
|
||||
return 0;
|
||||
}
|
||||
|
||||
744
clang/test/OpenMP/masked_taskloop_simd_loop_messages.cpp
Normal file
744
clang/test/OpenMP/masked_taskloop_simd_loop_messages.cpp
Normal file
@ -0,0 +1,744 @@
|
||||
// RUN: %clang_cc1 -fsyntax-only -fopenmp -fopenmp-version=45 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp4 %s -Wuninitialized
|
||||
// RUN: %clang_cc1 -fsyntax-only -fopenmp -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp5 %s -Wuninitialized
|
||||
|
||||
// RUN: %clang_cc1 -fsyntax-only -fopenmp-simd -fopenmp-version=45 -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp4 %s -Wuninitialized
|
||||
// RUN: %clang_cc1 -fsyntax-only -fopenmp-simd -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify=expected,omp5 %s -Wuninitialized
|
||||
|
||||
class S {
|
||||
int a;
|
||||
S() : a(0) {}
|
||||
|
||||
public:
|
||||
S(int v) : a(v) {}
|
||||
S(const S &s) : a(s.a) {}
|
||||
};
|
||||
|
||||
static int sii;
|
||||
// expected-note@+1 {{defined as threadprivate or thread local}}
|
||||
#pragma omp threadprivate(sii)
|
||||
static int globalii;
|
||||
|
||||
// Currently, we cannot use "0" for global register variables.
|
||||
// register int reg0 __asm__("0");
|
||||
int reg0;
|
||||
|
||||
int test_iteration_spaces() {
|
||||
const int N = 100;
|
||||
float a[N], b[N], c[N];
|
||||
int ii, jj, kk;
|
||||
float fii;
|
||||
double dii;
|
||||
int tid = 0;
|
||||
register int reg; // expected-warning {{'register' storage class specifier is deprecated}}
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd filter(tid)
|
||||
for (int i = 0; i < 10; i += 1) {
|
||||
c[i] = a[i] + b[i];
|
||||
}
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd
|
||||
for (char i = 0; i < 10; i++) {
|
||||
c[i] = a[i] + b[i];
|
||||
}
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd
|
||||
for (char i = 0; i < 10; i += '\1') {
|
||||
c[i] = a[i] + b[i];
|
||||
}
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd
|
||||
for (long long i = 0; i < 10; i++) {
|
||||
c[i] = a[i] + b[i];
|
||||
}
|
||||
#pragma omp parallel
|
||||
// expected-error@+2 {{expression must have integral or unscoped enumeration type, not 'double'}}
|
||||
#pragma omp masked taskloop simd
|
||||
for (long long i = 0; i < 10; i += 1.5) {
|
||||
c[i] = a[i] + b[i];
|
||||
}
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd
|
||||
for (long long i = 0; i < 'z'; i += 1u) {
|
||||
c[i] = a[i] + b[i];
|
||||
}
|
||||
#pragma omp parallel
|
||||
// expected-error@+2 {{variable must be of integer or random access iterator type}}
|
||||
#pragma omp masked taskloop simd
|
||||
for (float fi = 0; fi < 10.0; fi++) {
|
||||
c[(int)fi] = a[(int)fi] + b[(int)fi];
|
||||
}
|
||||
#pragma omp parallel
|
||||
// expected-error@+2 {{variable must be of integer or random access iterator type}}
|
||||
#pragma omp masked taskloop simd
|
||||
for (double fi = 0; fi < 10.0; fi++) {
|
||||
c[(int)fi] = a[(int)fi] + b[(int)fi];
|
||||
}
|
||||
#pragma omp parallel
|
||||
// expected-error@+2 {{initialization clause of OpenMP for loop is not in canonical form ('var = init' or 'T var = init')}}
|
||||
#pragma omp masked taskloop simd
|
||||
for (int &ref = ii; ref < 10; ref++) {
|
||||
}
|
||||
#pragma omp parallel
|
||||
// expected-error@+2 {{initialization clause of OpenMP for loop is not in canonical form ('var = init' or 'T var = init')}}
|
||||
#pragma omp masked taskloop simd
|
||||
for (int i; i < 10; i++)
|
||||
c[i] = a[i];
|
||||
|
||||
#pragma omp parallel
|
||||
// expected-error@+2 {{initialization clause of OpenMP for loop is not in canonical form ('var = init' or 'T var = init')}}
|
||||
#pragma omp masked taskloop simd
|
||||
for (int i = 0, j = 0; i < 10; ++i)
|
||||
c[i] = a[i];
|
||||
|
||||
#pragma omp parallel
|
||||
// expected-error@+2 {{initialization clause of OpenMP for loop is not in canonical form ('var = init' or 'T var = init')}}
|
||||
#pragma omp masked taskloop simd
|
||||
for (; ii < 10; ++ii)
|
||||
c[ii] = a[ii];
|
||||
|
||||
#pragma omp parallel
|
||||
// expected-warning@+3 {{expression result unused}}
|
||||
// expected-error@+2 {{initialization clause of OpenMP for loop is not in canonical form ('var = init' or 'T var = init')}}
|
||||
#pragma omp masked taskloop simd
|
||||
for (ii + 1; ii < 10; ++ii)
|
||||
c[ii] = a[ii];
|
||||
|
||||
#pragma omp parallel
|
||||
// expected-error@+2 {{initialization clause of OpenMP for loop is not in canonical form ('var = init' or 'T var = init')}}
|
||||
#pragma omp masked taskloop simd
|
||||
for (c[ii] = 0; ii < 10; ++ii)
|
||||
c[ii] = a[ii];
|
||||
|
||||
#pragma omp parallel
|
||||
// Ok to skip parenthesises.
|
||||
#pragma omp masked taskloop simd
|
||||
for (((ii)) = 0; ii < 10; ++ii)
|
||||
c[ii] = a[ii];
|
||||
|
||||
#pragma omp parallel
|
||||
// omp4-error@+2 {{condition of OpenMP for loop must be a relational comparison ('<', '<=', '>', or '>=') of loop variable 'i'}} omp5-error@+2 {{condition of OpenMP for loop must be a relational comparison ('<', '<=', '>', '>=', or '!=') of loop variable 'i'}}
|
||||
#pragma omp masked taskloop simd
|
||||
for (int i = 0; i; i++)
|
||||
c[i] = a[i];
|
||||
|
||||
#pragma omp parallel
|
||||
// omp4-error@+3 {{condition of OpenMP for loop must be a relational comparison ('<', '<=', '>', or '>=') of loop variable 'i'}} omp5-error@+3 {{condition of OpenMP for loop must be a relational comparison ('<', '<=', '>', '>=', or '!=') of loop variable 'i'}}
|
||||
// expected-error@+2 {{increment clause of OpenMP for loop must perform simple addition or subtraction on loop variable 'i'}}
|
||||
#pragma omp masked taskloop simd
|
||||
for (int i = 0; jj < kk; ii++)
|
||||
c[i] = a[i];
|
||||
|
||||
#pragma omp parallel
|
||||
// omp4-error@+2 {{condition of OpenMP for loop must be a relational comparison ('<', '<=', '>', or '>=') of loop variable 'i'}} omp5-error@+2 {{condition of OpenMP for loop must be a relational comparison ('<', '<=', '>', '>=', or '!=') of loop variable 'i'}}
|
||||
#pragma omp masked taskloop simd
|
||||
for (int i = 0; !!i; i++)
|
||||
c[i] = a[i];
|
||||
|
||||
#pragma omp parallel
|
||||
// omp4-error@+2 {{condition of OpenMP for loop must be a relational comparison ('<', '<=', '>', or '>=') of loop variable 'i'}}
|
||||
#pragma omp masked taskloop simd
|
||||
for (int i = 0; i != 1; i++)
|
||||
c[i] = a[i];
|
||||
|
||||
#pragma omp parallel
|
||||
// omp4-error@+2 {{condition of OpenMP for loop must be a relational comparison ('<', '<=', '>', or '>=') of loop variable 'i'}} omp5-error@+2 {{condition of OpenMP for loop must be a relational comparison ('<', '<=', '>', '>=', or '!=') of loop variable 'i'}}
|
||||
#pragma omp masked taskloop simd
|
||||
for (int i = 0;; i++)
|
||||
c[i] = a[i];
|
||||
|
||||
#pragma omp parallel
|
||||
// Ok.
|
||||
#pragma omp masked taskloop simd
|
||||
for (int i = 11; i > 10; i--)
|
||||
c[i] = a[i];
|
||||
|
||||
#pragma omp parallel
|
||||
// Ok.
|
||||
#pragma omp masked taskloop simd
|
||||
for (int i = 0; i < 10; ++i)
|
||||
c[i] = a[i];
|
||||
|
||||
#pragma omp parallel
|
||||
// Ok.
|
||||
#pragma omp masked taskloop simd
|
||||
for (ii = 0; ii < 10; ++ii)
|
||||
c[ii] = a[ii];
|
||||
|
||||
#pragma omp parallel
|
||||
// expected-error@+2 {{increment clause of OpenMP for loop must perform simple addition or subtraction on loop variable 'ii'}}
|
||||
#pragma omp masked taskloop simd
|
||||
for (ii = 0; ii < 10; ++jj)
|
||||
c[ii] = a[jj];
|
||||
|
||||
#pragma omp parallel
|
||||
// expected-error@+2 {{increment clause of OpenMP for loop must perform simple addition or subtraction on loop variable 'ii'}}
|
||||
#pragma omp masked taskloop simd
|
||||
for (ii = 0; ii < 10; ++++ii)
|
||||
c[ii] = a[ii];
|
||||
|
||||
#pragma omp parallel
|
||||
// Ok but undefined behavior (in general, cannot check that incr
|
||||
// is really loop-invariant).
|
||||
#pragma omp masked taskloop simd
|
||||
for (ii = 0; ii < 10; ii = ii + ii)
|
||||
c[ii] = a[ii];
|
||||
|
||||
#pragma omp parallel
|
||||
// expected-error@+2 {{expression must have integral or unscoped enumeration type, not 'float'}}
|
||||
#pragma omp masked taskloop simd
|
||||
for (ii = 0; ii < 10; ii = ii + 1.0f)
|
||||
c[ii] = a[ii];
|
||||
|
||||
#pragma omp parallel
|
||||
// Ok - step was converted to integer type.
|
||||
#pragma omp masked taskloop simd
|
||||
for (ii = 0; ii < 10; ii = ii + (int)1.1f)
|
||||
c[ii] = a[ii];
|
||||
|
||||
#pragma omp parallel
|
||||
// expected-error@+2 {{increment clause of OpenMP for loop must perform simple addition or subtraction on loop variable 'ii'}}
|
||||
#pragma omp masked taskloop simd
|
||||
for (ii = 0; ii < 10; jj = ii + 2)
|
||||
c[ii] = a[ii];
|
||||
|
||||
#pragma omp parallel
|
||||
// expected-warning@+3 {{relational comparison result unused}}
|
||||
// expected-error@+2 {{increment clause of OpenMP for loop must perform simple addition or subtraction on loop variable 'ii'}}
|
||||
#pragma omp masked taskloop simd
|
||||
for (ii = 0; ii<10; jj> kk + 2)
|
||||
c[ii] = a[ii];
|
||||
|
||||
#pragma omp parallel
|
||||
// expected-error@+2 {{increment clause of OpenMP for loop must perform simple addition or subtraction on loop variable 'ii'}}
|
||||
#pragma omp masked taskloop simd
|
||||
for (ii = 0; ii < 10;)
|
||||
c[ii] = a[ii];
|
||||
|
||||
#pragma omp parallel
|
||||
// expected-warning@+3 {{expression result unused}}
|
||||
// expected-error@+2 {{increment clause of OpenMP for loop must perform simple addition or subtraction on loop variable 'ii'}}
|
||||
#pragma omp masked taskloop simd
|
||||
for (ii = 0; ii < 10; !ii)
|
||||
c[ii] = a[ii];
|
||||
|
||||
#pragma omp parallel
|
||||
// expected-error@+2 {{increment clause of OpenMP for loop must perform simple addition or subtraction on loop variable 'ii'}}
|
||||
#pragma omp masked taskloop simd
|
||||
for (ii = 0; ii < 10; ii ? ++ii : ++jj)
|
||||
c[ii] = a[ii];
|
||||
|
||||
#pragma omp parallel
|
||||
// expected-error@+2 {{increment clause of OpenMP for loop must perform simple addition or subtraction on loop variable 'ii'}}
|
||||
#pragma omp masked taskloop simd
|
||||
for (ii = 0; ii < 10; ii = ii < 10)
|
||||
c[ii] = a[ii];
|
||||
|
||||
#pragma omp parallel
|
||||
// expected-note@+3 {{loop step is expected to be positive due to this condition}}
|
||||
// expected-error@+2 {{increment expression must cause 'ii' to increase on each iteration of OpenMP for loop}}
|
||||
#pragma omp masked taskloop simd
|
||||
for (ii = 0; ii < 10; ii = ii + 0)
|
||||
c[ii] = a[ii];
|
||||
|
||||
#pragma omp parallel
|
||||
// expected-note@+3 {{loop step is expected to be positive due to this condition}}
|
||||
// expected-error@+2 {{increment expression must cause 'ii' to increase on each iteration of OpenMP for loop}}
|
||||
#pragma omp masked taskloop simd
|
||||
for (ii = 0; ii < 10; ii = ii + (int)(0.8 - 0.45))
|
||||
c[ii] = a[ii];
|
||||
|
||||
#pragma omp parallel
|
||||
// expected-note@+3 {{loop step is expected to be positive due to this condition}}
|
||||
// expected-error@+2 {{increment expression must cause 'ii' to increase on each iteration of OpenMP for loop}}
|
||||
#pragma omp masked taskloop simd
|
||||
for (ii = 0; (ii) < 10; ii -= 25)
|
||||
c[ii] = a[ii];
|
||||
|
||||
#pragma omp parallel
|
||||
// expected-note@+3 {{loop step is expected to be positive due to this condition}}
|
||||
// expected-error@+2 {{increment expression must cause 'ii' to increase on each iteration of OpenMP for loop}}
|
||||
#pragma omp masked taskloop simd
|
||||
for (ii = 0; (ii < 10); ii -= 0)
|
||||
c[ii] = a[ii];
|
||||
|
||||
#pragma omp parallel
|
||||
// expected-note@+3 {{loop step is expected to be negative due to this condition}}
|
||||
// expected-error@+2 {{increment expression must cause 'ii' to decrease on each iteration of OpenMP for loop}}
|
||||
#pragma omp masked taskloop simd
|
||||
for (ii = 0; ii > 10; (ii += 0))
|
||||
c[ii] = a[ii];
|
||||
|
||||
#pragma omp parallel
|
||||
// expected-note@+3 {{loop step is expected to be positive due to this condition}}
|
||||
// expected-error@+2 {{increment expression must cause 'ii' to increase on each iteration of OpenMP for loop}}
|
||||
#pragma omp masked taskloop simd
|
||||
for (ii = 0; ii < 10; (ii) = (1 - 1) + (ii))
|
||||
c[ii] = a[ii];
|
||||
|
||||
#pragma omp parallel
|
||||
// expected-note@+3 {{loop step is expected to be negative due to this condition}}
|
||||
// expected-error@+2 {{increment expression must cause 'ii' to decrease on each iteration of OpenMP for loop}}
|
||||
#pragma omp masked taskloop simd
|
||||
for ((ii = 0); ii > 10; (ii -= 0))
|
||||
c[ii] = a[ii];
|
||||
|
||||
#pragma omp parallel
|
||||
// expected-note@+3 {{loop step is expected to be positive due to this condition}}
|
||||
// expected-error@+2 {{increment expression must cause 'ii' to increase on each iteration of OpenMP for loop}}
|
||||
#pragma omp masked taskloop simd
|
||||
for (ii = 0; (ii < 10); (ii -= 0))
|
||||
c[ii] = a[ii];
|
||||
|
||||
#pragma omp parallel
|
||||
// expected-note@+2 {{defined as firstprivate}}
|
||||
// expected-error@+2 {{loop iteration variable in the associated loop of 'omp masked taskloop simd' directive may not be firstprivate, predetermined as linear}}
|
||||
#pragma omp masked taskloop simd firstprivate(ii)
|
||||
for (ii = 0; ii < 10; ii++)
|
||||
c[ii] = a[ii];
|
||||
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd linear(ii)
|
||||
for (ii = 0; ii < 10; ii++)
|
||||
c[ii] = a[ii];
|
||||
|
||||
// omp4-note@+3 {{defined as private}}
|
||||
// omp4-error@+3 {{loop iteration variable in the associated loop of 'omp masked taskloop simd' directive may not be private, predetermined as linear}}
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd private(ii)
|
||||
for (ii = 0; ii < 10; ii++)
|
||||
c[ii] = a[ii];
|
||||
|
||||
// omp4-note@+3 {{defined as lastprivate}}
|
||||
// omp4-error@+3 {{loop iteration variable in the associated loop of 'omp masked taskloop simd' directive may not be lastprivate, predetermined as linear}}
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd lastprivate(ii)
|
||||
for (ii = 0; ii < 10; ii++)
|
||||
c[ii] = a[ii];
|
||||
|
||||
#pragma omp parallel
|
||||
{
|
||||
// expected-error@+2 {{loop iteration variable in the associated loop of 'omp masked taskloop simd' directive may not be threadprivate or thread local, predetermined as linear}}
|
||||
#pragma omp masked taskloop simd
|
||||
for (sii = 0; sii < 10; sii += 1)
|
||||
c[sii] = a[sii];
|
||||
}
|
||||
|
||||
#pragma omp parallel
|
||||
{
|
||||
#pragma omp masked taskloop simd
|
||||
for (reg0 = 0; reg0 < 10; reg0 += 1)
|
||||
c[reg0] = a[reg0];
|
||||
}
|
||||
|
||||
#pragma omp parallel
|
||||
{
|
||||
#pragma omp masked taskloop simd
|
||||
for (reg = 0; reg < 10; reg += 1)
|
||||
c[reg] = a[reg];
|
||||
}
|
||||
|
||||
#pragma omp parallel
|
||||
{
|
||||
#pragma omp masked taskloop simd
|
||||
for (globalii = 0; globalii < 10; globalii += 1)
|
||||
c[globalii] = a[globalii];
|
||||
}
|
||||
|
||||
#pragma omp parallel
|
||||
{
|
||||
#pragma omp masked taskloop simd collapse(2)
|
||||
for (ii = 0; ii < 10; ii += 1)
|
||||
for (globalii = 0; globalii < 10; globalii += 1)
|
||||
c[globalii] += a[globalii] + ii;
|
||||
}
|
||||
|
||||
#pragma omp parallel
|
||||
// omp4-error@+2 {{statement after '#pragma omp masked taskloop simd' must be a for loop}}
|
||||
#pragma omp masked taskloop simd
|
||||
for (auto &item : a) {
|
||||
item = item + 1;
|
||||
}
|
||||
|
||||
#pragma omp parallel
|
||||
// expected-note@+3 {{loop step is expected to be positive due to this condition}}
|
||||
// expected-error@+2 {{increment expression must cause 'i' to increase on each iteration of OpenMP for loop}}
|
||||
#pragma omp masked taskloop simd
|
||||
for (unsigned i = 9; i < 10; i--) {
|
||||
c[i] = a[i] + b[i];
|
||||
}
|
||||
|
||||
int(*lb)[4] = nullptr;
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd
|
||||
for (int(*p)[4] = lb; p < lb + 8; ++p) {
|
||||
}
|
||||
|
||||
#pragma omp parallel
|
||||
// expected-warning@+2 {{initialization clause of OpenMP for loop is not in canonical form ('var = init' or 'T var = init')}}
|
||||
#pragma omp masked taskloop simd
|
||||
for (int a{0}; a < 10; ++a) {
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
// Iterators allowed in openmp for-loops.
|
||||
namespace std {
|
||||
struct random_access_iterator_tag {};
|
||||
template <class Iter>
|
||||
struct iterator_traits {
|
||||
typedef typename Iter::difference_type difference_type;
|
||||
typedef typename Iter::iterator_category iterator_category;
|
||||
};
|
||||
template <class Iter>
|
||||
typename iterator_traits<Iter>::difference_type
|
||||
distance(Iter first, Iter last) { return first - last; }
|
||||
}
|
||||
class Iter0 {
|
||||
public:
|
||||
Iter0() {}
|
||||
Iter0(const Iter0 &) {}
|
||||
Iter0 operator++() { return *this; }
|
||||
Iter0 operator--() { return *this; }
|
||||
bool operator<(Iter0 a) { return true; }
|
||||
};
|
||||
// expected-note@+2 {{candidate function not viable: no known conversion from 'GoodIter' to 'Iter0' for 1st argument}}
|
||||
// expected-note@+1 2 {{candidate function not viable: no known conversion from 'Iter1' to 'Iter0' for 1st argument}}
|
||||
int operator-(Iter0 a, Iter0 b) { return 0; }
|
||||
class Iter1 {
|
||||
public:
|
||||
Iter1(float f = 0.0f, double d = 0.0) {}
|
||||
Iter1(const Iter1 &) {}
|
||||
Iter1 operator++() { return *this; }
|
||||
Iter1 operator--() { return *this; }
|
||||
bool operator<(Iter1 a) { return true; }
|
||||
bool operator>=(Iter1 a) { return false; }
|
||||
};
|
||||
class GoodIter {
|
||||
public:
|
||||
GoodIter() {}
|
||||
GoodIter(const GoodIter &) {}
|
||||
GoodIter(int fst, int snd) {}
|
||||
GoodIter &operator=(const GoodIter &that) { return *this; }
|
||||
GoodIter &operator=(const Iter0 &that) { return *this; }
|
||||
GoodIter &operator+=(int x) { return *this; }
|
||||
GoodIter &operator-=(int x) { return *this; }
|
||||
explicit GoodIter(void *) {}
|
||||
GoodIter operator++() { return *this; }
|
||||
GoodIter operator--() { return *this; }
|
||||
bool operator!() { return true; }
|
||||
bool operator<(GoodIter a) { return true; }
|
||||
bool operator<=(GoodIter a) { return true; }
|
||||
bool operator>=(GoodIter a) { return false; }
|
||||
typedef int difference_type;
|
||||
typedef std::random_access_iterator_tag iterator_category;
|
||||
};
|
||||
// expected-note@+2 {{candidate function not viable: no known conversion from 'const Iter0' to 'GoodIter' for 2nd argument}}
|
||||
// expected-note@+1 2 {{candidate function not viable: no known conversion from 'Iter1' to 'GoodIter' for 1st argument}}
|
||||
int operator-(GoodIter a, GoodIter b) { return 0; }
|
||||
// expected-note@+1 3 {{candidate function not viable: requires single argument 'a', but 2 arguments were provided}}
|
||||
GoodIter operator-(GoodIter a) { return a; }
|
||||
// expected-note@+2 {{candidate function not viable: no known conversion from 'const Iter0' to 'int' for 2nd argument}}
|
||||
// expected-note@+1 2 {{candidate function not viable: no known conversion from 'Iter1' to 'GoodIter' for 1st argument}}
|
||||
GoodIter operator-(GoodIter a, int v) { return GoodIter(); }
|
||||
// expected-note@+1 2 {{candidate function not viable: no known conversion from 'Iter0' to 'GoodIter' for 1st argument}}
|
||||
GoodIter operator+(GoodIter a, int v) { return GoodIter(); }
|
||||
// expected-note@+2 {{candidate function not viable: no known conversion from 'GoodIter' to 'int' for 1st argument}}
|
||||
// expected-note@+1 2 {{candidate function not viable: no known conversion from 'Iter1' to 'int' for 1st argument}}
|
||||
GoodIter operator-(int v, GoodIter a) { return GoodIter(); }
|
||||
// expected-note@+1 2 {{candidate function not viable: no known conversion from 'Iter0' to 'int' for 1st argument}}
|
||||
GoodIter operator+(int v, GoodIter a) { return GoodIter(); }
|
||||
|
||||
int test_with_random_access_iterator() {
|
||||
GoodIter begin, end;
|
||||
Iter0 begin0, end0;
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd
|
||||
for (GoodIter I = begin; I < end; ++I)
|
||||
++I;
|
||||
#pragma omp parallel
|
||||
// expected-error@+2 {{initialization clause of OpenMP for loop is not in canonical form ('var = init' or 'T var = init')}}
|
||||
#pragma omp masked taskloop simd
|
||||
for (GoodIter &I = begin; I < end; ++I)
|
||||
++I;
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd
|
||||
for (GoodIter I = begin; I >= end; --I)
|
||||
++I;
|
||||
#pragma omp parallel
|
||||
// expected-warning@+2 {{initialization clause of OpenMP for loop is not in canonical form ('var = init' or 'T var = init')}}
|
||||
#pragma omp masked taskloop simd
|
||||
for (GoodIter I(begin); I < end; ++I)
|
||||
++I;
|
||||
#pragma omp parallel
|
||||
// expected-warning@+2 {{initialization clause of OpenMP for loop is not in canonical form ('var = init' or 'T var = init')}}
|
||||
#pragma omp masked taskloop simd
|
||||
for (GoodIter I(nullptr); I < end; ++I)
|
||||
++I;
|
||||
#pragma omp parallel
|
||||
// expected-warning@+2 {{initialization clause of OpenMP for loop is not in canonical form ('var = init' or 'T var = init')}}
|
||||
#pragma omp masked taskloop simd
|
||||
for (GoodIter I(0); I < end; ++I)
|
||||
++I;
|
||||
#pragma omp parallel
|
||||
// expected-warning@+2 {{initialization clause of OpenMP for loop is not in canonical form ('var = init' or 'T var = init')}}
|
||||
#pragma omp masked taskloop simd
|
||||
for (GoodIter I(1, 2); I < end; ++I)
|
||||
++I;
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd
|
||||
for (begin = GoodIter(0); begin < end; ++begin)
|
||||
++begin;
|
||||
// expected-error@+4 {{invalid operands to binary expression ('GoodIter' and 'const Iter0')}}
|
||||
// expected-error@+3 {{could not calculate number of iterations calling 'operator-' with upper and lower loop bounds}}
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd
|
||||
for (begin = begin0; begin < end; ++begin)
|
||||
++begin;
|
||||
#pragma omp parallel
|
||||
// expected-error@+2 {{initialization clause of OpenMP for loop is not in canonical form ('var = init' or 'T var = init')}}
|
||||
#pragma omp masked taskloop simd
|
||||
for (++begin; begin < end; ++begin)
|
||||
++begin;
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd
|
||||
for (begin = end; begin < end; ++begin)
|
||||
++begin;
|
||||
#pragma omp parallel
|
||||
// omp4-error@+2 {{condition of OpenMP for loop must be a relational comparison ('<', '<=', '>', or '>=') of loop variable 'I'}} omp5-error@+2 {{condition of OpenMP for loop must be a relational comparison ('<', '<=', '>', '>=', or '!=') of loop variable 'I'}}
|
||||
#pragma omp masked taskloop simd
|
||||
for (GoodIter I = begin; I - I; ++I)
|
||||
++I;
|
||||
#pragma omp parallel
|
||||
// omp4-error@+2 {{condition of OpenMP for loop must be a relational comparison ('<', '<=', '>', or '>=') of loop variable 'I'}} omp5-error@+2 {{condition of OpenMP for loop must be a relational comparison ('<', '<=', '>', '>=', or '!=') of loop variable 'I'}}
|
||||
#pragma omp masked taskloop simd
|
||||
for (GoodIter I = begin; begin < end; ++I)
|
||||
++I;
|
||||
#pragma omp parallel
|
||||
// omp4-error@+2 {{condition of OpenMP for loop must be a relational comparison ('<', '<=', '>', or '>=') of loop variable 'I'}} omp5-error@+2 {{condition of OpenMP for loop must be a relational comparison ('<', '<=', '>', '>=', or '!=') of loop variable 'I'}}
|
||||
#pragma omp masked taskloop simd
|
||||
for (GoodIter I = begin; !I; ++I)
|
||||
++I;
|
||||
#pragma omp parallel
|
||||
// expected-note@+3 {{loop step is expected to be negative due to this condition}}
|
||||
// expected-error@+2 {{increment expression must cause 'I' to decrease on each iteration of OpenMP for loop}}
|
||||
#pragma omp masked taskloop simd
|
||||
for (GoodIter I = begin; I >= end; I = I + 1)
|
||||
++I;
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd
|
||||
for (GoodIter I = begin; I >= end; I = I - 1)
|
||||
++I;
|
||||
#pragma omp parallel
|
||||
// expected-error@+2 {{increment clause of OpenMP for loop must perform simple addition or subtraction on loop variable 'I'}}
|
||||
#pragma omp masked taskloop simd
|
||||
for (GoodIter I = begin; I >= end; I = -I)
|
||||
++I;
|
||||
#pragma omp parallel
|
||||
// expected-note@+3 {{loop step is expected to be negative due to this condition}}
|
||||
// expected-error@+2 {{increment expression must cause 'I' to decrease on each iteration of OpenMP for loop}}
|
||||
#pragma omp masked taskloop simd
|
||||
for (GoodIter I = begin; I >= end; I = 2 + I)
|
||||
++I;
|
||||
#pragma omp parallel
|
||||
// expected-error@+2 {{increment clause of OpenMP for loop must perform simple addition or subtraction on loop variable 'I'}}
|
||||
#pragma omp masked taskloop simd
|
||||
for (GoodIter I = begin; I >= end; I = 2 - I)
|
||||
++I;
|
||||
// In the following example, we cannot update the loop variable using '+='
|
||||
// expected-error@+3 {{invalid operands to binary expression ('Iter0' and 'int')}}
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd
|
||||
for (Iter0 I = begin0; I < end0; ++I)
|
||||
++I;
|
||||
#pragma omp parallel
|
||||
// Initializer is constructor without params.
|
||||
// expected-error@+3 {{invalid operands to binary expression ('Iter0' and 'int')}}
|
||||
// expected-warning@+2 {{initialization clause of OpenMP for loop is not in canonical form ('var = init' or 'T var = init')}}
|
||||
#pragma omp masked taskloop simd
|
||||
for (Iter0 I; I < end0; ++I)
|
||||
++I;
|
||||
Iter1 begin1, end1;
|
||||
// expected-error@+4 {{invalid operands to binary expression ('Iter1' and 'Iter1')}}
|
||||
// expected-error@+3 {{could not calculate number of iterations calling 'operator-' with upper and lower loop bounds}}
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd
|
||||
for (Iter1 I = begin1; I < end1; ++I)
|
||||
++I;
|
||||
#pragma omp parallel
|
||||
// expected-note@+3 {{loop step is expected to be negative due to this condition}}
|
||||
// expected-error@+2 {{increment expression must cause 'I' to decrease on each iteration of OpenMP for loop}}
|
||||
#pragma omp masked taskloop simd
|
||||
for (Iter1 I = begin1; I >= end1; ++I)
|
||||
++I;
|
||||
#pragma omp parallel
|
||||
// expected-error@+5 {{invalid operands to binary expression ('Iter1' and 'float')}}
|
||||
// expected-error@+4 {{could not calculate number of iterations calling 'operator-' with upper and lower loop bounds}}
|
||||
// Initializer is constructor with all default params.
|
||||
// expected-warning@+2 {{initialization clause of OpenMP for loop is not in canonical form ('var = init' or 'T var = init')}}
|
||||
#pragma omp masked taskloop simd
|
||||
for (Iter1 I; I < end1; ++I) {
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
template <typename IT, int ST>
|
||||
class TC {
|
||||
public:
|
||||
int dotest_lt(IT begin, IT end) {
|
||||
#pragma omp parallel
|
||||
// expected-note@+3 {{loop step is expected to be positive due to this condition}}
|
||||
// expected-error@+2 {{increment expression must cause 'I' to increase on each iteration of OpenMP for loop}}
|
||||
#pragma omp masked taskloop simd
|
||||
for (IT I = begin; I < end; I = I + ST) {
|
||||
++I;
|
||||
}
|
||||
#pragma omp parallel
|
||||
// expected-note@+3 {{loop step is expected to be positive due to this condition}}
|
||||
// expected-error@+2 {{increment expression must cause 'I' to increase on each iteration of OpenMP for loop}}
|
||||
#pragma omp masked taskloop simd
|
||||
for (IT I = begin; I <= end; I += ST) {
|
||||
++I;
|
||||
}
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd
|
||||
for (IT I = begin; I < end; ++I) {
|
||||
++I;
|
||||
}
|
||||
}
|
||||
|
||||
static IT step() {
|
||||
return IT(ST);
|
||||
}
|
||||
};
|
||||
template <typename IT, int ST = 0>
|
||||
int dotest_gt(IT begin, IT end) {
|
||||
#pragma omp parallel
|
||||
// expected-note@+3 2 {{loop step is expected to be negative due to this condition}}
|
||||
// expected-error@+2 2 {{increment expression must cause 'I' to decrease on each iteration of OpenMP for loop}}
|
||||
#pragma omp masked taskloop simd
|
||||
for (IT I = begin; I >= end; I = I + ST) {
|
||||
++I;
|
||||
}
|
||||
#pragma omp parallel
|
||||
// expected-note@+3 2 {{loop step is expected to be negative due to this condition}}
|
||||
// expected-error@+2 2 {{increment expression must cause 'I' to decrease on each iteration of OpenMP for loop}}
|
||||
#pragma omp masked taskloop simd
|
||||
for (IT I = begin; I >= end; I += ST) {
|
||||
++I;
|
||||
}
|
||||
|
||||
#pragma omp parallel
|
||||
// expected-note@+3 {{loop step is expected to be negative due to this condition}}
|
||||
// expected-error@+2 {{increment expression must cause 'I' to decrease on each iteration of OpenMP for loop}}
|
||||
#pragma omp masked taskloop simd
|
||||
for (IT I = begin; I >= end; ++I) {
|
||||
++I;
|
||||
}
|
||||
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd
|
||||
for (IT I = begin; I < end; I += TC<int, ST>::step()) {
|
||||
++I;
|
||||
}
|
||||
}
|
||||
|
||||
void test_with_template() {
|
||||
GoodIter begin, end;
|
||||
TC<GoodIter, 100> t1;
|
||||
TC<GoodIter, -100> t2;
|
||||
t1.dotest_lt(begin, end);
|
||||
t2.dotest_lt(begin, end); // expected-note {{in instantiation of member function 'TC<GoodIter, -100>::dotest_lt' requested here}}
|
||||
dotest_gt(begin, end); // expected-note {{in instantiation of function template specialization 'dotest_gt<GoodIter, 0>' requested here}}
|
||||
dotest_gt<unsigned, 10>(0, 100); // expected-note {{in instantiation of function template specialization 'dotest_gt<unsigned int, 10>' requested here}}
|
||||
}
|
||||
|
||||
void test_loop_break() {
|
||||
const int N = 100;
|
||||
float a[N], b[N], c[N];
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd
|
||||
for (int i = 0; i < 10; i++) {
|
||||
c[i] = a[i] + b[i];
|
||||
for (int j = 0; j < 10; ++j) {
|
||||
if (a[i] > b[j])
|
||||
break; // OK in nested loop
|
||||
}
|
||||
switch (i) {
|
||||
case 1:
|
||||
b[i]++;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
if (c[i] > 10)
|
||||
break; // expected-error {{'break' statement cannot be used in OpenMP for loop}}
|
||||
|
||||
if (c[i] > 11)
|
||||
break; // expected-error {{'break' statement cannot be used in OpenMP for loop}}
|
||||
}
|
||||
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd
|
||||
for (int i = 0; i < 10; i++) {
|
||||
for (int j = 0; j < 10; j++) {
|
||||
c[i] = a[i] + b[i];
|
||||
if (c[i] > 10) {
|
||||
if (c[i] < 20) {
|
||||
break; // OK
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void test_loop_eh() {
|
||||
const int N = 100;
|
||||
float a[N], b[N], c[N];
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd
|
||||
for (int i = 0; i < 10; i++) {
|
||||
c[i] = a[i] + b[i];
|
||||
try { // expected-error {{'try' statement cannot be used in OpenMP simd region}}
|
||||
for (int j = 0; j < 10; ++j) {
|
||||
if (a[i] > b[j])
|
||||
throw a[i]; // expected-error {{'throw' statement cannot be used in OpenMP simd region}}
|
||||
}
|
||||
throw a[i]; // expected-error {{'throw' statement cannot be used in OpenMP simd region}}
|
||||
} catch (float f) {
|
||||
if (f > 0.1)
|
||||
throw a[i]; // expected-error {{'throw' statement cannot be used in OpenMP simd region}}
|
||||
return; // expected-error {{cannot return from OpenMP region}}
|
||||
}
|
||||
switch (i) {
|
||||
case 1:
|
||||
b[i]++;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
for (int j = 0; j < 10; j++) {
|
||||
if (c[i] > 10)
|
||||
throw c[i]; // expected-error {{'throw' statement cannot be used in OpenMP simd region}}
|
||||
}
|
||||
}
|
||||
if (c[9] > 10)
|
||||
throw c[9]; // OK
|
||||
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd
|
||||
for (int i = 0; i < 10; ++i) {
|
||||
struct S {
|
||||
void g() { throw 0; }
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
void test_loop_firstprivate_lastprivate() {
|
||||
S s(4);
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd lastprivate(s) firstprivate(s)
|
||||
for (int i = 0; i < 16; ++i)
|
||||
;
|
||||
}
|
||||
|
||||
104
clang/test/OpenMP/masked_taskloop_simd_num_tasks_messages.cpp
Normal file
104
clang/test/OpenMP/masked_taskloop_simd_num_tasks_messages.cpp
Normal file
@ -0,0 +1,104 @@
|
||||
// RUN: %clang_cc1 -verify -fopenmp -ferror-limit 100 %s -Wuninitialized
|
||||
|
||||
// RUN: %clang_cc1 -verify -fopenmp-simd -ferror-limit 100 %s -Wuninitialized
|
||||
|
||||
void foo() {
|
||||
}
|
||||
|
||||
bool foobool(int argc) {
|
||||
return argc;
|
||||
}
|
||||
|
||||
struct S1; // expected-note {{declared here}}
|
||||
|
||||
template <class T, class S> // expected-note {{declared here}}
|
||||
int tmain(T argc, S **argv) {
|
||||
T z;
|
||||
#pragma omp masked taskloop simd num_tasks // expected-error {{expected '(' after 'num_tasks'}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd num_tasks ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd num_tasks () // expected-error {{expected expression}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd num_tasks (argc // expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd num_tasks (argc)) // expected-warning {{extra tokens at the end of '#pragma omp masked taskloop simd' are ignored}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd num_tasks (argc > 0 ? argv[1][0] : argv[2][argc] + z)
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd num_tasks (foobool(argc)), num_tasks (true) // expected-error {{directive '#pragma omp masked taskloop simd' cannot contain more than one 'num_tasks' clause}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd num_tasks (S) // expected-error {{'S' does not refer to a value}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd num_tasks (argc argc) // expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd num_tasks(0) // expected-error {{argument to 'num_tasks' clause must be a strictly positive integer value}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd num_tasks(-1) // expected-error {{argument to 'num_tasks' clause must be a strictly positive integer value}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd num_tasks(argc) grainsize(argc) // expected-error {{'grainsize' and 'num_tasks' clause are mutually exclusive and may not appear on the same directive}} expected-note {{'num_tasks' clause is specified here}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int main(int argc, char **argv) {
|
||||
int z;
|
||||
int tid = 0;
|
||||
#pragma omp masked taskloop simd num_tasks filter(tid) // expected-error {{expected '(' after 'num_tasks'}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd num_tasks ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd num_tasks () // expected-error {{expected expression}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd num_tasks (argc // expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd num_tasks (argc)) // expected-warning {{extra tokens at the end of '#pragma omp masked taskloop simd' are ignored}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd num_tasks (argc > 0 ? argv[1][0] : argv[2][argc] - z)
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd num_tasks (foobool(argc)), num_tasks (true) // expected-error {{directive '#pragma omp masked taskloop simd' cannot contain more than one 'num_tasks' clause}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd num_tasks (S1) // expected-error {{'S1' does not refer to a value}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd num_tasks (argc argc) // expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd num_tasks (1 0) // expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd num_tasks(if(tmain(argc, argv) // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd num_tasks(0) // expected-error {{argument to 'num_tasks' clause must be a strictly positive integer value}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd num_tasks(-1) // expected-error {{argument to 'num_tasks' clause must be a strictly positive integer value}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd num_tasks(argc) grainsize(argc) // expected-error {{'grainsize' and 'num_tasks' clause are mutually exclusive and may not appear on the same directive}} expected-note {{'num_tasks' clause is specified here}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
|
||||
return tmain(argc, argv);
|
||||
}
|
||||
98
clang/test/OpenMP/masked_taskloop_simd_priority_messages.cpp
Normal file
98
clang/test/OpenMP/masked_taskloop_simd_priority_messages.cpp
Normal file
@ -0,0 +1,98 @@
|
||||
// RUN: %clang_cc1 -verify -fopenmp -ferror-limit 100 %s -Wuninitialized
|
||||
|
||||
// RUN: %clang_cc1 -verify -fopenmp-simd -ferror-limit 100 %s -Wuninitialized
|
||||
|
||||
void foo() {
|
||||
}
|
||||
|
||||
bool foobool(int argc) {
|
||||
return argc;
|
||||
}
|
||||
|
||||
struct S1; // expected-note {{declared here}}
|
||||
|
||||
template <class T, class S> // expected-note {{declared here}}
|
||||
int tmain(T argc, S **argv) {
|
||||
T z;
|
||||
#pragma omp masked taskloop simd priority // expected-error {{expected '(' after 'priority'}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd priority ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd priority () // expected-error {{expected expression}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd priority (argc // expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd priority (argc + z)) // expected-warning {{extra tokens at the end of '#pragma omp masked taskloop simd' are ignored}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd priority (argc > 0 ? argv[1][0] : argv[2][argc])
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd priority (foobool(argc)), priority (true) // expected-error {{directive '#pragma omp masked taskloop simd' cannot contain more than one 'priority' clause}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd priority (S) // expected-error {{'S' does not refer to a value}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd priority (argc argc) // expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd priority(0)
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd priority(-1) // expected-error {{argument to 'priority' clause must be a non-negative integer value}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int main(int argc, char **argv) {
|
||||
int tid = 0;
|
||||
int z;
|
||||
#pragma omp masked taskloop simd priority filter(tid) // expected-error {{expected '(' after 'priority'}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd priority ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd priority () // expected-error {{expected expression}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd priority (argc // expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd priority (argc + z)) // expected-warning {{extra tokens at the end of '#pragma omp masked taskloop simd' are ignored}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd priority (argc > 0 ? argv[1][0] : argv[2][argc])
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd priority (foobool(argc)), priority (true) // expected-error {{directive '#pragma omp masked taskloop simd' cannot contain more than one 'priority' clause}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd priority (S1) // expected-error {{'S1' does not refer to a value}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd priority (argc argc) // expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd priority (1 0) // expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd priority(if(tmain(argc, argv) // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd priority(0)
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd priority(-1) // expected-error {{argument to 'priority' clause must be a non-negative integer value}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
|
||||
return tmain(argc, argv);
|
||||
}
|
||||
261
clang/test/OpenMP/masked_taskloop_simd_private_messages.cpp
Normal file
261
clang/test/OpenMP/masked_taskloop_simd_private_messages.cpp
Normal file
@ -0,0 +1,261 @@
|
||||
// RUN: %clang_cc1 -verify -fopenmp %s -Wuninitialized
|
||||
|
||||
// RUN: %clang_cc1 -verify -fopenmp-simd %s -Wuninitialized
|
||||
|
||||
typedef void **omp_allocator_handle_t;
|
||||
extern const omp_allocator_handle_t omp_null_allocator;
|
||||
extern const omp_allocator_handle_t omp_default_mem_alloc;
|
||||
extern const omp_allocator_handle_t omp_large_cap_mem_alloc;
|
||||
extern const omp_allocator_handle_t omp_const_mem_alloc;
|
||||
extern const omp_allocator_handle_t omp_high_bw_mem_alloc;
|
||||
extern const omp_allocator_handle_t omp_low_lat_mem_alloc;
|
||||
extern const omp_allocator_handle_t omp_cgroup_mem_alloc;
|
||||
extern const omp_allocator_handle_t omp_pteam_mem_alloc;
|
||||
extern const omp_allocator_handle_t omp_thread_mem_alloc;
|
||||
|
||||
void foo() {
|
||||
}
|
||||
|
||||
bool foobool(int argc) {
|
||||
return argc;
|
||||
}
|
||||
|
||||
struct S1; // expected-note 2 {{declared here}} expected-note 2 {{forward declaration of 'S1'}}
|
||||
extern S1 a;
|
||||
class S2 {
|
||||
mutable int a;
|
||||
|
||||
public:
|
||||
S2() : a(0) {}
|
||||
};
|
||||
const S2 b;
|
||||
const S2 ba[5];
|
||||
class S3 {
|
||||
int a;
|
||||
|
||||
public:
|
||||
S3() : a(0) {}
|
||||
};
|
||||
const S3 ca[5];
|
||||
class S4 {
|
||||
int a;
|
||||
S4(); // expected-note {{implicitly declared private here}}
|
||||
|
||||
public:
|
||||
S4(int v) : a(v) {
|
||||
#pragma omp masked taskloop simd private(a) private(this->a)
|
||||
for (int k = 0; k < v; ++k)
|
||||
++this->a;
|
||||
}
|
||||
};
|
||||
class S5 {
|
||||
int a;
|
||||
S5() : a(0) {} // expected-note {{implicitly declared private here}}
|
||||
|
||||
public:
|
||||
S5(int v) : a(v) {}
|
||||
S5 &operator=(S5 &s) {
|
||||
#pragma omp masked taskloop simd private(a) private(this->a) private(s.a) // expected-error {{expected variable name or data member of current class}}
|
||||
for (int k = 0; k < s.a; ++k)
|
||||
++s.a;
|
||||
return *this;
|
||||
}
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
class S6 {
|
||||
public:
|
||||
T a;
|
||||
|
||||
S6() : a(0) {}
|
||||
S6(T v) : a(v) {
|
||||
#pragma omp masked taskloop simd allocate(omp_thread_mem_alloc: a) private(a) private(this->a) // expected-warning {{allocator with the 'thread' trait access has unspecified behavior on 'masked taskloop simd' directive}}
|
||||
for (int k = 0; k < v; ++k)
|
||||
++this->a;
|
||||
}
|
||||
S6 &operator=(S6 &s) {
|
||||
#pragma omp masked taskloop simd private(a) private(this->a) private(s.a) // expected-error {{expected variable name or data member of current class}}
|
||||
for (int k = 0; k < s.a; ++k)
|
||||
++s.a;
|
||||
return *this;
|
||||
}
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
class S7 : public T {
|
||||
T a;
|
||||
S7() : a(0) {}
|
||||
|
||||
public:
|
||||
S7(T v) : a(v) {
|
||||
#pragma omp masked taskloop simd private(a) private(this->a) private(T::a)
|
||||
for (int k = 0; k < a.a; ++k)
|
||||
++this->a.a;
|
||||
}
|
||||
S7 &operator=(S7 &s) {
|
||||
#pragma omp masked taskloop simd private(a) private(this->a) private(s.a) private(s.T::a) // expected-error 2 {{expected variable name or data member of current class}}
|
||||
for (int k = 0; k < s.a.a; ++k)
|
||||
++s.a.a;
|
||||
return *this;
|
||||
}
|
||||
};
|
||||
|
||||
S3 h;
|
||||
#pragma omp threadprivate(h) // expected-note 2 {{defined as threadprivate or thread local}}
|
||||
|
||||
template <class I, class C>
|
||||
int foomain(I argc, C **argv) {
|
||||
I e(4);
|
||||
I g(5);
|
||||
int i, z;
|
||||
int &j = i;
|
||||
#pragma omp masked taskloop simd private // expected-error {{expected '(' after 'private'}}
|
||||
for (int k = 0; k < argc; ++k)
|
||||
++k;
|
||||
#pragma omp masked taskloop simd private( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int k = 0; k < argc; ++k)
|
||||
++k;
|
||||
#pragma omp masked taskloop simd private() // expected-error {{expected expression}}
|
||||
for (int k = 0; k < argc; ++k)
|
||||
++k;
|
||||
#pragma omp masked taskloop simd private(argc // expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int k = 0; k < argc; ++k)
|
||||
++k;
|
||||
#pragma omp masked taskloop simd private(argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int k = 0; k < argc; ++k)
|
||||
++k;
|
||||
#pragma omp masked taskloop simd private(argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}}
|
||||
for (int k = 0; k < argc; ++k)
|
||||
++k;
|
||||
#pragma omp masked taskloop simd private(argc) allocate , allocate(, allocate(omp_default , allocate(omp_default_mem_alloc, allocate(omp_default_mem_alloc:, allocate(omp_default_mem_alloc: argc, allocate(omp_default_mem_alloc: argv), allocate(argv) // expected-error {{expected '(' after 'allocate'}} expected-error 2 {{expected expression}} expected-error 2 {{expected ')'}} expected-error {{use of undeclared identifier 'omp_default'}} expected-note 2 {{to match this '('}}
|
||||
for (int k = 0; k < argc; ++k)
|
||||
++k;
|
||||
#pragma omp masked taskloop simd private(S1) // expected-error {{'S1' does not refer to a value}}
|
||||
for (int k = 0; k < argc; ++k)
|
||||
++k;
|
||||
#pragma omp masked taskloop simd private(a, b) // expected-error {{private variable with incomplete type 'S1'}}
|
||||
for (int k = 0; k < argc; ++k)
|
||||
++k;
|
||||
#pragma omp masked taskloop simd private(argv[1]) // expected-error {{expected variable name}}
|
||||
for (int k = 0; k < argc; ++k)
|
||||
++k;
|
||||
#pragma omp masked taskloop simd private(e, g, z)
|
||||
for (int k = 0; k < argc; ++k)
|
||||
++k;
|
||||
#pragma omp masked taskloop simd private(h) // expected-error {{threadprivate or thread local variable cannot be private}}
|
||||
for (int k = 0; k < argc; ++k)
|
||||
++k;
|
||||
#pragma omp masked taskloop simd shared(i)
|
||||
for (int k = 0; k < argc; ++k)
|
||||
++k;
|
||||
#pragma omp parallel
|
||||
{
|
||||
int v = 0;
|
||||
int i;
|
||||
#pragma omp masked taskloop simd private(i)
|
||||
for (int k = 0; k < argc; ++k) {
|
||||
i = k;
|
||||
v += i;
|
||||
}
|
||||
}
|
||||
#pragma omp parallel shared(i)
|
||||
#pragma omp parallel private(i)
|
||||
#pragma omp masked taskloop simd private(j)
|
||||
for (int k = 0; k < argc; ++k)
|
||||
++k;
|
||||
#pragma omp masked taskloop simd private(i)
|
||||
for (int k = 0; k < argc; ++k)
|
||||
++k;
|
||||
return 0;
|
||||
}
|
||||
|
||||
void bar(S4 a[2]) {
|
||||
#pragma omp parallel
|
||||
#pragma omp masked taskloop simd private(a)
|
||||
for (int i = 0; i < 2; ++i)
|
||||
foo();
|
||||
}
|
||||
|
||||
namespace A {
|
||||
double x;
|
||||
#pragma omp threadprivate(x) // expected-note {{defined as threadprivate or thread local}}
|
||||
}
|
||||
namespace B {
|
||||
using A::x;
|
||||
}
|
||||
|
||||
int main(int argc, char **argv) {
|
||||
S4 e(4);
|
||||
S5 g(5);
|
||||
S6<float> s6(0.0) , s6_0(1.0); // expected-note {{in instantiation of member function 'S6<float>::S6' requested here}}
|
||||
S7<S6<float> > s7(0.0) , s7_0(1.0);
|
||||
int i, z;
|
||||
int &j = i;
|
||||
int tid = 0;
|
||||
#pragma omp masked taskloop simd private filter(tid) // expected-error {{expected '(' after 'private'}}
|
||||
for (int k = 0; k < argc; ++k)
|
||||
++k;
|
||||
#pragma omp masked taskloop simd private( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int k = 0; k < argc; ++k)
|
||||
++k;
|
||||
#pragma omp masked taskloop simd private() // expected-error {{expected expression}}
|
||||
for (int k = 0; k < argc; ++k)
|
||||
++k;
|
||||
#pragma omp masked taskloop simd private(argc // expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int k = 0; k < argc; ++k)
|
||||
++k;
|
||||
#pragma omp masked taskloop simd private(argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int k = 0; k < argc; ++k)
|
||||
++k;
|
||||
#pragma omp masked taskloop simd private(argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name}}
|
||||
for (int k = 0; k < argc; ++k)
|
||||
++k;
|
||||
#pragma omp masked taskloop simd private(argc, z)
|
||||
for (int k = 0; k < argc; ++k)
|
||||
++k;
|
||||
#pragma omp masked taskloop simd private(S1) // expected-error {{'S1' does not refer to a value}}
|
||||
for (int k = 0; k < argc; ++k)
|
||||
++k;
|
||||
#pragma omp masked taskloop simd private(a, b) // expected-error {{private variable with incomplete type 'S1'}}
|
||||
for (int k = 0; k < argc; ++k)
|
||||
++k;
|
||||
#pragma omp masked taskloop simd private(argv[1]) // expected-error {{expected variable name}}
|
||||
for (int k = 0; k < argc; ++k)
|
||||
++k;
|
||||
#pragma omp masked taskloop simd private(e, g) // expected-error {{calling a private constructor of class 'S4'}} expected-error {{calling a private constructor of class 'S5'}}
|
||||
for (int k = 0; k < argc; ++k)
|
||||
++k;
|
||||
#pragma omp masked taskloop simd private(h) // expected-error {{threadprivate or thread local variable cannot be private}}
|
||||
for (int k = 0; k < argc; ++k)
|
||||
++k;
|
||||
#pragma omp masked taskloop simd private(B::x) // expected-error {{threadprivate or thread local variable cannot be private}}
|
||||
for (int k = 0; k < argc; ++k)
|
||||
++k;
|
||||
#pragma omp masked taskloop simd shared(i)
|
||||
for (int k = 0; k < argc; ++k)
|
||||
++k;
|
||||
#pragma omp parallel
|
||||
{
|
||||
int i;
|
||||
#pragma omp masked taskloop simd private(i)
|
||||
for (int k = 0; k < argc; ++k)
|
||||
++k;
|
||||
}
|
||||
#pragma omp parallel shared(i)
|
||||
#pragma omp parallel private(i)
|
||||
#pragma omp masked taskloop simd private(j)
|
||||
for (int k = 0; k < argc; ++k)
|
||||
++k;
|
||||
#pragma omp masked taskloop simd private(i)
|
||||
for (int k = 0; k < argc; ++k)
|
||||
++k;
|
||||
static int si;
|
||||
#pragma omp masked taskloop simd private(si) // OK
|
||||
for(int k = 0; k < argc; ++k)
|
||||
si = k + 1;
|
||||
|
||||
s6 = s6_0; // expected-note {{in instantiation of member function 'S6<float>::operator=' requested here}}
|
||||
s7 = s7_0; // expected-note {{in instantiation of member function 'S7<S6<float>>::operator=' requested here}}
|
||||
return foomain(argc, argv); // expected-note {{in instantiation of function template specialization 'foomain<int, char>' requested here}}
|
||||
}
|
||||
|
||||
363
clang/test/OpenMP/masked_taskloop_simd_reduction_messages.cpp
Normal file
363
clang/test/OpenMP/masked_taskloop_simd_reduction_messages.cpp
Normal file
@ -0,0 +1,363 @@
|
||||
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -ferror-limit 150 -o - %s -Wuninitialized
|
||||
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized
|
||||
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp -fopenmp-version=45 -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
|
||||
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -ferror-limit 150 -o - %s -Wuninitialized
|
||||
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized
|
||||
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
|
||||
|
||||
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -ferror-limit 150 -o - %s -Wuninitialized
|
||||
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized
|
||||
// RUN: %clang_cc1 -verify=expected,omp45 -fopenmp-simd -fopenmp-version=45 -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
|
||||
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -ferror-limit 150 -o - %s -Wuninitialized
|
||||
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -std=c++98 -ferror-limit 150 -o - %s -Wuninitialized
|
||||
// RUN: %clang_cc1 -verify=expected,omp50 -fopenmp-simd -std=c++11 -ferror-limit 150 -o - %s -Wuninitialized
|
||||
|
||||
typedef void **omp_allocator_handle_t;
|
||||
extern const omp_allocator_handle_t omp_null_allocator;
|
||||
extern const omp_allocator_handle_t omp_default_mem_alloc;
|
||||
extern const omp_allocator_handle_t omp_large_cap_mem_alloc;
|
||||
extern const omp_allocator_handle_t omp_const_mem_alloc;
|
||||
extern const omp_allocator_handle_t omp_high_bw_mem_alloc;
|
||||
extern const omp_allocator_handle_t omp_low_lat_mem_alloc;
|
||||
extern const omp_allocator_handle_t omp_cgroup_mem_alloc;
|
||||
extern const omp_allocator_handle_t omp_pteam_mem_alloc;
|
||||
extern const omp_allocator_handle_t omp_thread_mem_alloc;
|
||||
|
||||
void xxx(int argc) {
|
||||
int fp; // expected-note {{initialize the variable 'fp' to silence this warning}}
|
||||
#pragma omp masked taskloop simd reduction(+:fp) // expected-warning {{variable 'fp' is uninitialized when used here}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
;
|
||||
}
|
||||
|
||||
void foo() {
|
||||
}
|
||||
|
||||
bool foobool(int argc) {
|
||||
return argc;
|
||||
}
|
||||
|
||||
void foobar(int &ref) {
|
||||
#pragma omp masked taskloop simd reduction(+:ref)
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
}
|
||||
|
||||
struct S1; // expected-note {{declared here}} expected-note 4 {{forward declaration of 'S1'}}
|
||||
extern S1 a;
|
||||
class S2 {
|
||||
mutable int a;
|
||||
S2 &operator+(const S2 &arg) { return (*this); } // expected-note 3 {{implicitly declared private here}}
|
||||
|
||||
public:
|
||||
S2() : a(0) {}
|
||||
S2(S2 &s2) : a(s2.a) {}
|
||||
static float S2s; // expected-note 2 {{static data member is predetermined as shared}}
|
||||
static const float S2sc; // expected-note 2 {{'S2sc' declared here}}
|
||||
};
|
||||
const float S2::S2sc = 0;
|
||||
S2 b; // expected-note 3 {{'b' defined here}}
|
||||
const S2 ba[5]; // expected-note 2 {{'ba' defined here}}
|
||||
class S3 {
|
||||
int a;
|
||||
|
||||
public:
|
||||
int b;
|
||||
S3() : a(0) {}
|
||||
S3(const S3 &s3) : a(s3.a) {}
|
||||
S3 operator+(const S3 &arg1) { return arg1; }
|
||||
};
|
||||
int operator+(const S3 &arg1, const S3 &arg2) { return 5; }
|
||||
S3 c; // expected-note 3 {{'c' defined here}}
|
||||
const S3 ca[5]; // expected-note 2 {{'ca' defined here}}
|
||||
extern const int f; // expected-note 4 {{'f' declared here}}
|
||||
class S4 {
|
||||
int a;
|
||||
S4(); // expected-note {{implicitly declared private here}}
|
||||
S4(const S4 &s4);
|
||||
S4 &operator+(const S4 &arg) { return (*this); }
|
||||
|
||||
public:
|
||||
S4(int v) : a(v) {}
|
||||
};
|
||||
S4 &operator&=(S4 &arg1, S4 &arg2) { return arg1; }
|
||||
class S5 {
|
||||
int a;
|
||||
S5() : a(0) {} // expected-note {{implicitly declared private here}}
|
||||
S5(const S5 &s5) : a(s5.a) {}
|
||||
S5 &operator+(const S5 &arg);
|
||||
|
||||
public:
|
||||
S5(int v) : a(v) {}
|
||||
};
|
||||
class S6 { // expected-note 3 {{candidate function (the implicit copy assignment operator) not viable: no known conversion from 'int' to 'const S6' for 1st argument}}
|
||||
#if __cplusplus >= 201103L // C++11 or later
|
||||
// expected-note@-2 3 {{candidate function (the implicit move assignment operator) not viable}}
|
||||
#endif
|
||||
int a;
|
||||
|
||||
public:
|
||||
S6() : a(6) {}
|
||||
operator int() { return 6; }
|
||||
} o;
|
||||
|
||||
struct S7 {
|
||||
int a: 32;
|
||||
S7() {
|
||||
#pragma omp taskloop reduction(+:a) // expected-error {{expected addressable reduction item for the task-based directives}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
++a;
|
||||
}
|
||||
};
|
||||
|
||||
S3 h, k;
|
||||
#pragma omp threadprivate(h) // expected-note 2 {{defined as threadprivate or thread local}}
|
||||
|
||||
template <class T> // expected-note {{declared here}}
|
||||
T tmain(T argc) {
|
||||
const T d = T(); // expected-note 4 {{'d' defined here}}
|
||||
const T da[5] = {T()}; // expected-note 2 {{'da' defined here}}
|
||||
T qa[5] = {T()};
|
||||
T i, z;
|
||||
T &j = i; // expected-note 4 {{'j' defined here}}
|
||||
S3 &p = k; // expected-note 2 {{'p' defined here}}
|
||||
const T &r = da[(int)i]; // expected-note 2 {{'r' defined here}}
|
||||
T &q = qa[(int)i]; // expected-note 2 {{'q' defined here}}
|
||||
T fl;
|
||||
#pragma omp masked taskloop simd reduction // expected-error {{expected '(' after 'reduction'}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd reduction + // expected-error {{expected '(' after 'reduction'}} expected-warning {{extra tokens at the end of '#pragma omp masked taskloop simd' are ignored}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd reduction( // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd reduction(- // expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd reduction() // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd reduction(*) // expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected expression}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd reduction(\) // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd reduction(& : argc // expected-error {{expected ')'}} expected-note {{to match this '('}} expected-error {{invalid operands to binary expression ('float' and 'float')}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd reduction(| : argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}} expected-error {{invalid operands to binary expression ('float' and 'float')}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd reduction(|| : argc ? i : argc) // expected-error 2 {{expected variable name, array element or array section}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd reduction(foo : argc) //expected-error {{incorrect reduction identifier, expected one of '+', '-', '*', '&', '|', '^', '&&', '||', 'min' or 'max' or declare reduction for type 'float'}} expected-error {{incorrect reduction identifier, expected one of '+', '-', '*', '&', '|', '^', '&&', '||', 'min' or 'max' or declare reduction for type 'int'}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd reduction(&& : argc) allocate , allocate(, allocate(omp_default , allocate(omp_default_mem_alloc, allocate(omp_default_mem_alloc:, allocate(omp_default_mem_alloc: argc, allocate(omp_default_mem_alloc: argv), allocate(argv) // expected-error {{expected '(' after 'allocate'}} expected-error 2 {{expected expression}} expected-error 2 {{expected ')'}} expected-error {{use of undeclared identifier 'omp_default'}} expected-note 2 {{to match this '('}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd reduction(^ : T) // expected-error {{'T' does not refer to a value}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd reduction(+ : a, b, c, d, f) // expected-error {{a reduction list item with incomplete type 'S1'}} expected-error 3 {{const-qualified variable cannot be reduction}} expected-error 2 {{'operator+' is a private member of 'S2'}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd reduction(min : a, b, c, d, f) // expected-error {{a reduction list item with incomplete type 'S1'}} expected-error 4 {{arguments of OpenMP clause 'reduction' for 'min' or 'max' must be of arithmetic type}} expected-error 3 {{const-qualified variable cannot be reduction}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd reduction(max : h.b) // expected-error {{expected variable name, array element or array section}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd reduction(+ : ba) // expected-error {{const-qualified variable cannot be reduction}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd reduction(* : z, ca) // expected-error {{const-qualified variable cannot be reduction}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd reduction(- : da) // expected-error {{const-qualified variable cannot be reduction}} expected-error {{const-qualified variable cannot be reduction}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd reduction(^ : fl) // expected-error {{invalid operands to binary expression ('float' and 'float')}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd reduction(&& : S2::S2s) // expected-error {{shared variable cannot be reduction}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd reduction(&& : S2::S2sc) // expected-error {{const-qualified variable cannot be reduction}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd reduction(+ : h, k) // expected-error {{threadprivate or thread local variable cannot be reduction}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd reduction(+ : o) // expected-error 2 {{no viable overloaded '='}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd private(i), reduction(+ : j), reduction(+ : q) // expected-error 4 {{argument of OpenMP clause 'reduction' must reference the same object in all threads}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp parallel private(k)
|
||||
#pragma omp masked taskloop simd reduction(+ : p), reduction(+ : p) // expected-error 2 {{argument of OpenMP clause 'reduction' must reference the same object in all threads}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd reduction(+ : p), reduction(+ : p) // expected-error 2 {{variable can appear only once in OpenMP 'reduction' clause}} expected-note 2 {{previously referenced here}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd reduction(+ : r) // expected-error 2 {{const-qualified variable cannot be reduction}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp parallel shared(i)
|
||||
#pragma omp parallel reduction(min : i)
|
||||
#pragma omp masked taskloop simd reduction(max : j) // expected-error 2 {{argument of OpenMP clause 'reduction' must reference the same object in all threads}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp parallel private(fl)
|
||||
#pragma omp masked taskloop simd reduction(+ : fl) allocate(omp_thread_mem_alloc: fl) // expected-warning 2 {{allocator with the 'thread' trait access has unspecified behavior on 'masked taskloop simd' directive}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp parallel reduction(* : fl)
|
||||
#pragma omp masked taskloop simd reduction(+ : fl)
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
|
||||
return T();
|
||||
}
|
||||
|
||||
namespace A {
|
||||
double x;
|
||||
#pragma omp threadprivate(x) // expected-note {{defined as threadprivate or thread local}}
|
||||
}
|
||||
namespace B {
|
||||
using A::x;
|
||||
}
|
||||
|
||||
int main(int argc, char **argv) {
|
||||
const int d = 5; // expected-note 2 {{'d' defined here}}
|
||||
const int da[5] = {0}; // expected-note {{'da' defined here}}
|
||||
int qa[5] = {0};
|
||||
S4 e(4);
|
||||
S5 g(5);
|
||||
int i, z;
|
||||
int &j = i; // expected-note 2 {{'j' defined here}}
|
||||
S3 &p = k; // expected-note 2 {{'p' defined here}}
|
||||
const int &r = da[i]; // expected-note {{'r' defined here}}
|
||||
int &q = qa[i]; // expected-note {{'q' defined here}}
|
||||
float fl;
|
||||
int tid = 0;
|
||||
#pragma omp masked taskloop simd reduction filter(tid) // expected-error {{expected '(' after 'reduction'}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd reduction + // expected-error {{expected '(' after 'reduction'}} expected-warning {{extra tokens at the end of '#pragma omp masked taskloop simd' are ignored}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd reduction( // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd reduction(- // expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd reduction() // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd reduction(*) // expected-warning {{missing ':' after reduction identifier - ignoring}} expected-error {{expected expression}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd reduction(\) // expected-error {{expected unqualified-id}} expected-warning {{missing ':' after reduction identifier - ignoring}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd reduction(foo : argc // expected-error {{expected ')'}} expected-note {{to match this '('}} expected-error {{incorrect reduction identifier, expected one of '+', '-', '*', '&', '|', '^', '&&', '||', 'min' or 'max'}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd reduction(| : argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd reduction(|| : argc > 0 ? argv[1] : argv[2]) // expected-error {{expected variable name, array element or array section}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd reduction(~ : argc) // expected-error {{expected unqualified-id}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd reduction(&& : argc, z)
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd reduction(^ : S1) // expected-error {{'S1' does not refer to a value}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd reduction(+ : a, b, c, d, f) // expected-error {{a reduction list item with incomplete type 'S1'}} expected-error 2 {{const-qualified variable cannot be reduction}} expected-error {{'operator+' is a private member of 'S2'}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd reduction(min : a, b, c, d, f) // expected-error {{a reduction list item with incomplete type 'S1'}} expected-error 2 {{arguments of OpenMP clause 'reduction' for 'min' or 'max' must be of arithmetic type}} expected-error 2 {{const-qualified variable cannot be reduction}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd reduction(max : h.b) // expected-error {{expected variable name, array element or array section}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd reduction(+ : ba) // expected-error {{const-qualified variable cannot be reduction}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd reduction(* : ca) // expected-error {{const-qualified variable cannot be reduction}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd reduction(- : da) // expected-error {{const-qualified variable cannot be reduction}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd reduction(^ : fl) // expected-error {{invalid operands to binary expression ('float' and 'float')}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd reduction(&& : S2::S2s) // expected-error {{shared variable cannot be reduction}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd reduction(&& : S2::S2sc) // expected-error {{const-qualified variable cannot be reduction}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd reduction(& : e, g) // expected-error {{calling a private constructor of class 'S4'}} expected-error {{calling a private constructor of class 'S5'}} expected-error {{invalid operands to binary expression ('S5' and 'S5')}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd reduction(+ : h, k, B::x) // expected-error 2 {{threadprivate or thread local variable cannot be reduction}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd reduction(+ : o) // expected-error {{no viable overloaded '='}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd private(i), reduction(+ : j), reduction(+ : q) // expected-error 2 {{argument of OpenMP clause 'reduction' must reference the same object in all threads}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp parallel private(k)
|
||||
#pragma omp masked taskloop simd reduction(+ : p), reduction(+ : p) // expected-error 2 {{argument of OpenMP clause 'reduction' must reference the same object in all threads}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd reduction(+ : p), reduction(+ : p) // expected-error {{variable can appear only once in OpenMP 'reduction' clause}} expected-note {{previously referenced here}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp masked taskloop simd reduction(+ : r) // expected-error {{const-qualified variable cannot be reduction}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp parallel shared(i)
|
||||
#pragma omp parallel reduction(min : i)
|
||||
#pragma omp masked taskloop simd reduction(max : j) // expected-error {{argument of OpenMP clause 'reduction' must reference the same object in all threads}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp parallel private(fl)
|
||||
#pragma omp masked taskloop simd reduction(+ : fl)
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
#pragma omp parallel reduction(* : fl)
|
||||
#pragma omp masked taskloop simd reduction(+ : fl)
|
||||
for (int i = 0; i < 10; ++i)
|
||||
foo();
|
||||
static int m;
|
||||
#pragma omp masked taskloop simd reduction(+ : m) // OK
|
||||
for (int i = 0; i < 10; ++i)
|
||||
m++;
|
||||
#pragma omp masked taskloop simd reduction(+ : m) nogroup // expected-error {{'reduction' clause cannot be used with 'nogroup' clause}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
m++;
|
||||
#pragma omp masked taskloop simd reduction(task, + : m) // omp45-error 2 {{expected expression}} omp45-warning {{missing ':' after reduction identifier - ignoring}} omp50-error {{'reduction' clause with 'task' modifier allowed only on non-simd parallel or worksharing constructs}}
|
||||
for (int i = 0; i < 10; ++i)
|
||||
m++;
|
||||
|
||||
return tmain(argc) + tmain(fl); // expected-note {{in instantiation of function template specialization 'tmain<int>' requested here}} expected-note {{in instantiation of function template specialization 'tmain<float>' requested here}}
|
||||
}
|
||||
96
clang/test/OpenMP/masked_taskloop_simd_safelen_messages.cpp
Normal file
96
clang/test/OpenMP/masked_taskloop_simd_safelen_messages.cpp
Normal file
@ -0,0 +1,96 @@
|
||||
// RUN: %clang_cc1 -verify -fopenmp %s -Wuninitialized
|
||||
// RUN: %clang_cc1 -verify -fopenmp -std=c++98 %s -Wuninitialized
|
||||
// RUN: %clang_cc1 -verify -fopenmp -std=c++11 %s -Wuninitialized
|
||||
|
||||
// RUN: %clang_cc1 -verify -fopenmp-simd %s -Wuninitialized
|
||||
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++98 %s -Wuninitialized
|
||||
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++11 %s -Wuninitialized
|
||||
|
||||
// expected-note@* 0+{{declared here}}
|
||||
|
||||
void foo() {
|
||||
}
|
||||
|
||||
bool foobool(int argc) {
|
||||
return argc;
|
||||
}
|
||||
|
||||
struct S1;
|
||||
|
||||
template <class T, typename S, int N, int ST>
|
||||
T tmain(T argc, S **argv) {
|
||||
#pragma omp masked taskloop simd safelen // expected-error {{expected '(' after 'safelen'}}
|
||||
for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST];
|
||||
#pragma omp masked taskloop simd safelen ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST];
|
||||
#pragma omp masked taskloop simd safelen () // expected-error {{expected expression}}
|
||||
for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST];
|
||||
// expected-error@+2 {{expected ')'}} expected-note@+2 {{to match this '('}}
|
||||
// expected-error@+1 2 {{integral constant expression}} expected-note@+1 0+{{constant expression}}
|
||||
#pragma omp masked taskloop simd safelen (argc
|
||||
for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST];
|
||||
// expected-error@+1 {{argument to 'safelen' clause must be a strictly positive integer value}}
|
||||
#pragma omp masked taskloop simd safelen (ST // expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST];
|
||||
#pragma omp masked taskloop simd safelen (1)) // expected-warning {{extra tokens at the end of '#pragma omp masked taskloop simd' are ignored}}
|
||||
for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST];
|
||||
#pragma omp masked taskloop simd safelen ((ST > 0) ? 1 + ST : 2)
|
||||
for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST];
|
||||
// expected-error@+3 2 {{directive '#pragma omp masked taskloop simd' cannot contain more than one 'safelen' clause}}
|
||||
// expected-error@+2 {{argument to 'safelen' clause must be a strictly positive integer value}}
|
||||
// expected-error@+1 2 {{integral constant expression}} expected-note@+1 0+{{constant expression}}
|
||||
#pragma omp masked taskloop simd safelen (foobool(argc)), safelen (true), safelen (-5)
|
||||
for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST];
|
||||
#pragma omp masked taskloop simd safelen (S) // expected-error {{'S' does not refer to a value}}
|
||||
for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST];
|
||||
#if __cplusplus <= 199711L
|
||||
// expected-error@+4 2 {{integral constant expression}} expected-note@+4 0+{{constant expression}}
|
||||
#else
|
||||
// expected-error@+2 2 {{integral constant expression must have integral or unscoped enumeration type, not 'char *'}}
|
||||
#endif
|
||||
#pragma omp masked taskloop simd safelen (argv[1]=2) // expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST];
|
||||
#pragma omp masked taskloop simd safelen (4)
|
||||
for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST];
|
||||
#pragma omp masked taskloop simd safelen (N) // expected-error {{argument to 'safelen' clause must be a strictly positive integer value}}
|
||||
for (T i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST];
|
||||
return argc;
|
||||
}
|
||||
|
||||
int main(int argc, char **argv) {
|
||||
int tid = 0;
|
||||
#pragma omp masked taskloop simd safelen filter(tid) // expected-error {{expected '(' after 'safelen'}}
|
||||
for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4];
|
||||
#pragma omp masked taskloop simd safelen ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4];
|
||||
#pragma omp masked taskloop simd safelen () // expected-error {{expected expression}}
|
||||
for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4];
|
||||
#pragma omp masked taskloop simd safelen (4 // expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4];
|
||||
#pragma omp masked taskloop simd safelen (2+2)) // expected-warning {{extra tokens at the end of '#pragma omp masked taskloop simd' are ignored}}
|
||||
for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4];
|
||||
// expected-error@+1 {{integral constant expression}} expected-note@+1 0+{{constant expression}}
|
||||
#pragma omp masked taskloop simd safelen (foobool(1) > 0 ? 1 : 2)
|
||||
for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4];
|
||||
// expected-error@+3 {{integral constant expression}} expected-note@+3 0+{{constant expression}}
|
||||
// expected-error@+2 2 {{directive '#pragma omp masked taskloop simd' cannot contain more than one 'safelen' clause}}
|
||||
// expected-error@+1 {{argument to 'safelen' clause must be a strictly positive integer value}}
|
||||
#pragma omp masked taskloop simd safelen (foobool(argc)), safelen (true), safelen (-5)
|
||||
for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4];
|
||||
#pragma omp masked taskloop simd safelen (S1) // expected-error {{'S1' does not refer to a value}}
|
||||
for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4];
|
||||
#if __cplusplus <= 199711L
|
||||
// expected-error@+4 {{integral constant expression}} expected-note@+4 0+{{constant expression}}
|
||||
#else
|
||||
// expected-error@+2 {{integral constant expression must have integral or unscoped enumeration type, not 'char *'}}
|
||||
#endif
|
||||
#pragma omp masked taskloop simd safelen (argv[1]=2) // expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4];
|
||||
// expected-error@+3 {{statement after '#pragma omp masked taskloop simd' must be a for loop}}
|
||||
// expected-note@+1 {{in instantiation of function template specialization 'tmain<int, char, -1, -2>' requested here}}
|
||||
#pragma omp masked taskloop simd safelen(safelen(tmain<int, char, -1, -2>(argc, argv) // expected-error 2 {{expected ')'}} expected-note 2 {{to match this '('}}
|
||||
foo();
|
||||
// expected-note@+1 {{in instantiation of function template specialization 'tmain<int, char, 12, 4>' requested here}}
|
||||
return tmain<int, char, 12, 4>(argc, argv);
|
||||
}
|
||||
|
||||
96
clang/test/OpenMP/masked_taskloop_simd_simdlen_messages.cpp
Normal file
96
clang/test/OpenMP/masked_taskloop_simd_simdlen_messages.cpp
Normal file
@ -0,0 +1,96 @@
|
||||
// RUN: %clang_cc1 -verify -fopenmp %s -Wuninitialized
|
||||
// RUN: %clang_cc1 -verify -fopenmp -std=c++98 %s -Wuninitialized
|
||||
// RUN: %clang_cc1 -verify -fopenmp -std=c++11 %s -Wuninitialized
|
||||
|
||||
// RUN: %clang_cc1 -verify -fopenmp-simd %s -Wuninitialized
|
||||
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++98 %s -Wuninitialized
|
||||
// RUN: %clang_cc1 -verify -fopenmp-simd -std=c++11 %s -Wuninitialized
|
||||
|
||||
// expected-note@* 0+{{declared here}}
|
||||
|
||||
void foo() {
|
||||
}
|
||||
|
||||
bool foobool(int argc) {
|
||||
return argc;
|
||||
}
|
||||
|
||||
struct S1;
|
||||
|
||||
template <class T, typename S, int N, int ST>
|
||||
T tmain(T argc, S **argv) {
|
||||
#pragma omp masked taskloop simd simdlen // expected-error {{expected '(' after 'simdlen'}}
|
||||
for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST];
|
||||
#pragma omp masked taskloop simd simdlen ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST];
|
||||
#pragma omp masked taskloop simd simdlen () // expected-error {{expected expression}}
|
||||
for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST];
|
||||
// expected-error@+2 {{expected ')'}} expected-note@+2 {{to match this '('}}
|
||||
// expected-error@+1 2 {{integral constant expression}} expected-note@+1 0+{{constant expression}}
|
||||
#pragma omp masked taskloop simd simdlen (argc
|
||||
for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST];
|
||||
// expected-error@+1 {{argument to 'simdlen' clause must be a strictly positive integer value}}
|
||||
#pragma omp masked taskloop simd simdlen (ST // expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST];
|
||||
#pragma omp masked taskloop simd simdlen (1)) // expected-warning {{extra tokens at the end of '#pragma omp masked taskloop simd' are ignored}}
|
||||
for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST];
|
||||
#pragma omp masked taskloop simd simdlen ((ST > 0) ? 1 + ST : 2)
|
||||
for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST];
|
||||
// expected-error@+3 2 {{directive '#pragma omp masked taskloop simd' cannot contain more than one 'simdlen' clause}}
|
||||
// expected-error@+2 {{argument to 'simdlen' clause must be a strictly positive integer value}}
|
||||
// expected-error@+1 2 {{integral constant expression}} expected-note@+1 0+{{constant expression}}
|
||||
#pragma omp masked taskloop simd simdlen (foobool(argc)), simdlen (true), simdlen (-5)
|
||||
for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST];
|
||||
#pragma omp masked taskloop simd simdlen (S) // expected-error {{'S' does not refer to a value}}
|
||||
for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST];
|
||||
#if __cplusplus <= 199711L
|
||||
// expected-error@+4 2 {{integral constant expression}} expected-note@+4 0+{{constant expression}}
|
||||
#else
|
||||
// expected-error@+2 2 {{integral constant expression must have integral or unscoped enumeration type, not 'char *'}}
|
||||
#endif
|
||||
#pragma omp masked taskloop simd simdlen (argv[1]=2) // expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST];
|
||||
#pragma omp masked taskloop simd simdlen (4)
|
||||
for (int i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST];
|
||||
#pragma omp masked taskloop simd simdlen (N) // expected-error {{argument to 'simdlen' clause must be a strictly positive integer value}}
|
||||
for (T i = ST; i < N; i++) argv[0][i] = argv[0][i] - argv[0][i-ST];
|
||||
return argc;
|
||||
}
|
||||
|
||||
int main(int argc, char **argv) {
|
||||
int tid = 0;
|
||||
#pragma omp masked taskloop simd simdlen filter(tid) // expected-error {{expected '(' after 'simdlen'}}
|
||||
for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4];
|
||||
#pragma omp masked taskloop simd simdlen ( // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4];
|
||||
#pragma omp masked taskloop simd simdlen () // expected-error {{expected expression}}
|
||||
for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4];
|
||||
#pragma omp masked taskloop simd simdlen (4 // expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4];
|
||||
#pragma omp masked taskloop simd simdlen (2+2)) // expected-warning {{extra tokens at the end of '#pragma omp masked taskloop simd' are ignored}}
|
||||
for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4];
|
||||
// expected-error@+1 {{integral constant expression}} expected-note@+1 0+{{constant expression}}
|
||||
#pragma omp masked taskloop simd simdlen (foobool(1) > 0 ? 1 : 2)
|
||||
for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4];
|
||||
// expected-error@+3 {{integral constant expression}} expected-note@+3 0+{{constant expression}}
|
||||
// expected-error@+2 2 {{directive '#pragma omp masked taskloop simd' cannot contain more than one 'simdlen' clause}}
|
||||
// expected-error@+1 {{argument to 'simdlen' clause must be a strictly positive integer value}}
|
||||
#pragma omp masked taskloop simd simdlen (foobool(argc)), simdlen (true), simdlen (-5)
|
||||
for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4];
|
||||
#pragma omp masked taskloop simd simdlen (S1) // expected-error {{'S1' does not refer to a value}}
|
||||
for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4];
|
||||
#if __cplusplus <= 199711L
|
||||
// expected-error@+4 {{integral constant expression}} expected-note@+4 0+{{constant expression}}
|
||||
#else
|
||||
// expected-error@+2 {{integral constant expression must have integral or unscoped enumeration type, not 'char *'}}
|
||||
#endif
|
||||
#pragma omp masked taskloop simd simdlen (argv[1]=2) // expected-error {{expected ')'}} expected-note {{to match this '('}}
|
||||
for (int i = 4; i < 12; i++) argv[0][i] = argv[0][i] - argv[0][i-4];
|
||||
// expected-error@+3 {{statement after '#pragma omp masked taskloop simd' must be a for loop}}
|
||||
// expected-note@+1 {{in instantiation of function template specialization 'tmain<int, char, -1, -2>' requested here}}
|
||||
#pragma omp masked taskloop simd simdlen(simdlen(tmain<int, char, -1, -2>(argc, argv) // expected-error 2 {{expected ')'}} expected-note 2 {{to match this '('}}
|
||||
foo();
|
||||
// expected-note@+1 {{in instantiation of function template specialization 'tmain<int, char, 12, 4>' requested here}}
|
||||
return tmain<int, char, 12, 4>(argc, argv);
|
||||
}
|
||||
|
||||
@ -2181,6 +2181,8 @@ public:
|
||||
void VisitOMPMaskedTaskLoopDirective(const OMPMaskedTaskLoopDirective *D);
|
||||
void
|
||||
VisitOMPMasterTaskLoopSimdDirective(const OMPMasterTaskLoopSimdDirective *D);
|
||||
void VisitOMPMaskedTaskLoopSimdDirective(
|
||||
const OMPMaskedTaskLoopSimdDirective *D);
|
||||
void VisitOMPParallelMasterTaskLoopDirective(
|
||||
const OMPParallelMasterTaskLoopDirective *D);
|
||||
void VisitOMPParallelMasterTaskLoopSimdDirective(
|
||||
@ -3195,6 +3197,11 @@ void EnqueueVisitor::VisitOMPMasterTaskLoopSimdDirective(
|
||||
VisitOMPLoopDirective(D);
|
||||
}
|
||||
|
||||
void EnqueueVisitor::VisitOMPMaskedTaskLoopSimdDirective(
|
||||
const OMPMaskedTaskLoopSimdDirective *D) {
|
||||
VisitOMPLoopDirective(D);
|
||||
}
|
||||
|
||||
void EnqueueVisitor::VisitOMPParallelMasterTaskLoopDirective(
|
||||
const OMPParallelMasterTaskLoopDirective *D) {
|
||||
VisitOMPLoopDirective(D);
|
||||
@ -5832,6 +5839,8 @@ CXString clang_getCursorKindSpelling(enum CXCursorKind Kind) {
|
||||
return cxstring::createRef("OMPMaskedTaskLoopDirective");
|
||||
case CXCursor_OMPMasterTaskLoopSimdDirective:
|
||||
return cxstring::createRef("OMPMasterTaskLoopSimdDirective");
|
||||
case CXCursor_OMPMaskedTaskLoopSimdDirective:
|
||||
return cxstring::createRef("OMPMaskedTaskLoopSimdDirective");
|
||||
case CXCursor_OMPParallelMasterTaskLoopDirective:
|
||||
return cxstring::createRef("OMPParallelMasterTaskLoopDirective");
|
||||
case CXCursor_OMPParallelMasterTaskLoopSimdDirective:
|
||||
|
||||
@ -775,6 +775,9 @@ CXCursor cxcursor::MakeCXCursor(const Stmt *S, const Decl *Parent,
|
||||
case Stmt::OMPMasterTaskLoopSimdDirectiveClass:
|
||||
K = CXCursor_OMPMasterTaskLoopSimdDirective;
|
||||
break;
|
||||
case Stmt::OMPMaskedTaskLoopSimdDirectiveClass:
|
||||
K = CXCursor_OMPMaskedTaskLoopSimdDirective;
|
||||
break;
|
||||
case Stmt::OMPParallelMasterTaskLoopDirectiveClass:
|
||||
K = CXCursor_OMPParallelMasterTaskLoopDirective;
|
||||
break;
|
||||
|
||||
@ -1717,6 +1717,34 @@ def OMP_MasterTaskloopSimd : Directive<"master taskloop simd"> {
|
||||
VersionedClause<OMPC_Order, 50>
|
||||
];
|
||||
}
|
||||
def OMP_MaskedTaskloopSimd : Directive<"masked taskloop simd"> {
|
||||
let allowedClauses = [
|
||||
VersionedClause<OMPC_If>,
|
||||
VersionedClause<OMPC_Shared>,
|
||||
VersionedClause<OMPC_Private>,
|
||||
VersionedClause<OMPC_FirstPrivate>,
|
||||
VersionedClause<OMPC_LastPrivate>,
|
||||
VersionedClause<OMPC_Default>,
|
||||
VersionedClause<OMPC_Collapse>,
|
||||
VersionedClause<OMPC_Final>,
|
||||
VersionedClause<OMPC_Untied>,
|
||||
VersionedClause<OMPC_Mergeable>,
|
||||
VersionedClause<OMPC_Priority>,
|
||||
VersionedClause<OMPC_Linear>,
|
||||
VersionedClause<OMPC_Aligned>,
|
||||
VersionedClause<OMPC_SafeLen>,
|
||||
VersionedClause<OMPC_SimdLen>,
|
||||
VersionedClause<OMPC_GrainSize>,
|
||||
VersionedClause<OMPC_NoGroup>,
|
||||
VersionedClause<OMPC_NumTasks>,
|
||||
VersionedClause<OMPC_Reduction>,
|
||||
VersionedClause<OMPC_InReduction>,
|
||||
VersionedClause<OMPC_Allocate>,
|
||||
VersionedClause<OMPC_NonTemporal, 50>,
|
||||
VersionedClause<OMPC_Order, 50>,
|
||||
VersionedClause<OMPC_Filter>
|
||||
];
|
||||
}
|
||||
def OMP_ParallelMasterTaskloopSimd :
|
||||
Directive<"parallel master taskloop simd"> {
|
||||
let allowedClauses = [
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user