*/
CXCursor_OMPTaskyieldDirective = 242,
+ /** \brief OpenMP barrier directive.
+ */
+ CXCursor_OMPBarrierDirective = 243,
+
/** \brief Windows Structured Exception Handling's leave statement.
*/
- CXCursor_SEHLeaveStmt = 243,
+ CXCursor_SEHLeaveStmt = 244,
CXCursor_LastStmt = CXCursor_SEHLeaveStmt,
DEF_TRAVERSE_STMT(OMPTaskyieldDirective,
{ TRY_TO(TraverseOMPExecutableDirective(S)); })
+DEF_TRAVERSE_STMT(OMPBarrierDirective,
+ { TRY_TO(TraverseOMPExecutableDirective(S)); })
+
// OpenMP clauses.
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseOMPClause(OMPClause *C) {
DEF_TRAVERSE_STMT(OMPTaskyieldDirective,
{ TRY_TO(TraverseOMPExecutableDirective(S)); })
+DEF_TRAVERSE_STMT(OMPBarrierDirective,
+ { TRY_TO(TraverseOMPExecutableDirective(S)); })
+
// OpenMP clauses.
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseOMPClause(OMPClause *C) {
}
};
+/// \brief This represents '#pragma omp barrier' directive.
+///
+/// \code
+/// #pragma omp barrier
+/// \endcode
+///
+class OMPBarrierDirective : public OMPExecutableDirective {
+ friend class ASTStmtReader;
+ /// \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.
+ ///
+ OMPBarrierDirective(SourceLocation StartLoc, SourceLocation EndLoc)
+ : OMPExecutableDirective(this, OMPBarrierDirectiveClass, OMPD_barrier,
+ StartLoc, EndLoc, 0, 0) {}
+
+ /// \brief Build an empty directive.
+ ///
+ explicit OMPBarrierDirective()
+ : OMPExecutableDirective(this, OMPBarrierDirectiveClass, OMPD_barrier,
+ SourceLocation(), SourceLocation(), 0, 0) {}
+
+public:
+ /// \brief Creates directive.
+ ///
+ /// \param C AST context.
+ /// \param StartLoc Starting location of the directive kind.
+ /// \param EndLoc Ending Location of the directive.
+ ///
+ static OMPBarrierDirective *
+ Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc);
+
+ /// \brief Creates an empty directive.
+ ///
+ /// \param C AST context.
+ ///
+ static OMPBarrierDirective *CreateEmpty(const ASTContext &C, EmptyShell);
+
+ static bool classof(const Stmt *T) {
+ return T->getStmtClass() == OMPBarrierDirectiveClass;
+ }
+};
+
} // end namespace clang
#endif
OPENMP_DIRECTIVE(single)
OPENMP_DIRECTIVE(master)
OPENMP_DIRECTIVE(taskyield)
+OPENMP_DIRECTIVE(barrier)
OPENMP_DIRECTIVE_EXT(parallel_for, "parallel for")
OPENMP_DIRECTIVE_EXT(parallel_sections, "parallel sections")
def OMPParallelSectionsDirective : DStmt<OMPExecutableDirective>;
def OMPTaskDirective : DStmt<OMPExecutableDirective>;
def OMPTaskyieldDirective : DStmt<OMPExecutableDirective>;
+def OMPBarrierDirective : DStmt<OMPExecutableDirective>;
StmtResult ActOnOpenMPTaskDirective(ArrayRef<OMPClause *> Clauses,
Stmt *AStmt, SourceLocation StartLoc,
SourceLocation EndLoc);
- /// \brief Called on well-formed '\#pragma omp taskyield' after parsing of the
- /// associated statement.
+ /// \brief Called on well-formed '\#pragma omp taskyield'.
StmtResult ActOnOpenMPTaskyieldDirective(SourceLocation StartLoc,
SourceLocation EndLoc);
+ /// \brief Called on well-formed '\#pragma omp barrier'.
+ StmtResult ActOnOpenMPBarrierDirective(SourceLocation StartLoc,
+ SourceLocation EndLoc);
OMPClause *ActOnOpenMPSingleExprClause(OpenMPClauseKind Kind,
Expr *Expr,
STMT_OMP_PARALLEL_SECTIONS_DIRECTIVE,
STMT_OMP_TASK_DIRECTIVE,
STMT_OMP_TASKYIELD_DIRECTIVE,
+ STMT_OMP_BARRIER_DIRECTIVE,
// ARC
EXPR_OBJC_BRIDGED_CAST, // ObjCBridgedCastExpr
return new (Mem) OMPTaskyieldDirective();
}
+OMPBarrierDirective *OMPBarrierDirective::Create(const ASTContext &C,
+ SourceLocation StartLoc,
+ SourceLocation EndLoc) {
+ void *Mem = C.Allocate(sizeof(OMPBarrierDirective));
+ OMPBarrierDirective *Dir = new (Mem) OMPBarrierDirective(StartLoc, EndLoc);
+ return Dir;
+}
+
+OMPBarrierDirective *OMPBarrierDirective::CreateEmpty(const ASTContext &C,
+ EmptyShell) {
+ void *Mem = C.Allocate(sizeof(OMPBarrierDirective));
+ return new (Mem) OMPBarrierDirective();
+}
+
PrintOMPExecutableDirective(Node);
}
+void StmtPrinter::VisitOMPBarrierDirective(OMPBarrierDirective *Node) {
+ Indent() << "#pragma omp barrier";
+ PrintOMPExecutableDirective(Node);
+}
+
//===----------------------------------------------------------------------===//
// Expr printing methods.
//===----------------------------------------------------------------------===//
VisitOMPExecutableDirective(S);
}
+void StmtProfiler::VisitOMPBarrierDirective(const OMPBarrierDirective *S) {
+ VisitOMPExecutableDirective(S);
+}
+
void StmtProfiler::VisitExpr(const Expr *S) {
VisitStmt(S);
}
case OMPD_section:
case OMPD_master:
case OMPD_taskyield:
+ case OMPD_barrier:
break;
}
return false;
case Stmt::OMPTaskyieldDirectiveClass:
EmitOMPTaskyieldDirective(cast<OMPTaskyieldDirective>(*S));
break;
+ case Stmt::OMPBarrierDirectiveClass:
+ EmitOMPBarrierDirective(cast<OMPBarrierDirective>(*S));
+ break;
}
}
llvm_unreachable("CodeGen for 'omp taskyield' is not supported yet.");
}
+void CodeGenFunction::EmitOMPBarrierDirective(const OMPBarrierDirective &) {
+ llvm_unreachable("CodeGen for 'omp barrier' is not supported yet.");
+}
+
void EmitOMPParallelSectionsDirective(const OMPParallelSectionsDirective &S);
void EmitOMPTaskDirective(const OMPTaskDirective &S);
void EmitOMPTaskyieldDirective(const OMPTaskyieldDirective &S);
+ void EmitOMPBarrierDirective(const OMPBarrierDirective &S);
//===--------------------------------------------------------------------===//
// LValue Expression Emission
case OMPD_simd:
case OMPD_task:
case OMPD_taskyield:
+ case OMPD_barrier:
case OMPD_for:
case OMPD_sections:
case OMPD_section:
/// executable-directive:
/// annot_pragma_openmp 'parallel' | 'simd' | 'for' | 'sections' |
/// 'section' | 'single' | 'master' | 'parallel for' |
-/// 'parallel sections' | 'task' | 'taskyield' {clause}
+/// 'parallel sections' | 'task' | 'taskyield' | 'barrier' {clause}
/// annot_pragma_openmp_end
///
StmtResult
SkipUntil(tok::annot_pragma_openmp_end);
break;
case OMPD_taskyield:
+ case OMPD_barrier:
if (!StandAloneAllowed) {
Diag(Tok, diag::err_omp_immediate_directive)
<< getOpenMPDirectiveName(DKind);
Params);
break;
}
+ case OMPD_barrier: {
+ Sema::CapturedParamNameType Params[] = {
+ std::make_pair(StringRef(), QualType()) // __context with shared vars
+ };
+ ActOnCapturedRegionStart(DSAStack->getConstructLoc(), CurScope, CR_OpenMP,
+ Params);
+ break;
+ }
case OMPD_threadprivate:
llvm_unreachable("OpenMP Directive is not allowed");
case OMPD_unknown:
// | parallel |parallel sections| * |
// | parallel | task | * |
// | parallel | taskyield | * |
+ // | parallel | barrier | * |
// +------------------+-----------------+------------------------------------+
// | for | parallel | * |
// | for | for | + |
// | for |parallel sections| * |
// | for | task | * |
// | for | taskyield | * |
+ // | for | barrier | + |
// +------------------+-----------------+------------------------------------+
// | master | parallel | * |
// | master | for | + |
// | master |parallel sections| * |
// | master | task | * |
// | master | taskyield | * |
+ // | master | barrier | + |
// +------------------+-----------------+------------------------------------+
// | simd | parallel | |
// | simd | for | |
// | simd |parallel sections| |
// | simd | task | |
// | simd | taskyield | |
+ // | simd | barrier | |
// +------------------+-----------------+------------------------------------+
// | sections | parallel | * |
// | sections | for | + |
// | sections |parallel sections| * |
// | sections | task | * |
// | sections | taskyield | * |
+ // | sections | barrier | + |
// +------------------+-----------------+------------------------------------+
// | section | parallel | * |
// | section | for | + |
// | section |parallel sections| * |
// | section | task | * |
// | section | taskyield | * |
+ // | section | barrier | + |
// +------------------+-----------------+------------------------------------+
// | single | parallel | * |
// | single | for | + |
// | single |parallel sections| * |
// | single | task | * |
// | single | taskyield | * |
+ // | single | barrier | + |
// +------------------+-----------------+------------------------------------+
// | parallel for | parallel | * |
// | parallel for | for | + |
// | parallel for |parallel sections| * |
// | parallel for | task | * |
// | parallel for | taskyield | * |
+ // | parallel for | barrier | + |
// +------------------+-----------------+------------------------------------+
// | parallel sections| parallel | * |
// | parallel sections| for | + |
// | parallel sections|parallel sections| * |
// | parallel sections| task | * |
// | parallel sections| taskyield | * |
+ // | parallel sections| barrier | + |
// +------------------+-----------------+------------------------------------+
// | task | parallel | * |
// | task | for | + |
// | task |parallel sections| * |
// | task | task | * |
// | task | taskyield | * |
+ // | task | barrier | + |
// +------------------+-----------------+------------------------------------+
if (Stack->getCurScope()) {
auto ParentRegion = Stack->getParentDirective();
// atomic (TODO), or explicit task region.
NestingProhibited = isOpenMPWorksharingDirective(ParentRegion) ||
ParentRegion == OMPD_task;
+ } else if (CurrentRegion == OMPD_barrier) {
+ // OpenMP [2.16, Nesting of Regions]
+ // A barrier region may not be closely nested inside a worksharing,
+ // explicit task, critical(TODO), ordered(TODO), atomic(TODO), or master
+ // region.
+ NestingProhibited = isOpenMPWorksharingDirective(ParentRegion) ||
+ ParentRegion == OMPD_task ||
+ ParentRegion == OMPD_master;
} else if (isOpenMPWorksharingDirective(CurrentRegion) &&
!isOpenMPParallelDirective(CurrentRegion) &&
!isOpenMPSimdDirective(CurrentRegion)) {
"No associated statement allowed for 'omp taskyield' directive");
Res = ActOnOpenMPTaskyieldDirective(StartLoc, EndLoc);
break;
+ case OMPD_barrier:
+ assert(ClausesWithImplicit.empty() &&
+ "No clauses are allowed for 'omp barrier' directive");
+ assert(AStmt == nullptr &&
+ "No associated statement allowed for 'omp barrier' directive");
+ Res = ActOnOpenMPBarrierDirective(StartLoc, EndLoc);
+ break;
case OMPD_threadprivate:
llvm_unreachable("OpenMP Directive is not allowed");
case OMPD_unknown:
return OMPTaskyieldDirective::Create(Context, StartLoc, EndLoc);
}
+StmtResult Sema::ActOnOpenMPBarrierDirective(SourceLocation StartLoc,
+ SourceLocation EndLoc) {
+ return OMPBarrierDirective::Create(Context, StartLoc, EndLoc);
+}
+
OMPClause *Sema::ActOnOpenMPSingleExprClause(OpenMPClauseKind Kind, Expr *Expr,
SourceLocation StartLoc,
SourceLocation LParenLoc,
return Res;
}
+template <typename Derived>
+StmtResult
+TreeTransform<Derived>::TransformOMPBarrierDirective(OMPBarrierDirective *D) {
+ DeclarationNameInfo DirName;
+ getDerived().getSema().StartOpenMPDSABlock(OMPD_barrier, DirName, nullptr,
+ D->getLocStart());
+ StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
+ getDerived().getSema().EndOpenMPDSABlock(Res.get());
+ return Res;
+}
+
//===----------------------------------------------------------------------===//
// OpenMP clause transformation
//===----------------------------------------------------------------------===//
VisitOMPExecutableDirective(D);
}
+void ASTStmtReader::VisitOMPBarrierDirective(OMPBarrierDirective *D) {
+ VisitStmt(D);
+ VisitOMPExecutableDirective(D);
+}
+
//===----------------------------------------------------------------------===//
// ASTReader Implementation
//===----------------------------------------------------------------------===//
S = OMPTaskyieldDirective::CreateEmpty(Context, Empty);
break;
+ case STMT_OMP_BARRIER_DIRECTIVE:
+ S = OMPBarrierDirective::CreateEmpty(Context, Empty);
+ break;
+
case EXPR_CXX_OPERATOR_CALL:
S = new (Context) CXXOperatorCallExpr(Context, Empty);
break;
Code = serialization::STMT_OMP_TASKYIELD_DIRECTIVE;
}
+void ASTStmtWriter::VisitOMPBarrierDirective(OMPBarrierDirective *D) {
+ VisitStmt(D);
+ VisitOMPExecutableDirective(D);
+ Code = serialization::STMT_OMP_BARRIER_DIRECTIVE;
+}
+
//===----------------------------------------------------------------------===//
// ASTWriter Implementation
//===----------------------------------------------------------------------===//
case Stmt::OMPParallelSectionsDirectiveClass:
case Stmt::OMPTaskDirectiveClass:
case Stmt::OMPTaskyieldDirectiveClass:
+ case Stmt::OMPBarrierDirectiveClass:
llvm_unreachable("Stmt should not be in analyzer evaluation loop");
case Stmt::ObjCSubscriptRefExprClass:
--- /dev/null
+// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -ast-print %s | FileCheck %s
+// RUN: %clang_cc1 -fopenmp=libiomp5 -x c++ -std=c++11 -emit-pch -o %t %s
+// RUN: %clang_cc1 -fopenmp=libiomp5 -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>
+T tmain(T argc) {
+ static T a;
+#pragma omp barrier
+ return a + argc;
+}
+// CHECK: static int a;
+// CHECK-NEXT: #pragma omp barrier
+// CHECK: static char a;
+// CHECK-NEXT: #pragma omp barrier
+// CHECK: static T a;
+// CHECK-NEXT: #pragma omp barrier
+
+int main(int argc, char **argv) {
+ static int a;
+// CHECK: static int a;
+#pragma omp barrier
+ // CHECK-NEXT: #pragma omp barrier
+ return tmain(argc) + tmain(argv[0][0]) + a;
+}
+
+#endif
--- /dev/null
+// RUN: %clang_cc1 -verify -fopenmp=libiomp5 -ferror-limit 100 %s
+
+template <class T>
+T tmain(T argc) {
+#pragma omp barrier
+ ;
+#pragma omp barrier untied // expected-error {{unexpected OpenMP clause 'untied' in directive '#pragma omp barrier'}}
+#pragma omp barrier unknown // expected-warning {{extra tokens at the end of '#pragma omp barrier' are ignored}}
+ if (argc)
+#pragma omp barrier // expected-error {{'#pragma omp barrier' cannot be an immediate substatement}}
+ if (argc) {
+#pragma omp barrier
+ }
+ while (argc)
+#pragma omp barrier // expected-error {{'#pragma omp barrier' cannot be an immediate substatement}}
+ while (argc) {
+#pragma omp barrier
+ }
+ do
+#pragma omp barrier // expected-error {{'#pragma omp barrier' cannot be an immediate substatement}}
+ while (argc)
+ ;
+ do {
+#pragma omp barrier
+ } while (argc);
+ switch (argc)
+#pragma omp barrier // expected-error {{'#pragma omp barrier' cannot be an immediate substatement}}
+ switch (argc)
+ case 1:
+#pragma omp barrier // expected-error {{'#pragma omp barrier' cannot be an immediate substatement}}
+ switch (argc)
+ case 1: {
+#pragma omp barrier
+ }
+ switch (argc) {
+#pragma omp barrier
+ case 1:
+#pragma omp barrier // expected-error {{'#pragma omp barrier' cannot be an immediate substatement}}
+ break;
+ default: {
+#pragma omp barrier
+ } break;
+ }
+ for (;;)
+#pragma omp barrier // expected-error {{'#pragma omp barrier' cannot be an immediate substatement}}
+ for (;;) {
+#pragma omp barrier
+ }
+label:
+#pragma omp barrier // expected-error {{'#pragma omp barrier' cannot be an immediate substatement}}
+label1 : {
+#pragma omp barrier
+}
+
+ return T();
+}
+
+int main(int argc, char **argv) {
+#pragma omp barrier
+ ;
+#pragma omp barrier untied // expected-error {{unexpected OpenMP clause 'untied' in directive '#pragma omp barrier'}}
+#pragma omp barrier unknown // expected-warning {{extra tokens at the end of '#pragma omp barrier' are ignored}}
+ if (argc)
+#pragma omp barrier // expected-error {{'#pragma omp barrier' cannot be an immediate substatement}}
+ if (argc) {
+#pragma omp barrier
+ }
+ while (argc)
+#pragma omp barrier // expected-error {{'#pragma omp barrier' cannot be an immediate substatement}}
+ while (argc) {
+#pragma omp barrier
+ }
+ do
+#pragma omp barrier // expected-error {{'#pragma omp barrier' cannot be an immediate substatement}}
+ while (argc)
+ ;
+ do {
+#pragma omp barrier
+ } while (argc);
+ switch (argc)
+#pragma omp barrier // expected-error {{'#pragma omp barrier' cannot be an immediate substatement}}
+ switch (argc)
+ case 1:
+#pragma omp barrier // expected-error {{'#pragma omp barrier' cannot be an immediate substatement}}
+ switch (argc)
+ case 1: {
+#pragma omp barrier
+ }
+ switch (argc) {
+#pragma omp barrier
+ case 1:
+#pragma omp barrier // expected-error {{'#pragma omp barrier' cannot be an immediate substatement}}
+ break;
+ default: {
+#pragma omp barrier
+ } break;
+ }
+ for (;;)
+#pragma omp barrier // expected-error {{'#pragma omp barrier' cannot be an immediate substatement}}
+ for (;;) {
+#pragma omp barrier
+ }
+label:
+#pragma omp barrier // expected-error {{'#pragma omp barrier' cannot be an immediate substatement}}
+label1 : {
+#pragma omp barrier
+}
+
+ return tmain(argc);
+}
#pragma omp taskyield
bar();
}
+#pragma omp parallel
+ {
+#pragma omp barrier
+ bar();
+ }
// SIMD DIRECTIVE
#pragma omp simd
#pragma omp taskyield // expected-error {{OpenMP constructs may not be nested inside a simd region}}
bar();
}
+#pragma omp simd
+ for (int i = 0; i < 10; ++i) {
+#pragma omp barrier // expected-error {{OpenMP constructs may not be nested inside a simd region}}
+ bar();
+ }
// FOR DIRECTIVE
#pragma omp for
#pragma omp taskyield
bar();
}
+#pragma omp for
+ for (int i = 0; i < 10; ++i) {
+#pragma omp barrier // expected-error {{region cannot be closely nested inside 'for' region}}
+ bar();
+ }
// SECTIONS DIRECTIVE
#pragma omp sections
{
#pragma omp taskyield
}
+#pragma omp sections
+ {
+#pragma omp barrier // expected-error {{region cannot be closely nested inside 'sections' region}}
+ }
// SECTION DIRECTIVE
#pragma omp section // expected-error {{orphaned 'omp section' directives are prohibited, it must be closely nested to a sections region}}
bar();
}
}
+#pragma omp sections
+ {
+#pragma omp section
+ {
+#pragma omp barrier // expected-error {{region cannot be closely nested inside 'section' region}}
+ bar();
+ }
+ }
// SINGLE DIRECTIVE
#pragma omp single
#pragma omp taskyield
bar();
}
+#pragma omp single
+ {
+#pragma omp barrier // expected-error {{region cannot be closely nested inside 'single' region}}
+ bar();
+ }
// MASTER DIRECTIVE
#pragma omp master
#pragma omp taskyield
bar();
}
+#pragma omp master
+ {
+#pragma omp barrier // expected-error {{region cannot be closely nested inside 'master' region}}
+ bar();
+ }
// PARALLEL FOR DIRECTIVE
#pragma omp parallel for
#pragma omp taskyield
bar();
}
+#pragma omp parallel for
+ for (int i = 0; i < 10; ++i) {
+#pragma omp barrier // expected-error {{region cannot be closely nested inside 'parallel for' region}}
+ bar();
+ }
// PARALLEL SECTIONS DIRECTIVE
#pragma omp parallel sections
{
#pragma omp taskyield
}
+#pragma omp parallel sections
+ {
+#pragma omp barrier // expected-error {{region cannot be closely nested inside 'parallel sections' region}}
+ }
// TASK DIRECTIVE
#pragma omp task
#pragma omp taskyield
bar();
}
+#pragma omp task
+ {
+#pragma omp barrier // expected-error {{region cannot be closely nested inside 'task' region}}
+ bar();
+ }
}
void foo() {
#pragma omp taskyield
bar();
}
+#pragma omp parallel
+ {
+#pragma omp barrier
+ bar();
+ }
// SIMD DIRECTIVE
#pragma omp simd
#pragma omp taskyield // expected-error {{OpenMP constructs may not be nested inside a simd region}}
bar();
}
+#pragma omp simd
+ for (int i = 0; i < 10; ++i) {
+#pragma omp barrier // expected-error {{OpenMP constructs may not be nested inside a simd region}}
+ bar();
+ }
// FOR DIRECTIVE
#pragma omp for
#pragma omp taskyield
bar();
}
+#pragma omp for
+ for (int i = 0; i < 10; ++i) {
+#pragma omp barrier // expected-error {{region cannot be closely nested inside 'for' region}}
+ bar();
+ }
// SECTIONS DIRECTIVE
#pragma omp sections
}
#pragma omp sections
{
-#pragma omp task
+#pragma omp taskyield
+ }
+#pragma omp sections
+ {
+#pragma omp barrier // expected-error {{region cannot be closely nested inside 'sections' region}}
bar();
}
bar();
}
}
+#pragma omp sections
+ {
+#pragma omp section
+ {
+#pragma omp barrier // expected-error {{region cannot be closely nested inside 'section' region}}
+ bar();
+ }
+ }
// SINGLE DIRECTIVE
#pragma omp single
#pragma omp taskyield
bar();
}
+#pragma omp single
+ {
+#pragma omp barrier // expected-error {{region cannot be closely nested inside 'single' region}}
+ bar();
+ }
// MASTER DIRECTIVE
#pragma omp master
#pragma omp taskyield
bar();
}
+#pragma omp master
+ {
+#pragma omp barrier // expected-error {{region cannot be closely nested inside 'master' region}}
+ bar();
+ }
// PARALLEL FOR DIRECTIVE
#pragma omp parallel for
#pragma omp taskyield
bar();
}
+#pragma omp parallel for
+ for (int i = 0; i < 10; ++i) {
+#pragma omp barrier // expected-error {{region cannot be closely nested inside 'parallel for' region}}
+ bar();
+ }
// PARALLEL SECTIONS DIRECTIVE
#pragma omp parallel sections
{
#pragma omp taskyield
}
+#pragma omp parallel sections
+ {
+#pragma omp barrier // expected-error {{region cannot be closely nested inside 'parallel sections' region}}
+ }
// TASK DIRECTIVE
#pragma omp task
#pragma omp taskyield
bar();
}
+#pragma omp task
+ {
+#pragma omp barrier // expected-error {{region cannot be closely nested inside 'task' region}}
+ bar();
+ }
return foo<int>();
}
void VisitOMPParallelSectionsDirective(const OMPParallelSectionsDirective *D);
void VisitOMPTaskDirective(const OMPTaskDirective *D);
void VisitOMPTaskyieldDirective(const OMPTaskyieldDirective *D);
+ void VisitOMPBarrierDirective(const OMPBarrierDirective *D);
private:
void AddDeclarationNameInfo(const Stmt *S);
VisitOMPExecutableDirective(D);
}
+void EnqueueVisitor::VisitOMPBarrierDirective(const OMPBarrierDirective *D) {
+ VisitOMPExecutableDirective(D);
+}
+
void CursorVisitor::EnqueueWorkList(VisitorWorkList &WL, const Stmt *S) {
EnqueueVisitor(WL, MakeCXCursor(S, StmtParent, TU,RegionOfInterest)).Visit(S);
}
return cxstring::createRef("OMPTaskDirective");
case CXCursor_OMPTaskyieldDirective:
return cxstring::createRef("OMPTaskyieldDirective");
+ case CXCursor_OMPBarrierDirective:
+ return cxstring::createRef("OMPBarrierDirective");
}
llvm_unreachable("Unhandled CXCursorKind");
case Stmt::OMPTaskyieldDirectiveClass:
K = CXCursor_OMPTaskyieldDirective;
break;
+ case Stmt::OMPBarrierDirectiveClass:
+ K = CXCursor_OMPBarrierDirective;
+ break;
}
CXCursor C = { K, 0, { Parent, S, TU } };
projects / clang / commitdiff