*/
CXCursor_OMPBarrierDirective = 243,
+ /** \brief OpenMP taskwait directive.
+ */
+ CXCursor_OMPTaskwaitDirective = 244,
+
/** \brief Windows Structured Exception Handling's leave statement.
*/
- CXCursor_SEHLeaveStmt = 244,
+ CXCursor_SEHLeaveStmt = 245,
CXCursor_LastStmt = CXCursor_SEHLeaveStmt,
DEF_TRAVERSE_STMT(OMPBarrierDirective,
{ TRY_TO(TraverseOMPExecutableDirective(S)); })
+DEF_TRAVERSE_STMT(OMPTaskwaitDirective,
+ { TRY_TO(TraverseOMPExecutableDirective(S)); })
+
// OpenMP clauses.
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseOMPClause(OMPClause *C) {
DEF_TRAVERSE_STMT(OMPBarrierDirective,
{ TRY_TO(TraverseOMPExecutableDirective(S)); })
+DEF_TRAVERSE_STMT(OMPTaskwaitDirective,
+ { TRY_TO(TraverseOMPExecutableDirective(S)); })
+
// OpenMP clauses.
template <typename Derived>
bool RecursiveASTVisitor<Derived>::TraverseOMPClause(OMPClause *C) {
}
};
+/// \brief This represents '#pragma omp taskwait' directive.
+///
+/// \code
+/// #pragma omp taskwait
+/// \endcode
+///
+class OMPTaskwaitDirective : 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.
+ ///
+ OMPTaskwaitDirective(SourceLocation StartLoc, SourceLocation EndLoc)
+ : OMPExecutableDirective(this, OMPTaskwaitDirectiveClass, OMPD_taskwait,
+ StartLoc, EndLoc, 0, 0) {}
+
+ /// \brief Build an empty directive.
+ ///
+ explicit OMPTaskwaitDirective()
+ : OMPExecutableDirective(this, OMPTaskwaitDirectiveClass, OMPD_taskwait,
+ 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 OMPTaskwaitDirective *
+ Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc);
+
+ /// \brief Creates an empty directive.
+ ///
+ /// \param C AST context.
+ ///
+ static OMPTaskwaitDirective *CreateEmpty(const ASTContext &C, EmptyShell);
+
+ static bool classof(const Stmt *T) {
+ return T->getStmtClass() == OMPTaskwaitDirectiveClass;
+ }
+};
+
} // end namespace clang
#endif
OPENMP_DIRECTIVE(master)
OPENMP_DIRECTIVE(taskyield)
OPENMP_DIRECTIVE(barrier)
+OPENMP_DIRECTIVE(taskwait)
OPENMP_DIRECTIVE_EXT(parallel_for, "parallel for")
OPENMP_DIRECTIVE_EXT(parallel_sections, "parallel sections")
def OMPTaskDirective : DStmt<OMPExecutableDirective>;
def OMPTaskyieldDirective : DStmt<OMPExecutableDirective>;
def OMPBarrierDirective : DStmt<OMPExecutableDirective>;
+def OMPTaskwaitDirective : DStmt<OMPExecutableDirective>;
/// \brief Called on well-formed '\#pragma omp barrier'.
StmtResult ActOnOpenMPBarrierDirective(SourceLocation StartLoc,
SourceLocation EndLoc);
+ /// \brief Called on well-formed '\#pragma omp taskwait'.
+ StmtResult ActOnOpenMPTaskwaitDirective(SourceLocation StartLoc,
+ SourceLocation EndLoc);
OMPClause *ActOnOpenMPSingleExprClause(OpenMPClauseKind Kind,
Expr *Expr,
STMT_OMP_TASK_DIRECTIVE,
STMT_OMP_TASKYIELD_DIRECTIVE,
STMT_OMP_BARRIER_DIRECTIVE,
+ STMT_OMP_TASKWAIT_DIRECTIVE,
// ARC
EXPR_OBJC_BRIDGED_CAST, // ObjCBridgedCastExpr
return new (Mem) OMPBarrierDirective();
}
+OMPTaskwaitDirective *OMPTaskwaitDirective::Create(const ASTContext &C,
+ SourceLocation StartLoc,
+ SourceLocation EndLoc) {
+ void *Mem = C.Allocate(sizeof(OMPTaskwaitDirective));
+ OMPTaskwaitDirective *Dir = new (Mem) OMPTaskwaitDirective(StartLoc, EndLoc);
+ return Dir;
+}
+
+OMPTaskwaitDirective *OMPTaskwaitDirective::CreateEmpty(const ASTContext &C,
+ EmptyShell) {
+ void *Mem = C.Allocate(sizeof(OMPTaskwaitDirective));
+ return new (Mem) OMPTaskwaitDirective();
+}
+
PrintOMPExecutableDirective(Node);
}
+void StmtPrinter::VisitOMPTaskwaitDirective(OMPTaskwaitDirective *Node) {
+ Indent() << "#pragma omp taskwait";
+ PrintOMPExecutableDirective(Node);
+}
+
//===----------------------------------------------------------------------===//
// Expr printing methods.
//===----------------------------------------------------------------------===//
VisitOMPExecutableDirective(S);
}
+void StmtProfiler::VisitOMPTaskwaitDirective(const OMPTaskwaitDirective *S) {
+ VisitOMPExecutableDirective(S);
+}
+
void StmtProfiler::VisitExpr(const Expr *S) {
VisitStmt(S);
}
case OMPD_master:
case OMPD_taskyield:
case OMPD_barrier:
+ case OMPD_taskwait:
break;
}
return false;
case Stmt::OMPBarrierDirectiveClass:
EmitOMPBarrierDirective(cast<OMPBarrierDirective>(*S));
break;
+ case Stmt::OMPTaskwaitDirectiveClass:
+ EmitOMPTaskwaitDirective(cast<OMPTaskwaitDirective>(*S));
+ break;
}
}
llvm_unreachable("CodeGen for 'omp barrier' is not supported yet.");
}
+void CodeGenFunction::EmitOMPTaskwaitDirective(const OMPTaskwaitDirective &) {
+ llvm_unreachable("CodeGen for 'omp taskwait' is not supported yet.");
+}
+
void EmitOMPTaskDirective(const OMPTaskDirective &S);
void EmitOMPTaskyieldDirective(const OMPTaskyieldDirective &S);
void EmitOMPBarrierDirective(const OMPBarrierDirective &S);
+ void EmitOMPTaskwaitDirective(const OMPTaskwaitDirective &S);
//===--------------------------------------------------------------------===//
// LValue Expression Emission
case OMPD_task:
case OMPD_taskyield:
case OMPD_barrier:
+ case OMPD_taskwait:
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' | 'barrier' {clause}
-/// annot_pragma_openmp_end
+/// 'parallel sections' | 'task' | 'taskyield' | 'barrier' | 'taskwait'
+/// {clause} annot_pragma_openmp_end
///
StmtResult
Parser::ParseOpenMPDeclarativeOrExecutableDirective(bool StandAloneAllowed) {
break;
case OMPD_taskyield:
case OMPD_barrier:
+ case OMPD_taskwait:
if (!StandAloneAllowed) {
Diag(Tok, diag::err_omp_immediate_directive)
<< getOpenMPDirectiveName(DKind);
/// declaration
/// [GNU] '__extension__' declaration
/// statement
-/// [OMP] openmp-directive [TODO]
///
/// [GNU] label-declarations:
/// [GNU] label-declaration
/// [GNU] label-declaration:
/// [GNU] '__label__' identifier-list ';'
///
-/// [OMP] openmp-directive: [TODO]
-/// [OMP] barrier-directive
-/// [OMP] flush-directive
-///
StmtResult Parser::ParseCompoundStatement(bool isStmtExpr,
unsigned ScopeFlags) {
assert(Tok.is(tok::l_brace) && "Not a compount stmt!");
Params);
break;
}
+ case OMPD_taskwait: {
+ 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 | task | * |
// | parallel | taskyield | * |
// | parallel | barrier | * |
+ // | parallel | taskwait | * |
// +------------------+-----------------+------------------------------------+
// | for | parallel | * |
// | for | for | + |
// | for | task | * |
// | for | taskyield | * |
// | for | barrier | + |
+ // | for | taskwait | * |
// +------------------+-----------------+------------------------------------+
// | master | parallel | * |
// | master | for | + |
// | master | task | * |
// | master | taskyield | * |
// | master | barrier | + |
+ // | master | taskwait | * |
// +------------------+-----------------+------------------------------------+
// | simd | parallel | |
// | simd | for | |
// | simd | task | |
// | simd | taskyield | |
// | simd | barrier | |
+ // | simd | taskwait | |
// +------------------+-----------------+------------------------------------+
// | sections | parallel | * |
// | sections | for | + |
// | sections | task | * |
// | sections | taskyield | * |
// | sections | barrier | + |
+ // | sections | taskwait | * |
// +------------------+-----------------+------------------------------------+
// | section | parallel | * |
// | section | for | + |
// | section | task | * |
// | section | taskyield | * |
// | section | barrier | + |
+ // | section | taskwait | * |
// +------------------+-----------------+------------------------------------+
// | single | parallel | * |
// | single | for | + |
// | single | task | * |
// | single | taskyield | * |
// | single | barrier | + |
+ // | single | taskwait | * |
// +------------------+-----------------+------------------------------------+
// | parallel for | parallel | * |
// | parallel for | for | + |
// | parallel for | task | * |
// | parallel for | taskyield | * |
// | parallel for | barrier | + |
+ // | parallel for | taskwait | * |
// +------------------+-----------------+------------------------------------+
// | parallel sections| parallel | * |
// | parallel sections| for | + |
// | parallel sections| task | * |
// | parallel sections| taskyield | * |
// | parallel sections| barrier | + |
+ // | parallel sections| taskwait | * |
// +------------------+-----------------+------------------------------------+
// | task | parallel | * |
// | task | for | + |
// | task | task | * |
// | task | taskyield | * |
// | task | barrier | + |
+ // | task | taskwait | * |
// +------------------+-----------------+------------------------------------+
if (Stack->getCurScope()) {
auto ParentRegion = Stack->getParentDirective();
"No associated statement allowed for 'omp barrier' directive");
Res = ActOnOpenMPBarrierDirective(StartLoc, EndLoc);
break;
+ case OMPD_taskwait:
+ assert(ClausesWithImplicit.empty() &&
+ "No clauses are allowed for 'omp taskwait' directive");
+ assert(AStmt == nullptr &&
+ "No associated statement allowed for 'omp taskwait' directive");
+ Res = ActOnOpenMPTaskwaitDirective(StartLoc, EndLoc);
+ break;
case OMPD_threadprivate:
llvm_unreachable("OpenMP Directive is not allowed");
case OMPD_unknown:
return OMPBarrierDirective::Create(Context, StartLoc, EndLoc);
}
+StmtResult Sema::ActOnOpenMPTaskwaitDirective(SourceLocation StartLoc,
+ SourceLocation EndLoc) {
+ return OMPTaskwaitDirective::Create(Context, StartLoc, EndLoc);
+}
+
OMPClause *Sema::ActOnOpenMPSingleExprClause(OpenMPClauseKind Kind, Expr *Expr,
SourceLocation StartLoc,
SourceLocation LParenLoc,
return Res;
}
+template <typename Derived>
+StmtResult
+TreeTransform<Derived>::TransformOMPTaskwaitDirective(OMPTaskwaitDirective *D) {
+ DeclarationNameInfo DirName;
+ getDerived().getSema().StartOpenMPDSABlock(OMPD_taskwait, DirName, nullptr,
+ D->getLocStart());
+ StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
+ getDerived().getSema().EndOpenMPDSABlock(Res.get());
+ return Res;
+}
+
//===----------------------------------------------------------------------===//
// OpenMP clause transformation
//===----------------------------------------------------------------------===//
VisitOMPExecutableDirective(D);
}
+void ASTStmtReader::VisitOMPTaskwaitDirective(OMPTaskwaitDirective *D) {
+ VisitStmt(D);
+ VisitOMPExecutableDirective(D);
+}
+
//===----------------------------------------------------------------------===//
// ASTReader Implementation
//===----------------------------------------------------------------------===//
S = OMPBarrierDirective::CreateEmpty(Context, Empty);
break;
+ case STMT_OMP_TASKWAIT_DIRECTIVE:
+ S = OMPTaskwaitDirective::CreateEmpty(Context, Empty);
+ break;
+
case EXPR_CXX_OPERATOR_CALL:
S = new (Context) CXXOperatorCallExpr(Context, Empty);
break;
Code = serialization::STMT_OMP_BARRIER_DIRECTIVE;
}
+void ASTStmtWriter::VisitOMPTaskwaitDirective(OMPTaskwaitDirective *D) {
+ VisitStmt(D);
+ VisitOMPExecutableDirective(D);
+ Code = serialization::STMT_OMP_TASKWAIT_DIRECTIVE;
+}
+
//===----------------------------------------------------------------------===//
// ASTWriter Implementation
//===----------------------------------------------------------------------===//
case Stmt::OMPTaskDirectiveClass:
case Stmt::OMPTaskyieldDirectiveClass:
case Stmt::OMPBarrierDirectiveClass:
+ case Stmt::OMPTaskwaitDirectiveClass:
llvm_unreachable("Stmt should not be in analyzer evaluation loop");
case Stmt::ObjCSubscriptRefExprClass:
#pragma omp barrier
bar();
}
+#pragma omp parallel
+ {
+#pragma omp taskwait
+ bar();
+ }
// SIMD DIRECTIVE
#pragma omp simd
#pragma omp barrier // 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 taskwait // expected-error {{OpenMP constructs may not be nested inside a simd region}}
+ bar();
+ }
// FOR DIRECTIVE
#pragma omp for
#pragma omp barrier // expected-error {{region cannot be closely nested inside 'for' region}}
bar();
}
+#pragma omp for
+ for (int i = 0; i < 10; ++i) {
+#pragma omp taskwait
+ bar();
+ }
// SECTIONS DIRECTIVE
#pragma omp sections
{
#pragma omp barrier // expected-error {{region cannot be closely nested inside 'sections' region}}
}
+#pragma omp sections
+ {
+#pragma omp taskwait
+ }
// 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 taskwait
+ bar();
+ }
+ }
// SINGLE DIRECTIVE
#pragma omp single
#pragma omp barrier // expected-error {{region cannot be closely nested inside 'single' region}}
bar();
}
+#pragma omp single
+ {
+#pragma omp taskwait
+ bar();
+ }
// MASTER DIRECTIVE
#pragma omp master
#pragma omp barrier // expected-error {{region cannot be closely nested inside 'master' region}}
bar();
}
+#pragma omp master
+ {
+#pragma omp taskwait
+ bar();
+ }
// PARALLEL FOR DIRECTIVE
#pragma omp parallel for
#pragma omp barrier // expected-error {{region cannot be closely nested inside 'parallel for' region}}
bar();
}
+#pragma omp parallel for
+ for (int i = 0; i < 10; ++i) {
+#pragma omp taskwait
+ bar();
+ }
// PARALLEL SECTIONS DIRECTIVE
#pragma omp parallel sections
{
#pragma omp barrier // expected-error {{region cannot be closely nested inside 'parallel sections' region}}
}
+#pragma omp parallel sections
+ {
+#pragma omp taskwait
+ }
// TASK DIRECTIVE
#pragma omp task
#pragma omp barrier // expected-error {{region cannot be closely nested inside 'task' region}}
bar();
}
+#pragma omp task
+ {
+#pragma omp taskwait
+ bar();
+ }
}
void foo() {
#pragma omp barrier
bar();
}
+#pragma omp parallel
+ {
+#pragma omp taskwait
+ bar();
+ }
// SIMD DIRECTIVE
#pragma omp simd
#pragma omp barrier // 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 taskwait // expected-error {{OpenMP constructs may not be nested inside a simd region}}
+ bar();
+ }
// FOR DIRECTIVE
#pragma omp for
#pragma omp barrier // expected-error {{region cannot be closely nested inside 'for' region}}
bar();
}
+#pragma omp for
+ for (int i = 0; i < 10; ++i) {
+#pragma omp taskwait
+ bar();
+ }
// SECTIONS DIRECTIVE
#pragma omp sections
#pragma omp barrier // expected-error {{region cannot be closely nested inside 'sections' region}}
bar();
}
+#pragma omp sections
+ {
+#pragma omp taskwait
+ }
// 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 taskwait
+ bar();
+ }
+ }
// SINGLE DIRECTIVE
#pragma omp single
#pragma omp barrier // expected-error {{region cannot be closely nested inside 'single' region}}
bar();
}
+#pragma omp single
+ {
+#pragma omp taskwait
+ bar();
+ }
// MASTER DIRECTIVE
#pragma omp master
#pragma omp barrier // expected-error {{region cannot be closely nested inside 'master' region}}
bar();
}
+#pragma omp master
+ {
+#pragma omp taskwait
+ bar();
+ }
// PARALLEL FOR DIRECTIVE
#pragma omp parallel for
#pragma omp barrier // expected-error {{region cannot be closely nested inside 'parallel for' region}}
bar();
}
+#pragma omp parallel for
+ for (int i = 0; i < 10; ++i) {
+#pragma omp taskwait
+ bar();
+ }
// PARALLEL SECTIONS DIRECTIVE
#pragma omp parallel sections
{
#pragma omp barrier // expected-error {{region cannot be closely nested inside 'parallel sections' region}}
}
+#pragma omp parallel sections
+ {
+#pragma omp taskwait
+ }
// TASK DIRECTIVE
#pragma omp task
#pragma omp barrier // expected-error {{region cannot be closely nested inside 'task' region}}
bar();
}
+#pragma omp task
+ {
+#pragma omp taskwait
+ bar();
+ }
return foo<int>();
}
--- /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 taskwait
+ return a + argc;
+}
+// CHECK: static int a;
+// CHECK-NEXT: #pragma omp taskwait
+// CHECK: static char a;
+// CHECK-NEXT: #pragma omp taskwait
+// CHECK: static T a;
+// CHECK-NEXT: #pragma omp taskwait
+
+int main(int argc, char **argv) {
+ static int a;
+// CHECK: static int a;
+#pragma omp taskwait
+ // CHECK-NEXT: #pragma omp taskwait
+ 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 taskwait
+ ;
+#pragma omp taskwait untied // expected-error {{unexpected OpenMP clause 'untied' in directive '#pragma omp taskwait'}}
+#pragma omp taskwait unknown // expected-warning {{extra tokens at the end of '#pragma omp taskwait' are ignored}}
+ if (argc)
+#pragma omp taskwait // expected-error {{'#pragma omp taskwait' cannot be an immediate substatement}}
+ if (argc) {
+#pragma omp taskwait
+ }
+ while (argc)
+#pragma omp taskwait // expected-error {{'#pragma omp taskwait' cannot be an immediate substatement}}
+ while (argc) {
+#pragma omp taskwait
+ }
+ do
+#pragma omp taskwait // expected-error {{'#pragma omp taskwait' cannot be an immediate substatement}}
+ while (argc)
+ ;
+ do {
+#pragma omp taskwait
+ } while (argc);
+ switch (argc)
+#pragma omp taskwait // expected-error {{'#pragma omp taskwait' cannot be an immediate substatement}}
+ switch (argc)
+ case 1:
+#pragma omp taskwait // expected-error {{'#pragma omp taskwait' cannot be an immediate substatement}}
+ switch (argc)
+ case 1: {
+#pragma omp taskwait
+ }
+ switch (argc) {
+#pragma omp taskwait
+ case 1:
+#pragma omp taskwait // expected-error {{'#pragma omp taskwait' cannot be an immediate substatement}}
+ break;
+ default: {
+#pragma omp taskwait
+ } break;
+ }
+ for (;;)
+#pragma omp taskwait // expected-error {{'#pragma omp taskwait' cannot be an immediate substatement}}
+ for (;;) {
+#pragma omp taskwait
+ }
+label:
+#pragma omp taskwait // expected-error {{'#pragma omp taskwait' cannot be an immediate substatement}}
+label1 : {
+#pragma omp taskwait
+}
+
+ return T();
+}
+
+int main(int argc, char **argv) {
+#pragma omp taskwait
+ ;
+#pragma omp taskwait untied // expected-error {{unexpected OpenMP clause 'untied' in directive '#pragma omp taskwait'}}
+#pragma omp taskwait unknown // expected-warning {{extra tokens at the end of '#pragma omp taskwait' are ignored}}
+ if (argc)
+#pragma omp taskwait // expected-error {{'#pragma omp taskwait' cannot be an immediate substatement}}
+ if (argc) {
+#pragma omp taskwait
+ }
+ while (argc)
+#pragma omp taskwait // expected-error {{'#pragma omp taskwait' cannot be an immediate substatement}}
+ while (argc) {
+#pragma omp taskwait
+ }
+ do
+#pragma omp taskwait // expected-error {{'#pragma omp taskwait' cannot be an immediate substatement}}
+ while (argc)
+ ;
+ do {
+#pragma omp taskwait
+ } while (argc);
+ switch (argc)
+#pragma omp taskwait // expected-error {{'#pragma omp taskwait' cannot be an immediate substatement}}
+ switch (argc)
+ case 1:
+#pragma omp taskwait // expected-error {{'#pragma omp taskwait' cannot be an immediate substatement}}
+ switch (argc)
+ case 1: {
+#pragma omp taskwait
+ }
+ switch (argc) {
+#pragma omp taskwait
+ case 1:
+#pragma omp taskwait // expected-error {{'#pragma omp taskwait' cannot be an immediate substatement}}
+ break;
+ default: {
+#pragma omp taskwait
+ } break;
+ }
+ for (;;)
+#pragma omp taskwait // expected-error {{'#pragma omp taskwait' cannot be an immediate substatement}}
+ for (;;) {
+#pragma omp taskwait
+ }
+label:
+#pragma omp taskwait // expected-error {{'#pragma omp taskwait' cannot be an immediate substatement}}
+label1 : {
+#pragma omp taskwait
+}
+
+ return tmain(argc);
+}
void VisitOMPTaskDirective(const OMPTaskDirective *D);
void VisitOMPTaskyieldDirective(const OMPTaskyieldDirective *D);
void VisitOMPBarrierDirective(const OMPBarrierDirective *D);
+ void VisitOMPTaskwaitDirective(const OMPTaskwaitDirective *D);
private:
void AddDeclarationNameInfo(const Stmt *S);
VisitOMPExecutableDirective(D);
}
+void EnqueueVisitor::VisitOMPTaskwaitDirective(const OMPTaskwaitDirective *D) {
+ VisitOMPExecutableDirective(D);
+}
+
void CursorVisitor::EnqueueWorkList(VisitorWorkList &WL, const Stmt *S) {
EnqueueVisitor(WL, MakeCXCursor(S, StmtParent, TU,RegionOfInterest)).Visit(S);
}
return cxstring::createRef("OMPTaskyieldDirective");
case CXCursor_OMPBarrierDirective:
return cxstring::createRef("OMPBarrierDirective");
+ case CXCursor_OMPTaskwaitDirective:
+ return cxstring::createRef("OMPTaskwaitDirective");
}
llvm_unreachable("Unhandled CXCursorKind");
case Stmt::OMPBarrierDirectiveClass:
K = CXCursor_OMPBarrierDirective;
break;
+ case Stmt::OMPTaskwaitDirectiveClass:
+ K = CXCursor_OMPTaskwaitDirective;
+ break;
}
CXCursor C = { K, 0, { Parent, S, TU } };