From 0eca5e96c1b22228c8efe6a99df123186bfb340b Mon Sep 17 00:00:00 2001 From: Alexey Bataev Date: Thu, 26 Jun 2014 08:21:58 +0000 Subject: [OPENMP] Initial parsing and sema analysis for 'section' directive. git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@211767 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/clang-c/Index.h | 6 +- include/clang/AST/DataRecursiveASTVisitor.h | 5 ++ include/clang/AST/RecursiveASTVisitor.h | 5 ++ include/clang/AST/StmtOpenMP.h | 47 +++++++++++ include/clang/Basic/DiagnosticSemaKinds.td | 5 ++ include/clang/Basic/OpenMPKinds.def | 1 + include/clang/Basic/StmtNodes.td | 1 + include/clang/Sema/Sema.h | 4 + include/clang/Serialization/ASTBitCodes.h | 1 + lib/AST/Stmt.cpp | 20 +++++ lib/AST/StmtPrinter.cpp | 5 ++ lib/AST/StmtProfile.cpp | 4 + lib/Basic/OpenMPKinds.cpp | 5 +- lib/CodeGen/CGStmt.cpp | 3 + lib/CodeGen/CGStmtOpenMP.cpp | 4 + lib/CodeGen/CodeGenFunction.h | 1 + lib/Parse/ParseOpenMP.cpp | 8 +- lib/Sema/SemaOpenMP.cpp | 45 +++++++++- lib/Sema/TreeTransform.h | 10 +++ lib/Serialization/ASTReaderStmt.cpp | 9 ++ lib/Serialization/ASTWriterStmt.cpp | 6 ++ lib/StaticAnalyzer/Core/ExprEngine.cpp | 1 + test/OpenMP/nesting_of_regions.cpp | 126 +++++++++++++++++++++++----- test/OpenMP/sections_ast_print.cpp | 14 +++- test/OpenMP/sections_misc_messages.c | 22 +++++ tools/libclang/CIndex.cpp | 7 ++ tools/libclang/CXCursor.cpp | 3 + 27 files changed, 335 insertions(+), 33 deletions(-) diff --git a/include/clang-c/Index.h b/include/clang-c/Index.h index 567522e044..909e2dbfe2 100644 --- a/include/clang-c/Index.h +++ b/include/clang-c/Index.h @@ -2147,7 +2147,11 @@ enum CXCursorKind { */ CXCursor_OMPSectionsDirective = 235, - CXCursor_LastStmt = CXCursor_OMPSectionsDirective, + /** \brief OpenMP section directive. + */ + CXCursor_OMPSectionDirective = 236, + + CXCursor_LastStmt = CXCursor_OMPSectionDirective, /** * \brief Cursor that represents the translation unit itself. diff --git a/include/clang/AST/DataRecursiveASTVisitor.h b/include/clang/AST/DataRecursiveASTVisitor.h index 9a27c3954a..536d372ec4 100644 --- a/include/clang/AST/DataRecursiveASTVisitor.h +++ b/include/clang/AST/DataRecursiveASTVisitor.h @@ -2300,6 +2300,11 @@ DEF_TRAVERSE_STMT(OMPSectionsDirective, { return false; }) +DEF_TRAVERSE_STMT(OMPSectionDirective, { + if (!TraverseOMPExecutableDirective(S)) + return false; +}) + // OpenMP clauses. template bool RecursiveASTVisitor::TraverseOMPClause(OMPClause *C) { diff --git a/include/clang/AST/RecursiveASTVisitor.h b/include/clang/AST/RecursiveASTVisitor.h index 9e9d4effd9..eae370e0b8 100644 --- a/include/clang/AST/RecursiveASTVisitor.h +++ b/include/clang/AST/RecursiveASTVisitor.h @@ -2322,6 +2322,11 @@ DEF_TRAVERSE_STMT(OMPSectionsDirective, { return false; }) +DEF_TRAVERSE_STMT(OMPSectionDirective, { + if (!TraverseOMPExecutableDirective(S)) + return false; +}) + // OpenMP clauses. template bool RecursiveASTVisitor::TraverseOMPClause(OMPClause *C) { diff --git a/include/clang/AST/StmtOpenMP.h b/include/clang/AST/StmtOpenMP.h index aca0274192..8b954f45e7 100644 --- a/include/clang/AST/StmtOpenMP.h +++ b/include/clang/AST/StmtOpenMP.h @@ -423,6 +423,53 @@ public: } }; +/// \brief This represents '#pragma omp section' directive. +/// +/// \code +/// #pragma omp section +/// \endcode +/// +class OMPSectionDirective : 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. + /// + OMPSectionDirective(SourceLocation StartLoc, SourceLocation EndLoc) + : OMPExecutableDirective(this, OMPSectionDirectiveClass, OMPD_section, + StartLoc, EndLoc, 0, 1) {} + + /// \brief Build an empty directive. + /// + explicit OMPSectionDirective() + : OMPExecutableDirective(this, OMPSectionDirectiveClass, OMPD_section, + SourceLocation(), SourceLocation(), 0, 1) {} + +public: + /// \brief Creates directive. + /// + /// \param C AST context. + /// \param StartLoc Starting location of the directive kind. + /// \param EndLoc Ending Location of the directive. + /// \param AssociatedStmt Statement, associated with the directive. + /// + static OMPSectionDirective *Create(const ASTContext &C, + SourceLocation StartLoc, + SourceLocation EndLoc, + Stmt *AssociatedStmt); + + /// \brief Creates an empty directive. + /// + /// \param C AST context. + /// + static OMPSectionDirective *CreateEmpty(const ASTContext &C, EmptyShell); + + static bool classof(const Stmt *T) { + return T->getStmtClass() == OMPSectionDirectiveClass; + } +}; + } // end namespace clang #endif diff --git a/include/clang/Basic/DiagnosticSemaKinds.td b/include/clang/Basic/DiagnosticSemaKinds.td index 9be3d8543a..04923dae02 100644 --- a/include/clang/Basic/DiagnosticSemaKinds.td +++ b/include/clang/Basic/DiagnosticSemaKinds.td @@ -7115,6 +7115,11 @@ def err_omp_prohibited_region_simd : Error< "OpenMP constructs may not be nested inside a simd region">; def err_omp_sections_not_compound_stmt : Error< "the statement for '#pragma omp sections' must be a compound statement">; +def err_omp_orphaned_section_directive : Error< + "%select{orphaned 'omp section' directives are prohibited, it|'omp section' directive}0" + " must be closely nested to a sections region%select{|, not a %1 region}0">; +def err_omp_sections_substmt_not_section : Error< + "statement in 'omp sections' directive must be enclosed into a section region">; } // end of OpenMP category let CategoryName = "Related Result Type Issue" in { diff --git a/include/clang/Basic/OpenMPKinds.def b/include/clang/Basic/OpenMPKinds.def index 312b975f26..c47782b816 100644 --- a/include/clang/Basic/OpenMPKinds.def +++ b/include/clang/Basic/OpenMPKinds.def @@ -47,6 +47,7 @@ OPENMP_DIRECTIVE(task) OPENMP_DIRECTIVE(simd) OPENMP_DIRECTIVE(for) OPENMP_DIRECTIVE(sections) +OPENMP_DIRECTIVE(section) // OpenMP clauses. OPENMP_CLAUSE(if, OMPIfClause) diff --git a/include/clang/Basic/StmtNodes.td b/include/clang/Basic/StmtNodes.td index f4ff3ef20f..5236f46883 100644 --- a/include/clang/Basic/StmtNodes.td +++ b/include/clang/Basic/StmtNodes.td @@ -181,3 +181,4 @@ def OMPParallelDirective : DStmt; def OMPSimdDirective : DStmt; def OMPForDirective : DStmt; def OMPSectionsDirective : DStmt; +def OMPSectionDirective : DStmt; diff --git a/include/clang/Sema/Sema.h b/include/clang/Sema/Sema.h index 6d0eef5d56..0a6cd33b8d 100644 --- a/include/clang/Sema/Sema.h +++ b/include/clang/Sema/Sema.h @@ -7327,6 +7327,10 @@ public: StmtResult ActOnOpenMPSectionsDirective(ArrayRef Clauses, Stmt *AStmt, SourceLocation StartLoc, SourceLocation EndLoc); + /// \brief Called on well-formed '\#pragma omp section' after parsing of the + /// associated statement. + StmtResult ActOnOpenMPSectionDirective(Stmt *AStmt, SourceLocation StartLoc, + SourceLocation EndLoc); OMPClause *ActOnOpenMPSingleExprClause(OpenMPClauseKind Kind, Expr *Expr, diff --git a/include/clang/Serialization/ASTBitCodes.h b/include/clang/Serialization/ASTBitCodes.h index 828672e3d6..55cf34fc73 100644 --- a/include/clang/Serialization/ASTBitCodes.h +++ b/include/clang/Serialization/ASTBitCodes.h @@ -1343,6 +1343,7 @@ namespace clang { STMT_OMP_SIMD_DIRECTIVE, STMT_OMP_FOR_DIRECTIVE, STMT_OMP_SECTIONS_DIRECTIVE, + STMT_OMP_SECTION_DIRECTIVE, // ARC EXPR_OBJC_BRIDGED_CAST, // ObjCBridgedCastExpr diff --git a/lib/AST/Stmt.cpp b/lib/AST/Stmt.cpp index 48b3dc5baf..b402f6edd2 100644 --- a/lib/AST/Stmt.cpp +++ b/lib/AST/Stmt.cpp @@ -1410,3 +1410,23 @@ OMPSectionsDirective *OMPSectionsDirective::CreateEmpty(const ASTContext &C, return new (Mem) OMPSectionsDirective(NumClauses); } +OMPSectionDirective *OMPSectionDirective::Create(const ASTContext &C, + SourceLocation StartLoc, + SourceLocation EndLoc, + Stmt *AssociatedStmt) { + unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPSectionsDirective), + llvm::alignOf()); + void *Mem = C.Allocate(Size + sizeof(Stmt *)); + OMPSectionDirective *Dir = new (Mem) OMPSectionDirective(StartLoc, EndLoc); + Dir->setAssociatedStmt(AssociatedStmt); + return Dir; +} + +OMPSectionDirective *OMPSectionDirective::CreateEmpty(const ASTContext &C, + EmptyShell) { + unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPSectionDirective), + llvm::alignOf()); + void *Mem = C.Allocate(Size + sizeof(Stmt *)); + return new (Mem) OMPSectionDirective(); +} + diff --git a/lib/AST/StmtPrinter.cpp b/lib/AST/StmtPrinter.cpp index 46e9cbdc3d..0ac683347f 100644 --- a/lib/AST/StmtPrinter.cpp +++ b/lib/AST/StmtPrinter.cpp @@ -792,6 +792,11 @@ void StmtPrinter::VisitOMPSectionsDirective(OMPSectionsDirective *Node) { PrintOMPExecutableDirective(Node); } +void StmtPrinter::VisitOMPSectionDirective(OMPSectionDirective *Node) { + Indent() << "#pragma omp section"; + PrintOMPExecutableDirective(Node); +} + //===----------------------------------------------------------------------===// // Expr printing methods. //===----------------------------------------------------------------------===// diff --git a/lib/AST/StmtProfile.cpp b/lib/AST/StmtProfile.cpp index 0a9a011b93..804003fb67 100644 --- a/lib/AST/StmtProfile.cpp +++ b/lib/AST/StmtProfile.cpp @@ -364,6 +364,10 @@ void StmtProfiler::VisitOMPSectionsDirective(const OMPSectionsDirective *S) { VisitOMPExecutableDirective(S); } +void StmtProfiler::VisitOMPSectionDirective(const OMPSectionDirective *S) { + VisitOMPExecutableDirective(S); +} + void StmtProfiler::VisitExpr(const Expr *S) { VisitStmt(S); } diff --git a/lib/Basic/OpenMPKinds.cpp b/lib/Basic/OpenMPKinds.cpp index 07e2222f97..547eb32199 100644 --- a/lib/Basic/OpenMPKinds.cpp +++ b/lib/Basic/OpenMPKinds.cpp @@ -204,6 +204,7 @@ bool clang::isAllowedClauseForDirective(OpenMPDirectiveKind DKind, case OMPD_unknown: case OMPD_threadprivate: case OMPD_task: + case OMPD_section: break; } return false; @@ -214,8 +215,8 @@ bool clang::isOpenMPLoopDirective(OpenMPDirectiveKind DKind) { } bool clang::isOpenMPWorksharingDirective(OpenMPDirectiveKind DKind) { - return DKind == OMPD_for || - DKind == OMPD_sections; // TODO add next directives. + return DKind == OMPD_for || DKind == OMPD_sections || + DKind == OMPD_section; // TODO add next directives. } bool clang::isOpenMPParallelDirective(OpenMPDirectiveKind DKind) { diff --git a/lib/CodeGen/CGStmt.cpp b/lib/CodeGen/CGStmt.cpp index 3e49733a9c..c3ad8b369c 100644 --- a/lib/CodeGen/CGStmt.cpp +++ b/lib/CodeGen/CGStmt.cpp @@ -185,6 +185,9 @@ void CodeGenFunction::EmitStmt(const Stmt *S) { case Stmt::OMPSectionsDirectiveClass: EmitOMPSectionsDirective(cast(*S)); break; + case Stmt::OMPSectionDirectiveClass: + EmitOMPSectionDirective(cast(*S)); + break; } } diff --git a/lib/CodeGen/CGStmtOpenMP.cpp b/lib/CodeGen/CGStmtOpenMP.cpp index f75111bce1..ae45aa4abb 100644 --- a/lib/CodeGen/CGStmtOpenMP.cpp +++ b/lib/CodeGen/CGStmtOpenMP.cpp @@ -83,3 +83,7 @@ void CodeGenFunction::EmitOMPSectionsDirective(const OMPSectionsDirective &) { llvm_unreachable("CodeGen for 'omp sections' is not supported yet."); } +void CodeGenFunction::EmitOMPSectionDirective(const OMPSectionDirective &) { + llvm_unreachable("CodeGen for 'omp section' is not supported yet."); +} + diff --git a/lib/CodeGen/CodeGenFunction.h b/lib/CodeGen/CodeGenFunction.h index 8a7ebdd5e9..87453992b1 100644 --- a/lib/CodeGen/CodeGenFunction.h +++ b/lib/CodeGen/CodeGenFunction.h @@ -1904,6 +1904,7 @@ public: void EmitOMPSimdDirective(const OMPSimdDirective &S); void EmitOMPForDirective(const OMPForDirective &S); void EmitOMPSectionsDirective(const OMPSectionsDirective &S); + void EmitOMPSectionDirective(const OMPSectionDirective &S); //===--------------------------------------------------------------------===// // LValue Expression Emission diff --git a/lib/Parse/ParseOpenMP.cpp b/lib/Parse/ParseOpenMP.cpp index 7a3c05e96b..11e888efb4 100644 --- a/lib/Parse/ParseOpenMP.cpp +++ b/lib/Parse/ParseOpenMP.cpp @@ -64,6 +64,7 @@ Parser::DeclGroupPtrTy Parser::ParseOpenMPDeclarativeDirective() { case OMPD_task: case OMPD_for: case OMPD_sections: + case OMPD_section: Diag(Tok, diag::err_omp_unexpected_directive) << getOpenMPDirectiveName(DKind); break; @@ -79,8 +80,8 @@ Parser::DeclGroupPtrTy Parser::ParseOpenMPDeclarativeDirective() { /// annot_pragma_openmp_end /// /// executable-directive: -/// annot_pragma_openmp 'parallel'|'simd'|'for'|'sections' {clause} -/// annot_pragma_openmp_end +/// annot_pragma_openmp 'parallel'|'simd'|'for'|'sections'|'section' +/// {clause} annot_pragma_openmp_end /// StmtResult Parser::ParseOpenMPDeclarativeOrExecutableDirective() { assert(Tok.is(tok::annot_pragma_openmp) && "Not an OpenMP directive!"); @@ -119,7 +120,8 @@ StmtResult Parser::ParseOpenMPDeclarativeOrExecutableDirective() { case OMPD_parallel: case OMPD_simd: case OMPD_for: - case OMPD_sections: { + case OMPD_sections: + case OMPD_section: { ConsumeToken(); if (isOpenMPLoopDirective(DKind)) diff --git a/lib/Sema/SemaOpenMP.cpp b/lib/Sema/SemaOpenMP.cpp index db471b88ad..ba441a2b14 100644 --- a/lib/Sema/SemaOpenMP.cpp +++ b/lib/Sema/SemaOpenMP.cpp @@ -917,6 +917,13 @@ void Sema::ActOnOpenMPRegionStart(OpenMPDirectiveKind DKind, SourceLocation Loc, ActOnCapturedRegionStart(Loc, CurScope, CR_OpenMP, Params); break; } + case OMPD_section: { + Sema::CapturedParamNameType Params[] = { + std::make_pair(StringRef(), QualType()) // __context with shared vars + }; + ActOnCapturedRegionStart(Loc, CurScope, CR_OpenMP, Params); + break; + } case OMPD_threadprivate: case OMPD_task: llvm_unreachable("OpenMP Directive is not allowed"); @@ -939,6 +946,19 @@ bool CheckNestingOfRegions(Sema &SemaRef, DSAStackTy *Stack, SemaRef.Diag(StartLoc, diag::err_omp_prohibited_region_simd); return true; } + if (CurrentRegion == OMPD_section) { + // OpenMP [2.7.2, sections Construct, Restrictions] + // Orphaned section directives are prohibited. That is, the section + // directives must appear within the sections construct and must not be + // encountered elsewhere in the sections region. + if (ParentRegion != OMPD_sections) { + SemaRef.Diag(StartLoc, diag::err_omp_orphaned_section_directive) + << (ParentRegion != OMPD_unknown) + << getOpenMPDirectiveName(ParentRegion); + return true; + } + return false; + } if (isOpenMPWorksharingDirective(CurrentRegion) && !isOpenMPParallelDirective(CurrentRegion) && !isOpenMPSimdDirective(CurrentRegion)) { @@ -1008,6 +1028,11 @@ StmtResult Sema::ActOnOpenMPExecutableDirective(OpenMPDirectiveKind Kind, Res = ActOnOpenMPSectionsDirective(ClausesWithImplicit, AStmt, StartLoc, EndLoc); break; + case OMPD_section: + assert(ClausesWithImplicit.empty() && + "No clauses is allowed for 'omp section' directive"); + Res = ActOnOpenMPSectionDirective(AStmt, StartLoc, EndLoc); + break; case OMPD_threadprivate: case OMPD_task: llvm_unreachable("OpenMP Directive is not allowed"); @@ -1592,7 +1617,15 @@ StmtResult Sema::ActOnOpenMPSectionsDirective(ArrayRef Clauses, return StmtError(); // All associated statements must be '#pragma omp section' except for // the first one. - // TODO + for (++S; S; ++S) { + auto SectionStmt = *S; + if (!SectionStmt || !isa(SectionStmt)) { + if (SectionStmt) + Diag(SectionStmt->getLocStart(), + diag::err_omp_sections_substmt_not_section); + return StmtError(); + } + } } else { Diag(AStmt->getLocStart(), diag::err_omp_sections_not_compound_stmt); return StmtError(); @@ -1604,6 +1637,16 @@ StmtResult Sema::ActOnOpenMPSectionsDirective(ArrayRef Clauses, AStmt); } +StmtResult Sema::ActOnOpenMPSectionDirective(Stmt *AStmt, + SourceLocation StartLoc, + SourceLocation EndLoc) { + assert(AStmt && isa(AStmt) && "Captured statement expected"); + + getCurFunction()->setHasBranchProtectedScope(); + + return OMPSectionDirective::Create(Context, StartLoc, EndLoc, AStmt); +} + OMPClause *Sema::ActOnOpenMPSingleExprClause(OpenMPClauseKind Kind, Expr *Expr, SourceLocation StartLoc, SourceLocation LParenLoc, diff --git a/lib/Sema/TreeTransform.h b/lib/Sema/TreeTransform.h index 2e595ea657..59208737b7 100644 --- a/lib/Sema/TreeTransform.h +++ b/lib/Sema/TreeTransform.h @@ -6439,6 +6439,16 @@ TreeTransform::TransformOMPSectionsDirective(OMPSectionsDirective *D) { return Res; } +template +StmtResult +TreeTransform::TransformOMPSectionDirective(OMPSectionDirective *D) { + DeclarationNameInfo DirName; + getDerived().getSema().StartOpenMPDSABlock(OMPD_section, DirName, nullptr); + StmtResult Res = getDerived().TransformOMPExecutableDirective(D); + getDerived().getSema().EndOpenMPDSABlock(Res.get()); + return Res; +} + //===----------------------------------------------------------------------===// // OpenMP clause transformation //===----------------------------------------------------------------------===// diff --git a/lib/Serialization/ASTReaderStmt.cpp b/lib/Serialization/ASTReaderStmt.cpp index ef057f870f..6649b6f05e 100644 --- a/lib/Serialization/ASTReaderStmt.cpp +++ b/lib/Serialization/ASTReaderStmt.cpp @@ -1913,6 +1913,11 @@ void ASTStmtReader::VisitOMPSectionsDirective(OMPSectionsDirective *D) { VisitOMPExecutableDirective(D); } +void ASTStmtReader::VisitOMPSectionDirective(OMPSectionDirective *D) { + VisitStmt(D); + VisitOMPExecutableDirective(D); +} + //===----------------------------------------------------------------------===// // ASTReader Implementation //===----------------------------------------------------------------------===// @@ -2413,6 +2418,10 @@ Stmt *ASTReader::ReadStmtFromStream(ModuleFile &F) { Context, Record[ASTStmtReader::NumStmtFields], Empty); break; + case STMT_OMP_SECTION_DIRECTIVE: + S = OMPSectionDirective::CreateEmpty(Context, Empty); + break; + case EXPR_CXX_OPERATOR_CALL: S = new (Context) CXXOperatorCallExpr(Context, Empty); break; diff --git a/lib/Serialization/ASTWriterStmt.cpp b/lib/Serialization/ASTWriterStmt.cpp index c0566679a5..10a55b2889 100644 --- a/lib/Serialization/ASTWriterStmt.cpp +++ b/lib/Serialization/ASTWriterStmt.cpp @@ -1825,6 +1825,12 @@ void ASTStmtWriter::VisitOMPSectionsDirective(OMPSectionsDirective *D) { Code = serialization::STMT_OMP_SECTIONS_DIRECTIVE; } +void ASTStmtWriter::VisitOMPSectionDirective(OMPSectionDirective *D) { + VisitStmt(D); + VisitOMPExecutableDirective(D); + Code = serialization::STMT_OMP_SECTION_DIRECTIVE; +} + //===----------------------------------------------------------------------===// // ASTWriter Implementation //===----------------------------------------------------------------------===// diff --git a/lib/StaticAnalyzer/Core/ExprEngine.cpp b/lib/StaticAnalyzer/Core/ExprEngine.cpp index 45250f32b9..244862d0de 100644 --- a/lib/StaticAnalyzer/Core/ExprEngine.cpp +++ b/lib/StaticAnalyzer/Core/ExprEngine.cpp @@ -734,6 +734,7 @@ void ExprEngine::Visit(const Stmt *S, ExplodedNode *Pred, case Stmt::OMPSimdDirectiveClass: case Stmt::OMPForDirectiveClass: case Stmt::OMPSectionsDirectiveClass: + case Stmt::OMPSectionDirectiveClass: llvm_unreachable("Stmt should not be in analyzer evaluation loop"); case Stmt::ObjCSubscriptRefExprClass: diff --git a/test/OpenMP/nesting_of_regions.cpp b/test/OpenMP/nesting_of_regions.cpp index dc8a00257a..9d0ee29ec3 100644 --- a/test/OpenMP/nesting_of_regions.cpp +++ b/test/OpenMP/nesting_of_regions.cpp @@ -6,29 +6,39 @@ template void foo() { #pragma omp parallel #pragma omp for - for (int i = 0; i < 10; ++i); + for (int i = 0; i < 10; ++i) + ; #pragma omp parallel #pragma omp simd - for (int i = 0; i < 10; ++i); + for (int i = 0; i < 10; ++i) + ; #pragma omp parallel #pragma omp sections { bar(); } +#pragma omp parallel +#pragma omp section // expected-error {{'omp section' directive must be closely nested to a sections region, not a parallel region}} + { + bar(); + } #pragma omp simd for (int i = 0; i < 10; ++i) { #pragma omp for // expected-error {{OpenMP constructs may not be nested inside a simd region}} - for (int i = 0; i < 10; ++i); + for (int i = 0; i < 10; ++i) + ; } #pragma omp simd for (int i = 0; i < 10; ++i) { #pragma omp simd // expected-error {{OpenMP constructs may not be nested inside a simd region}} - for (int i = 0; i < 10; ++i); + for (int i = 0; i < 10; ++i) + ; } #pragma omp simd for (int i = 0; i < 10; ++i) { #pragma omp parallel // expected-error {{OpenMP constructs may not be nested inside a simd region}} - for (int i = 0; i < 10; ++i); + for (int i = 0; i < 10; ++i) + ; } #pragma omp simd for (int i = 0; i < 10; ++i) { @@ -37,20 +47,30 @@ void foo() { bar(); } } +#pragma omp simd + for (int i = 0; i < 10; ++i) { +#pragma omp section // expected-error {{OpenMP constructs may not be nested inside a simd region}} + { + bar(); + } + } #pragma omp for for (int i = 0; i < 10; ++i) { #pragma omp for // expected-error {{region cannot be closely nested inside 'for' region; perhaps you forget to enclose 'omp for' directive into a parallel region?}} - for (int i = 0; i < 10; ++i); + for (int i = 0; i < 10; ++i) + ; } #pragma omp for for (int i = 0; i < 10; ++i) { #pragma omp simd - for (int i = 0; i < 10; ++i); + for (int i = 0; i < 10; ++i) + ; } #pragma omp for for (int i = 0; i < 10; ++i) { #pragma omp parallel - for (int i = 0; i < 10; ++i); + for (int i = 0; i < 10; ++i) + ; } #pragma omp for for (int i = 0; i < 10; ++i) { @@ -59,20 +79,30 @@ void foo() { bar(); } } +#pragma omp for + for (int i = 0; i < 10; ++i) { +#pragma omp section // expected-error {{'omp section' directive must be closely nested to a sections region, not a for region}} + { + bar(); + } + } #pragma omp sections { #pragma omp for // expected-error {{region cannot be closely nested inside 'sections' region; perhaps you forget to enclose 'omp for' directive into a parallel region?}} - for (int i = 0; i < 10; ++i); + for (int i = 0; i < 10; ++i) + ; } #pragma omp sections { #pragma omp simd - for (int i = 0; i < 10; ++i); + for (int i = 0; i < 10; ++i) + ; } #pragma omp sections { #pragma omp parallel - for (int i = 0; i < 10; ++i); + for (int i = 0; i < 10; ++i) + ; } #pragma omp sections { @@ -81,34 +111,55 @@ void foo() { bar(); } } +#pragma omp sections + { +#pragma omp section + { + bar(); + } + } +#pragma omp section // expected-error {{orphaned 'omp section' directives are prohibited, it must be closely nested to a sections region}} + { + bar(); + } } void foo() { #pragma omp parallel #pragma omp for - for (int i = 0; i < 10; ++i); + for (int i = 0; i < 10; ++i) + ; #pragma omp parallel #pragma omp simd - for (int i = 0; i < 10; ++i); + for (int i = 0; i < 10; ++i) + ; #pragma omp parallel #pragma omp sections { bar(); } +#pragma omp parallel +#pragma omp section // expected-error {{'omp section' directive must be closely nested to a sections region, not a parallel region}} + { + bar(); + } #pragma omp simd for (int i = 0; i < 10; ++i) { #pragma omp for // expected-error {{OpenMP constructs may not be nested inside a simd region}} - for (int i = 0; i < 10; ++i); + for (int i = 0; i < 10; ++i) + ; } #pragma omp simd for (int i = 0; i < 10; ++i) { #pragma omp simd // expected-error {{OpenMP constructs may not be nested inside a simd region}} - for (int i = 0; i < 10; ++i); + for (int i = 0; i < 10; ++i) + ; } #pragma omp simd for (int i = 0; i < 10; ++i) { #pragma omp parallel // expected-error {{OpenMP constructs may not be nested inside a simd region}} - for (int i = 0; i < 10; ++i); + for (int i = 0; i < 10; ++i) + ; } #pragma omp simd for (int i = 0; i < 10; ++i) { @@ -117,20 +168,30 @@ void foo() { bar(); } } +#pragma omp simd + for (int i = 0; i < 10; ++i) { +#pragma omp section // expected-error {{OpenMP constructs may not be nested inside a simd region}} + { + bar(); + } + } #pragma omp for for (int i = 0; i < 10; ++i) { #pragma omp for // expected-error {{region cannot be closely nested inside 'for' region; perhaps you forget to enclose 'omp for' directive into a parallel region?}} - for (int i = 0; i < 10; ++i); + for (int i = 0; i < 10; ++i) + ; } #pragma omp for for (int i = 0; i < 10; ++i) { #pragma omp simd - for (int i = 0; i < 10; ++i); + for (int i = 0; i < 10; ++i) + ; } #pragma omp for for (int i = 0; i < 10; ++i) { #pragma omp parallel - for (int i = 0; i < 10; ++i); + for (int i = 0; i < 10; ++i) + ; } #pragma omp for for (int i = 0; i < 10; ++i) { @@ -139,20 +200,30 @@ void foo() { bar(); } } +#pragma omp for + for (int i = 0; i < 10; ++i) { +#pragma omp section // expected-error {{'omp section' directive must be closely nested to a sections region, not a for region}} + { + bar(); + } + } #pragma omp sections { #pragma omp for // expected-error {{region cannot be closely nested inside 'sections' region; perhaps you forget to enclose 'omp for' directive into a parallel region?}} - for (int i = 0; i < 10; ++i); + for (int i = 0; i < 10; ++i) + ; } #pragma omp sections { #pragma omp simd - for (int i = 0; i < 10; ++i); + for (int i = 0; i < 10; ++i) + ; } #pragma omp sections { #pragma omp parallel - for (int i = 0; i < 10; ++i); + for (int i = 0; i < 10; ++i) + ; } #pragma omp sections { @@ -161,6 +232,17 @@ void foo() { bar(); } } +#pragma omp sections + { +#pragma omp section + { + bar(); + } + } +#pragma omp section // expected-error {{orphaned 'omp section' directives are prohibited, it must be closely nested to a sections region}} + { + bar(); + } return foo(); } diff --git a/test/OpenMP/sections_ast_print.cpp b/test/OpenMP/sections_ast_print.cpp index 56c1c3c988..b1a2e03040 100644 --- a/test/OpenMP/sections_ast_print.cpp +++ b/test/OpenMP/sections_ast_print.cpp @@ -14,9 +14,9 @@ T tmain(T argc) { static T a; // CHECK: static T a; #pragma omp parallel -#pragma omp sections private(argc, b), firstprivate(c, d), lastprivate(d, f) reduction (-: g) nowait +#pragma omp sections private(argc, b), firstprivate(c, d), lastprivate(d, f) reduction(- : g) nowait { - foo(); + foo(); } // CHECK-NEXT: #pragma omp parallel // CHECK-NEXT: #pragma omp sections private(argc,b) firstprivate(c,d) lastprivate(d,f) reduction(-: g) nowait @@ -31,13 +31,19 @@ int main(int argc, char **argv) { static int a; // CHECK: static int a; #pragma omp parallel -#pragma omp sections private(argc, b), firstprivate(argv, c), lastprivate(d, f) reduction(+:g) nowait +#pragma omp sections private(argc, b), firstprivate(argv, c), lastprivate(d, f) reduction(+ : g) nowait { - foo(); +#pragma omp section + foo(); +#pragma omp section + foo(); } // CHECK-NEXT: #pragma omp parallel // CHECK-NEXT: #pragma omp sections private(argc,b) firstprivate(argv,c) lastprivate(d,f) reduction(+: g) nowait // CHECK-NEXT: { + // CHECK-NEXT: #pragma omp section + // CHECK-NEXT: foo(); + // CHECK-NEXT: #pragma omp section // CHECK-NEXT: foo(); // CHECK-NEXT: } return (tmain(argc) + tmain(argv[0][0])); diff --git a/test/OpenMP/sections_misc_messages.c b/test/OpenMP/sections_misc_messages.c index e8aa5e28c0..977d154156 100644 --- a/test/OpenMP/sections_misc_messages.c +++ b/test/OpenMP/sections_misc_messages.c @@ -18,6 +18,13 @@ void test_no_clause() { // expected-error@+2 {{the statement for '#pragma omp sections' must be a compound statement}} #pragma omp sections ++i; + +#pragma omp sections + { + foo(); + foo(); // expected-error {{statement in 'omp sections' directive must be enclosed into a section region}} + } + } void test_branch_protected_scope() { @@ -40,12 +47,24 @@ L1: L2: x[i]++; } +#pragma omp section + 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 L3; + else if (i == 8) { + L3: + x[i]++; + } } if (x[0] == 0) goto L2; // expected-error {{use of undeclared label 'L2'}} else if (x[1] == 1) goto L1; + goto L3; // expected-error {{use of undeclared label 'L3'}} } void test_invalid_clause() { @@ -55,6 +74,9 @@ void test_invalid_clause() { #pragma omp sections foo bar { foo(); +// expected-error@+1 {{unexpected OpenMP clause 'nowait' in directive '#pragma omp section'}} +#pragma omp section nowait + ; } } diff --git a/tools/libclang/CIndex.cpp b/tools/libclang/CIndex.cpp index ab0cd6fdda..2b7c8f50bb 100644 --- a/tools/libclang/CIndex.cpp +++ b/tools/libclang/CIndex.cpp @@ -1853,6 +1853,7 @@ public: void VisitOMPSimdDirective(const OMPSimdDirective *D); void VisitOMPForDirective(const OMPForDirective *D); void VisitOMPSectionsDirective(const OMPSectionsDirective *D); + void VisitOMPSectionDirective(const OMPSectionDirective *D); private: void AddDeclarationNameInfo(const Stmt *S); @@ -2292,6 +2293,10 @@ void EnqueueVisitor::VisitOMPSectionsDirective(const OMPSectionsDirective *D) { VisitOMPExecutableDirective(D); } +void EnqueueVisitor::VisitOMPSectionDirective(const OMPSectionDirective *D) { + VisitOMPExecutableDirective(D); +} + void CursorVisitor::EnqueueWorkList(VisitorWorkList &WL, const Stmt *S) { EnqueueVisitor(WL, MakeCXCursor(S, StmtParent, TU,RegionOfInterest)).Visit(S); } @@ -3972,6 +3977,8 @@ CXString clang_getCursorKindSpelling(enum CXCursorKind Kind) { return cxstring::createRef("OMPForDirective"); case CXCursor_OMPSectionsDirective: return cxstring::createRef("OMPSectionsDirective"); + case CXCursor_OMPSectionDirective: + return cxstring::createRef("OMPSectionDirective"); } llvm_unreachable("Unhandled CXCursorKind"); diff --git a/tools/libclang/CXCursor.cpp b/tools/libclang/CXCursor.cpp index ad8c7df70b..8a5077c12a 100644 --- a/tools/libclang/CXCursor.cpp +++ b/tools/libclang/CXCursor.cpp @@ -525,6 +525,9 @@ CXCursor cxcursor::MakeCXCursor(const Stmt *S, const Decl *Parent, case Stmt::OMPSectionsDirectiveClass: K = CXCursor_OMPSectionsDirective; break; + case Stmt::OMPSectionDirectiveClass: + K = CXCursor_OMPSectionDirective; + break; } CXCursor C = { K, 0, { Parent, S, TU } }; -- cgit v1.2.3