maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

[OPENMP] First changes for Parsing and Sema for 'omp simd' directive support 

llvm-svn: 202360
This commit is contained in:
Alexey Bataev 2014-02-27 08:29:12 +00:00
parent 6edfad4811
commit 1b59ab5683
24 changed files with 461 additions and 57 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
clang/include/clang-c/Index.h
View File

@ -2135,7 +2135,11 @@ enum CXCursorKind {
*/
CXCursor_OMPParallelDirective = 232,
CXCursor_LastStmt = CXCursor_OMPParallelDirective,
/** \brief OpenMP simd directive.
*/
CXCursor_OMPSimdDirective = 233,
CXCursor_LastStmt = CXCursor_OMPSimdDirective,
/**
* \brief Cursor that represents the translation unit itself.

14
clang/include/clang/AST/DataRecursiveASTVisitor.h
View File

@ -424,6 +424,7 @@ private:
bool TraverseFunctionHelper(FunctionDecl *D);
bool TraverseVarHelper(VarDecl *D);
bool TraverseOMPClause(OMPClause *C);
bool TraverseOMPExecutableDirective(OMPExecutableDirective *S);
#define OPENMP_CLAUSE(Name, Class) \
bool Visit##Class(Class *C);
#include "clang/Basic/OpenMPKinds.def"
@ -2331,11 +2332,22 @@ DEF_TRAVERSE_STMT(ObjCDictionaryLiteral, { })
DEF_TRAVERSE_STMT(AsTypeExpr, { })
// OpenMP directives.
DEF_TRAVERSE_STMT(OMPParallelDirective, {
template<typename Derived>
bool DataRecursiveASTVisitor<Derived>::TraverseOMPExecutableDirective(
OMPExecutableDirective *S) {
ArrayRef<OMPClause *> Clauses = S->clauses();
for (ArrayRef<OMPClause *>::iterator I = Clauses.begin(), E = Clauses.end();
I != E; ++I)
if (!TraverseOMPClause(*I)) return false;
return true;
}
DEF_TRAVERSE_STMT(OMPParallelDirective, {
if (!TraverseOMPExecutableDirective(S)) return false;
})
DEF_TRAVERSE_STMT(OMPSimdDirective, {
if (!TraverseOMPExecutableDirective(S)) return false;
})
// OpenMP clauses.

14
clang/include/clang/AST/RecursiveASTVisitor.h
View File

@ -441,6 +441,7 @@ private:
bool TraverseFunctionHelper(FunctionDecl *D);
bool TraverseVarHelper(VarDecl *D);
bool TraverseOMPClause(OMPClause *C);
bool TraverseOMPExecutableDirective(OMPExecutableDirective *S);
#define OPENMP_CLAUSE(Name, Class) \
bool Visit##Class(Class *C);
#include "clang/Basic/OpenMPKinds.def"
@ -2355,11 +2356,22 @@ DEF_TRAVERSE_STMT(ObjCDictionaryLiteral, { })
DEF_TRAVERSE_STMT(AsTypeExpr, { })
// OpenMP directives.
DEF_TRAVERSE_STMT(OMPParallelDirective, {
template<typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseOMPExecutableDirective(
OMPExecutableDirective *S) {
ArrayRef<OMPClause *> Clauses = S->clauses();
for (ArrayRef<OMPClause *>::iterator I = Clauses.begin(), E = Clauses.end();
I != E; ++I)
if (!TraverseOMPClause(*I)) return false;
return true;
}
DEF_TRAVERSE_STMT(OMPParallelDirective, {
if (!TraverseOMPExecutableDirective(S)) return false;
})
DEF_TRAVERSE_STMT(OMPSimdDirective, {
if (!TraverseOMPExecutableDirective(S)) return false;
})
// OpenMP clauses.

86
clang/include/clang/AST/StmtOpenMP.h
View File

@ -140,17 +140,18 @@ class OMPParallelDirective : public OMPExecutableDirective {
/// \param EndLoc Ending Location of the directive.
///
OMPParallelDirective(SourceLocation StartLoc, SourceLocation EndLoc,
unsigned N)
unsigned NumClauses)
: OMPExecutableDirective(this, OMPParallelDirectiveClass, OMPD_parallel,
StartLoc, EndLoc, N, 1) {}
StartLoc, EndLoc, NumClauses, 1) {}
/// \brief Build an empty directive.
///
/// \param N Number of clauses.
/// \param NumClauses Number of clauses.
///
explicit OMPParallelDirective(unsigned N)
explicit OMPParallelDirective(unsigned NumClauses)
: OMPExecutableDirective(this, OMPParallelDirectiveClass, OMPD_parallel,
SourceLocation(), SourceLocation(), N, 1) {}
SourceLocation(), SourceLocation(),
NumClauses, 1) {}
public:
/// \brief Creates directive with a list of \a Clauses.
@ -168,9 +169,10 @@ public:
/// \brief Creates an empty directive with the place for \a N clauses.
///
/// \param C AST context.
/// \param N The number of clauses.
/// \param NumClauses Number of clauses.
///
static OMPParallelDirective *CreateEmpty(const ASTContext &C, unsigned N,
static OMPParallelDirective *CreateEmpty(const ASTContext &C,
unsigned NumClauses,
EmptyShell);
static bool classof(const Stmt *T) {
@ -178,6 +180,76 @@ public:
}
};
/// \brief This represents '#pragma omp simd' directive.
///
/// \code
/// #pragma omp simd private(a,b) linear(i,j:s) reduction(+:c,d)
/// \endcode
/// In this example directive '#pragma omp simd' has clauses 'private'
/// with the variables 'a' and 'b', 'linear' with variables 'i', 'j' and
/// linear step 's', 'reduction' with operator '+' and variables 'c' and 'd'.
///
class OMPSimdDirective : public OMPExecutableDirective {
friend class ASTStmtReader;
/// \brief Number of collapsed loops as specified by 'collapse' clause.
unsigned CollapsedNum;
/// \brief 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.
/// \param NumClauses Number of clauses.
///
OMPSimdDirective(SourceLocation StartLoc, SourceLocation EndLoc,
unsigned CollapsedNum, unsigned NumClauses)
: OMPExecutableDirective(this, OMPSimdDirectiveClass, OMPD_simd,
StartLoc, EndLoc, NumClauses, 1),
CollapsedNum(CollapsedNum) { }
/// \brief Build an empty directive.
///
/// \param CollapsedNum Number of collapsed nested loops.
/// \param NumClauses Number of clauses.
///
explicit OMPSimdDirective(unsigned CollapsedNum, unsigned NumClauses)
: OMPExecutableDirective(this, OMPSimdDirectiveClass, OMPD_simd,
SourceLocation(), SourceLocation(),
NumClauses, 1),
CollapsedNum(CollapsedNum) { }
public:
/// \brief Creates directive with a list of \a Clauses.
///
/// \param C AST context.
/// \param StartLoc Starting location of the directive kind.
/// \param EndLoc Ending Location of the directive.
/// \param Clauses List of clauses.
/// \param AssociatedStmt Statement, associated with the directive.
///
static OMPSimdDirective *Create(const ASTContext &C,
SourceLocation StartLoc,
SourceLocation EndLoc,
ArrayRef<OMPClause *> Clauses,
Stmt *AssociatedStmt);
/// \brief Creates an empty directive with the place
/// for \a NumClauses clauses.
///
/// \param C AST context.
/// \param CollapsedNum Number of collapsed nested loops.
/// \param NumClauses Number of clauses.
///
static OMPSimdDirective *CreateEmpty(const ASTContext &C,
unsigned NumClauses,
unsigned CollapsedNum,
EmptyShell);
unsigned getCollapsedNumber() const { return CollapsedNum; }
static bool classof(const Stmt *T) {
return T->getStmtClass() == OMPSimdDirectiveClass;
}
};
} // end namespace clang
#endif

14
clang/include/clang/Basic/DiagnosticSemaKinds.td
View File

@ -6835,24 +6835,26 @@ def err_omp_private_incomplete_type : Error<
"a private variable with incomplete type %0">;
def err_omp_firstprivate_incomplete_type : Error<
"a firstprivate variable with incomplete type %0">;
def err_omp_unexpected_clause_value : Error <
def err_omp_unexpected_clause_value : Error<
"expected %0 in OpenMP clause '%1'">;
def err_omp_expected_var_name : Error <
def err_omp_expected_var_name : Error<
"expected variable name">;
def err_omp_required_method : Error <
def err_omp_required_method : Error<
"%0 variable must have an accessible, unambiguous %select{default constructor|copy constructor|copy assignment operator|'%2'|destructor}1">;
def err_omp_clause_ref_type_arg : Error<
"arguments of OpenMP clause '%0' cannot be of reference type %1">;
def err_omp_threadprivate_incomplete_type : Error<
"threadprivate variable with incomplete type %0">;
def err_omp_no_dsa_for_variable : Error <
def err_omp_no_dsa_for_variable : Error<
"variable %0 must have explicitly specified data sharing attributes">;
def err_omp_wrong_dsa : Error<
"%0 variable cannot be %1">;
def note_omp_explicit_dsa : Note <
def note_omp_explicit_dsa : Note<
"defined as %0">;
def note_omp_predetermined_dsa : Note <
def note_omp_predetermined_dsa : Note<
"predetermined as %0">;
def err_omp_not_for : Error<
"statement after '#pragma omp %0' must be a for loop">;
} // end of OpenMP category
let CategoryName = "Related Result Type Issue" in {

8
clang/include/clang/Basic/OpenMPKinds.def
View File

@ -21,6 +21,9 @@
#ifndef OPENMP_PARALLEL_CLAUSE
# define OPENMP_PARALLEL_CLAUSE(Name)
#endif
#ifndef OPENMP_SIMD_CLAUSE
# define OPENMP_SIMD_CLAUSE(Name)
#endif
#ifndef OPENMP_DEFAULT_KIND
# define OPENMP_DEFAULT_KIND(Name)
#endif
@ -29,6 +32,7 @@
OPENMP_DIRECTIVE(threadprivate)
OPENMP_DIRECTIVE(parallel)
OPENMP_DIRECTIVE(task)
OPENMP_DIRECTIVE(simd)
// OpenMP clauses.
OPENMP_CLAUSE(if, OMPIfClause)
@ -44,6 +48,8 @@ OPENMP_PARALLEL_CLAUSE(private)
OPENMP_PARALLEL_CLAUSE(firstprivate)
OPENMP_PARALLEL_CLAUSE(shared)
// FIXME: clauses allowed for directive 'omp simd'.
// Static attributes for 'default' clause.
OPENMP_DEFAULT_KIND(none)
OPENMP_DEFAULT_KIND(shared)
@ -52,3 +58,5 @@ OPENMP_DEFAULT_KIND(shared)
#undef OPENMP_DIRECTIVE
#undef OPENMP_CLAUSE
#undef OPENMP_PARALLEL_CLAUSE
#undef OPENMP_SIMD_CLAUSE

1
clang/include/clang/Basic/StmtNodes.td
View File

@ -178,3 +178,4 @@ def AsTypeExpr : DStmt<Expr>;
// OpenMP Directives.
def OMPExecutableDirective : Stmt<1>;
def OMPParallelDirective : DStmt<OMPExecutableDirective>;
def OMPSimdDirective : DStmt<OMPExecutableDirective>;

6
clang/include/clang/Sema/Sema.h
View File

@ -7111,6 +7111,12 @@ public:
Stmt *AStmt,
SourceLocation StartLoc,
SourceLocation EndLoc);
/// \brief Called on well-formed '\#pragma omp simd' after parsing
/// of the associated statement.
StmtResult ActOnOpenMPSimdDirective(ArrayRef<OMPClause *> Clauses,
Stmt *AStmt,
SourceLocation StartLoc,
SourceLocation EndLoc);
OMPClause *ActOnOpenMPSingleExprClause(OpenMPClauseKind Kind,
Expr *Expr,

1
clang/include/clang/Serialization/ASTBitCodes.h
View File

@ -1333,6 +1333,7 @@ namespace clang {
// OpenMP drectives
STMT_OMP_PARALLEL_DIRECTIVE,
STMT_OMP_SIMD_DIRECTIVE,
// ARC
EXPR_OBJC_BRIDGED_CAST, // ObjCBridgedCastExpr

35
clang/lib/AST/Stmt.cpp
View File

@ -1217,10 +1217,39 @@ OMPParallelDirective *OMPParallelDirective::Create(
}
OMPParallelDirective *OMPParallelDirective::CreateEmpty(const ASTContext &C,
unsigned N,
unsigned NumClauses,
EmptyShell) {
unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPParallelDirective),
llvm::alignOf<OMPClause *>());
void *Mem = C.Allocate(Size + sizeof(OMPClause *) * N + sizeof(Stmt *));
return new (Mem) OMPParallelDirective(N);
void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
sizeof(Stmt *));
return new (Mem) OMPParallelDirective(NumClauses);
}
OMPSimdDirective *OMPSimdDirective::Create(const ASTContext &C,
SourceLocation StartLoc,
SourceLocation EndLoc,
ArrayRef<OMPClause *> Clauses,
Stmt *AssociatedStmt) {
unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPSimdDirective),
llvm::alignOf<OMPClause *>());
void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
sizeof(Stmt *));
OMPSimdDirective *Dir = new (Mem) OMPSimdDirective(StartLoc, EndLoc,
1, Clauses.size());
Dir->setClauses(Clauses);
Dir->setAssociatedStmt(AssociatedStmt);
return Dir;
}
OMPSimdDirective *OMPSimdDirective::CreateEmpty(const ASTContext &C,
unsigned NumClauses,
unsigned CollapsedNum,
EmptyShell) {
unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPSimdDirective),
llvm::alignOf<OMPClause *>());
void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
sizeof(Stmt *));
return new (Mem) OMPSimdDirective(CollapsedNum, NumClauses);
}

24
clang/lib/AST/StmtPrinter.cpp
View File

@ -70,6 +70,7 @@ namespace {
void PrintCallArgs(CallExpr *E);
void PrintRawSEHExceptHandler(SEHExceptStmt *S);
void PrintRawSEHFinallyStmt(SEHFinallyStmt *S);
void PrintOMPExecutableDirective(OMPExecutableDirective *S);
void PrintExpr(Expr *E) {
if (E)
@ -656,11 +657,9 @@ void OMPClausePrinter::VisitOMPSharedClause(OMPSharedClause *Node) {
// OpenMP directives printing methods
//===----------------------------------------------------------------------===//
void StmtPrinter::VisitOMPParallelDirective(OMPParallelDirective *Node) {
Indent() << "#pragma omp parallel ";
void StmtPrinter::PrintOMPExecutableDirective(OMPExecutableDirective *S) {
OMPClausePrinter Printer(OS, Policy);
ArrayRef<OMPClause *> Clauses = Node->clauses();
ArrayRef<OMPClause *> Clauses = S->clauses();
for (ArrayRef<OMPClause *>::iterator I = Clauses.begin(), E = Clauses.end();
I != E; ++I)
if (*I && !(*I)->isImplicit()) {
@ -668,13 +667,24 @@ void StmtPrinter::VisitOMPParallelDirective(OMPParallelDirective *Node) {
OS << ' ';
}
OS << "\n";
if (Node->getAssociatedStmt()) {
assert(isa<CapturedStmt>(Node->getAssociatedStmt()) &&
if (S->getAssociatedStmt()) {
assert(isa<CapturedStmt>(S->getAssociatedStmt()) &&
"Expected captured statement!");
Stmt *CS = cast<CapturedStmt>(Node->getAssociatedStmt())->getCapturedStmt();
Stmt *CS = cast<CapturedStmt>(S->getAssociatedStmt())->getCapturedStmt();
PrintStmt(CS);
}
}
void StmtPrinter::VisitOMPParallelDirective(OMPParallelDirective *Node) {
Indent() << "#pragma omp parallel ";
PrintOMPExecutableDirective(Node);
}
void StmtPrinter::VisitOMPSimdDirective(OMPSimdDirective *Node) {
Indent() << "#pragma omp simd ";
PrintOMPExecutableDirective(Node);
}
//===----------------------------------------------------------------------===//
// Expr printing methods.
//===----------------------------------------------------------------------===//

10
clang/lib/AST/StmtProfile.cpp
View File

@ -293,7 +293,7 @@ void OMPClauseProfiler::VisitOMPSharedClause(const OMPSharedClause *C) {
}
void
StmtProfiler::VisitOMPParallelDirective(const OMPParallelDirective *S) {
StmtProfiler::VisitOMPExecutableDirective(const OMPExecutableDirective *S) {
VisitStmt(S);
OMPClauseProfiler P(this);
ArrayRef<OMPClause *> Clauses = S->clauses();
@ -303,6 +303,14 @@ StmtProfiler::VisitOMPParallelDirective(const OMPParallelDirective *S) {
P.Visit(*I);
}
void StmtProfiler::VisitOMPParallelDirective(const OMPParallelDirective *S) {
VisitOMPExecutableDirective(S);
}
void StmtProfiler::VisitOMPSimdDirective(const OMPSimdDirective *S) {
VisitOMPExecutableDirective(S);
}
void StmtProfiler::VisitExpr(const Expr *S) {
VisitStmt(S);
}

9
clang/lib/Basic/OpenMPKinds.cpp
View File

@ -120,6 +120,15 @@ bool clang::isAllowedClauseForDirective(OpenMPDirectiveKind DKind,
switch (CKind) {
#define OPENMP_PARALLEL_CLAUSE(Name) \
case OMPC_##Name: return true;
#include "clang/Basic/OpenMPKinds.def"
default:
break;
}
break;
case OMPD_simd:
switch (CKind) {
#define OPENMP_SIMD_CLAUSE(Name) \
case OMPC_##Name: return true;
#include "clang/Basic/OpenMPKinds.def"
default:
break;

1
clang/lib/CodeGen/CGStmt.cpp
View File

@ -77,6 +77,7 @@ void CodeGenFunction::EmitStmt(const Stmt *S) {
case Stmt::SEHFinallyStmtClass:
case Stmt::MSDependentExistsStmtClass:
case Stmt::OMPParallelDirectiveClass:
case Stmt::OMPSimdDirectiveClass:
llvm_unreachable("invalid statement class to emit generically");
case Stmt::NullStmtClass:
case Stmt::CompoundStmtClass:

4
clang/lib/Parse/ParseOpenMP.cpp
View File

@ -60,6 +60,7 @@ Parser::DeclGroupPtrTy Parser::ParseOpenMPDeclarativeDirective() {
Diag(Tok, diag::err_omp_unknown_directive);
break;
case OMPD_parallel:
case OMPD_simd:
case OMPD_task:
case NUM_OPENMP_DIRECTIVES:
Diag(Tok, diag::err_omp_unexpected_directive)
@ -114,7 +115,8 @@ StmtResult Parser::ParseOpenMPDeclarativeOrExecutableDirective() {
}
SkipUntil(tok::annot_pragma_openmp_end);
break;
case OMPD_parallel: {
case OMPD_parallel:
case OMPD_simd: {
ConsumeToken();
Actions.StartOpenMPDSABlock(DKind, DirName, Actions.getCurScope());

27
clang/lib/Sema/SemaOpenMP.cpp
View File

@ -699,6 +699,10 @@ StmtResult Sema::ActOnOpenMPExecutableDirective(OpenMPDirectiveKind Kind,
Res = ActOnOpenMPParallelDirective(ClausesWithImplicit, AStmt,
StartLoc, EndLoc);
break;
case OMPD_simd:
Res = ActOnOpenMPSimdDirective(ClausesWithImplicit, AStmt,
StartLoc, EndLoc);
break;
case OMPD_threadprivate:
case OMPD_task:
llvm_unreachable("OpenMP Directive is not allowed");
@ -721,6 +725,29 @@ StmtResult Sema::ActOnOpenMPParallelDirective(ArrayRef<OMPClause *> Clauses,
Clauses, AStmt));
}
StmtResult Sema::ActOnOpenMPSimdDirective(ArrayRef<OMPClause *> Clauses,
Stmt *AStmt,
SourceLocation StartLoc,
SourceLocation EndLoc) {
Stmt *CStmt = AStmt;
while (CapturedStmt *CS = dyn_cast_or_null<CapturedStmt>(CStmt))
CStmt = CS->getCapturedStmt();
while (AttributedStmt *AS = dyn_cast_or_null<AttributedStmt>(CStmt))
CStmt = AS->getSubStmt();
ForStmt *For = dyn_cast<ForStmt>(CStmt);
if (!For) {
Diag(CStmt->getLocStart(), diag::err_omp_not_for)
<< getOpenMPDirectiveName(OMPD_simd);
return StmtError();
}
// FIXME: Checking loop canonical form, collapsing etc.
getCurFunction()->setHasBranchProtectedScope();
return Owned(OMPSimdDirective::Create(Context, StartLoc, EndLoc,
Clauses, AStmt));
}
OMPClause *Sema::ActOnOpenMPSingleExprClause(OpenMPClauseKind Kind,
Expr *Expr,
SourceLocation StartLoc,

39
clang/lib/Sema/TreeTransform.h
View File

@ -607,6 +607,7 @@ public:
ExprResult TransformAddressOfOperand(Expr *E);
ExprResult TransformDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E,
bool IsAddressOfOperand);
StmtResult TransformOMPExecutableDirective(OMPExecutableDirective *S);
// FIXME: We use LLVM_ATTRIBUTE_NOINLINE because inlining causes a ridiculous
// amount of stack usage with clang.
@ -1286,15 +1287,16 @@ public:
return getSema().BuildObjCAtThrowStmt(AtLoc, Operand);
}
/// \brief Build a new OpenMP parallel directive.
/// \brief Build a new OpenMP executable directive.
///
/// By default, performs semantic analysis to build the new statement.
/// Subclasses may override this routine to provide different behavior.
StmtResult RebuildOMPParallelDirective(ArrayRef<OMPClause *> Clauses,
StmtResult RebuildOMPExecutableDirective(OpenMPDirectiveKind Kind,
ArrayRef<OMPClause *> Clauses,
Stmt *AStmt,
SourceLocation StartLoc,
SourceLocation EndLoc) {
return getSema().ActOnOpenMPParallelDirective(Clauses, AStmt,
return getSema().ActOnOpenMPExecutableDirective(Kind, Clauses, AStmt,
StartLoc, EndLoc);
}
@ -6248,9 +6250,8 @@ StmtResult TreeTransform<Derived>::TransformSEHHandler(Stmt *Handler) {
template<typename Derived>
StmtResult
TreeTransform<Derived>::TransformOMPParallelDirective(OMPParallelDirective *D) {
DeclarationNameInfo DirName;
getSema().StartOpenMPDSABlock(OMPD_parallel, DirName, 0);
TreeTransform<Derived>::TransformOMPExecutableDirective(
OMPExecutableDirective *D) {
// Transform the clauses
llvm::SmallVector<OMPClause *, 16> TClauses;
@ -6261,7 +6262,6 @@ TreeTransform<Derived>::TransformOMPParallelDirective(OMPParallelDirective *D) {
if (*I) {
OMPClause *Clause = getDerived().TransformOMPClause(*I);
if (!Clause) {
getSema().EndOpenMPDSABlock(0);
return StmtError();
}
TClauses.push_back(Clause);
@ -6271,21 +6271,38 @@ TreeTransform<Derived>::TransformOMPParallelDirective(OMPParallelDirective *D) {
}
}
if (!D->getAssociatedStmt()) {
getSema().EndOpenMPDSABlock(0);
return StmtError();
}
StmtResult AssociatedStmt =
getDerived().TransformStmt(D->getAssociatedStmt());
if (AssociatedStmt.isInvalid()) {
getSema().EndOpenMPDSABlock(0);
return StmtError();
}
StmtResult Res = getDerived().RebuildOMPParallelDirective(TClauses,
return getDerived().RebuildOMPExecutableDirective(D->getDirectiveKind(),
TClauses,
AssociatedStmt.take(),
D->getLocStart(),
D->getLocEnd());
getSema().EndOpenMPDSABlock(Res.get());
}
template<typename Derived>
StmtResult
TreeTransform<Derived>::TransformOMPParallelDirective(OMPParallelDirective *D) {
DeclarationNameInfo DirName;
getSema().StartOpenMPDSABlock(OMPD_parallel, DirName, 0);
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
}
template<typename Derived>
StmtResult
TreeTransform<Derived>::TransformOMPSimdDirective(OMPSimdDirective *D) {
DeclarationNameInfo DirName;
getSema().StartOpenMPDSABlock(OMPD_simd, DirName, 0);
StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
getDerived().getSema().EndOpenMPDSABlock(Res.get());
return Res;
}

21
clang/lib/Serialization/ASTReaderStmt.cpp
View File

@ -1742,8 +1742,6 @@ void OMPClauseReader::VisitOMPSharedClause(OMPSharedClause *C) {
// OpenMP Directives.
//===----------------------------------------------------------------------===//
void ASTStmtReader::VisitOMPExecutableDirective(OMPExecutableDirective *E) {
VisitStmt(E);
++Idx;
E->setLocStart(ReadSourceLocation(Record, Idx));
E->setLocEnd(ReadSourceLocation(Record, Idx));
OMPClauseReader ClauseReader(this, Reader.getContext(), Record, Idx);
@ -1755,6 +1753,16 @@ void ASTStmtReader::VisitOMPExecutableDirective(OMPExecutableDirective *E) {
}
void ASTStmtReader::VisitOMPParallelDirective(OMPParallelDirective *D) {
VisitStmt(D);
// The NumClauses field was read in ReadStmtFromStream.
++Idx;
VisitOMPExecutableDirective(D);
}
void ASTStmtReader::VisitOMPSimdDirective(OMPSimdDirective *D) {
VisitStmt(D);
// Two fields (NumClauses and CollapsedNum) were read in ReadStmtFromStream.
Idx += 2;
VisitOMPExecutableDirective(D);
}
@ -2230,6 +2238,7 @@ Stmt *ASTReader::ReadStmtFromStream(ModuleFile &F) {
DeclarationNameInfo(),
0);
break;
case STMT_OMP_PARALLEL_DIRECTIVE:
S =
OMPParallelDirective::CreateEmpty(Context,
@ -2237,6 +2246,14 @@ Stmt *ASTReader::ReadStmtFromStream(ModuleFile &F) {
Empty);
break;
case STMT_OMP_SIMD_DIRECTIVE: {
unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
S = OMPSimdDirective::CreateEmpty(Context, NumClauses,
CollapsedNum, Empty);
break;
}
case EXPR_CXX_OPERATOR_CALL:
S = new (Context) CXXOperatorCallExpr(Context, Empty);
break;

12
clang/lib/Serialization/ASTWriterStmt.cpp
View File

@ -1721,8 +1721,6 @@ void OMPClauseWriter::VisitOMPSharedClause(OMPSharedClause *C) {
// OpenMP Directives.
//===----------------------------------------------------------------------===//
void ASTStmtWriter::VisitOMPExecutableDirective(OMPExecutableDirective *E) {
VisitStmt(E);
Record.push_back(E->getNumClauses());
Writer.AddSourceLocation(E->getLocStart(), Record);
Writer.AddSourceLocation(E->getLocEnd(), Record);
OMPClauseWriter ClauseWriter(this, Record);
@ -1733,10 +1731,20 @@ void ASTStmtWriter::VisitOMPExecutableDirective(OMPExecutableDirective *E) {
}
void ASTStmtWriter::VisitOMPParallelDirective(OMPParallelDirective *D) {
VisitStmt(D);
Record.push_back(D->getNumClauses());
VisitOMPExecutableDirective(D);
Code = serialization::STMT_OMP_PARALLEL_DIRECTIVE;
}
void ASTStmtWriter::VisitOMPSimdDirective(OMPSimdDirective *D) {
VisitStmt(D);
Record.push_back(D->getNumClauses());
Record.push_back(D->getCollapsedNumber());
VisitOMPExecutableDirective(D);
Code = serialization::STMT_OMP_SIMD_DIRECTIVE;
}
//===----------------------------------------------------------------------===//
// ASTWriter Implementation
//===----------------------------------------------------------------------===//

1
clang/lib/StaticAnalyzer/Core/ExprEngine.cpp
View File

@ -731,6 +731,7 @@ void ExprEngine::Visit(const Stmt *S, ExplodedNode *Pred,
case Expr::MSDependentExistsStmtClass:
case Stmt::CapturedStmtClass:
case Stmt::OMPParallelDirectiveClass:
case Stmt::OMPSimdDirectiveClass:
llvm_unreachable("Stmt should not be in analyzer evaluation loop");
case Stmt::ObjCSubscriptRefExprClass:

75
clang/test/OpenMP/simd_ast_print.cpp Normal file
View File

@ -0,0 +1,75 @@
// RUN: %clang_cc1 -verify -fopenmp -ast-print %s | FileCheck %s
// RUN: %clang_cc1 -fopenmp -x c++ -std=c++11 -emit-pch -o %t %s
// RUN: %clang_cc1 -fopenmp -std=c++11 -include-pch %t -fsyntax-only -verify %s -ast-print | FileCheck %s
// expected-no-diagnostics
#ifndef HEADER
#define HEADER
void foo() {}
template<class T, class N> T reduct(T* arr, N num) {
N i;
N ind;
T sum = (T)0;
// CHECK: T sum = (T)0;
#pragma omp simd
// CHECK-NEXT: #pragma omp simd
for (i = 0; i < num; ++i) {
T cur = arr[ind];
++ind;
sum += cur;
}
}
template<class T> struct S {
S(const T &a)
:m_a(a)
{}
T result(T *v) const {
T res;
// CHECK: T res;
#pragma omp simd
// CHECK-NEXT: #pragma omp simd
for (T i = 7; i < m_a; ++i) {
res = v[i-7] + m_a;
}
return res;
}
~S()
{}
T m_a;
};
int main (int argc, char **argv) {
int b = argc, c, d, e, f, g;
int k1=0,k2=0;
static int *a;
// CHECK: static int *a;
#pragma omp simd
// CHECK-NEXT: #pragma omp simd
for (int i=0; i < 2; ++i)*a=2;
// CHECK-NEXT: for (int i = 0; i < 2; ++i)
// CHECK-NEXT: *a = 2;
#pragma omp simd
for (int i = 0; i < 10; ++i)
for (int j = 0; j < 10; ++j) {foo(); k1 += 8; k2 += 8;}
// CHECK-NEXT: #pragma omp simd
// CHECK-NEXT: for (int i = 0; i < 10; ++i)
// CHECK-NEXT: for (int j = 0; j < 10; ++j) {
// CHECK-NEXT: foo();
// CHECK-NEXT: k1 += 8;
// CHECK-NEXT: k2 += 8;
// CHECK-NEXT: }
for (int i = 0; i < 10; ++i)foo();
// CHECK-NEXT: for (int i = 0; i < 10; ++i)
// CHECK-NEXT: foo();
#pragma omp simd
// CHECK-NEXT: #pragma omp simd
for (int i = 0; i < 10; ++i)foo();
// CHECK-NEXT: for (int i = 0; i < 10; ++i)
// CHECK-NEXT: foo();
return (0);
}
#endif

73
clang/test/OpenMP/simd_misc_messages.c Normal file
View File

@ -0,0 +1,73 @@
// RUN: %clang_cc1 -fsyntax-only -fopenmp -verify %s
// expected-error@+1 {{unexpected OpenMP directive '#pragma omp simd'}}
#pragma omp simd
// expected-error@+1 {{unexpected OpenMP directive '#pragma omp simd'}}
#pragma omp simd foo
// expected-error@+1 {{unexpected OpenMP directive '#pragma omp simd'}}
#pragma omp simd safelen(4)
void test_no_clause()
{
int i;
#pragma omp simd
for (i = 0; i < 16; ++i) ;
// expected-error@+2 {{statement after '#pragma omp simd' must be a for loop}}
#pragma omp simd
++i;
}
void test_branch_protected_scope()
{
int i = 0;
L1:
++i;
int x[24];
#pragma omp simd
for (i = 0; i < 16; ++i) {
if (i == 5)
goto L1; // expected-error {{use of undeclared label 'L1'}}
else if (i == 6)
return; // expected-error {{cannot return from OpenMP region}}
else if (i == 7)
goto L2;
else if (i == 8) {
L2:
x[i]++;
}
}
if (x[0] == 0)
goto L2; // expected-error {{use of undeclared label 'L2'}}
else if (x[1] == 1)
goto L1;
}
void test_invalid_clause()
{
int i;
// expected-warning@+1 {{extra tokens at the end of '#pragma omp simd' are ignored}}
#pragma omp simd foo bar
for (i = 0; i < 16; ++i) ;
}
void test_non_identifiers()
{
int i, x;
// expected-warning@+1 {{extra tokens at the end of '#pragma omp simd' are ignored}}
#pragma omp simd;
for (i = 0; i < 16; ++i) ;
// expected-error@+2 {{unexpected OpenMP clause 'firstprivate' in directive '#pragma omp simd'}}
// expected-warning@+1 {{extra tokens at the end of '#pragma omp simd' are ignored}}
#pragma omp simd firstprivate(x);
for (i = 0; i < 16; ++i) ;
// expected-warning@+1 {{extra tokens at the end of '#pragma omp simd' are ignored}}
#pragma omp simd , private(x);
for (i = 0; i < 16; ++i) ;
}

7
clang/tools/libclang/CIndex.cpp
View File

@ -1867,6 +1867,7 @@ public:
void VisitLambdaExpr(const LambdaExpr *E);
void VisitOMPExecutableDirective(const OMPExecutableDirective *D);
void VisitOMPParallelDirective(const OMPParallelDirective *D);
void VisitOMPSimdDirective(const OMPSimdDirective *D);
private:
void AddDeclarationNameInfo(const Stmt *S);
@ -2257,6 +2258,10 @@ void EnqueueVisitor::VisitOMPParallelDirective(const OMPParallelDirective *D) {
VisitOMPExecutableDirective(D);
}
void EnqueueVisitor::VisitOMPSimdDirective(const OMPSimdDirective *D) {
VisitOMPExecutableDirective(D);
}
void CursorVisitor::EnqueueWorkList(VisitorWorkList &WL, const Stmt *S) {
EnqueueVisitor(WL, MakeCXCursor(S, StmtParent, TU,RegionOfInterest)).Visit(S);
}
@ -3912,6 +3917,8 @@ CXString clang_getCursorKindSpelling(enum CXCursorKind Kind) {
return cxstring::createRef("ModuleImport");
case CXCursor_OMPParallelDirective:
return cxstring::createRef("OMPParallelDirective");
case CXCursor_OMPSimdDirective:
return cxstring::createRef("OMPSimdDirective");
}
llvm_unreachable("Unhandled CXCursorKind");

4
clang/tools/libclang/CXCursor.cpp
View File

@ -509,7 +509,9 @@ CXCursor cxcursor::MakeCXCursor(const Stmt *S, const Decl *Parent,
case Stmt::OMPParallelDirectiveClass:
K = CXCursor_OMPParallelDirective;
break;
case Stmt::OMPSimdDirectiveClass:
K = CXCursor_OMPSimdDirective;
break;
}
CXCursor C = { K, 0, { Parent, S, TU } };