[OPENMP] Initial parsing and sema analysis for 'section' directive.

llvm-svn: 211767

clang/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.

clang/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 <typename Derived>
 bool RecursiveASTVisitor<Derived>::TraverseOMPClause(OMPClause *C) {

clang/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 <typename Derived>
 bool RecursiveASTVisitor<Derived>::TraverseOMPClause(OMPClause *C) {

clang/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

clang/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 {

clang/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)

clang/include/clang/Basic/StmtNodes.td

@@ -181,3 +181,4 @@ def OMPParallelDirective : DStmt<OMPExecutableDirective>;
 def OMPSimdDirective : DStmt<OMPExecutableDirective>;
 def OMPForDirective : DStmt<OMPExecutableDirective>;
 def OMPSectionsDirective : DStmt<OMPExecutableDirective>;
+def OMPSectionDirective : DStmt<OMPExecutableDirective>;

clang/include/clang/Sema/Sema.h

@@ -7327,6 +7327,10 @@ public:
   StmtResult ActOnOpenMPSectionsDirective(ArrayRef<OMPClause *> 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,

clang/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

clang/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<Stmt *>());
+  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<Stmt *>());
+  void *Mem = C.Allocate(Size + sizeof(Stmt *));
+  return new (Mem) OMPSectionDirective();
+}
+

clang/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.
 //===----------------------------------------------------------------------===//

clang/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);
 }

clang/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) {

clang/lib/CodeGen/CGStmt.cpp

@@ -185,6 +185,9 @@ void CodeGenFunction::EmitStmt(const Stmt *S) {
   case Stmt::OMPSectionsDirectiveClass:
     EmitOMPSectionsDirective(cast<OMPSectionsDirective>(*S));
     break;
+  case Stmt::OMPSectionDirectiveClass:
+    EmitOMPSectionDirective(cast<OMPSectionDirective>(*S));
+    break;
   }
 }
 

clang/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.");
+}
+

clang/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

clang/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))

clang/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<OMPClause *> 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<OMPSectionDirective>(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<OMPClause *> Clauses,
                                       AStmt);
 }
 
+StmtResult Sema::ActOnOpenMPSectionDirective(Stmt *AStmt,
+                                             SourceLocation StartLoc,
+                                             SourceLocation EndLoc) {
+  assert(AStmt && isa<CapturedStmt>(AStmt) && "Captured statement expected");
+
+  getCurFunction()->setHasBranchProtectedScope();
+
+  return OMPSectionDirective::Create(Context, StartLoc, EndLoc, AStmt);
+}
+
 OMPClause *Sema::ActOnOpenMPSingleExprClause(OpenMPClauseKind Kind, Expr *Expr,
                                              SourceLocation StartLoc,
                                              SourceLocation LParenLoc,

clang/lib/Sema/TreeTransform.h

@@ -6439,6 +6439,16 @@ TreeTransform<Derived>::TransformOMPSectionsDirective(OMPSectionsDirective *D) {
   return Res;
 }
 
+template <typename Derived>
+StmtResult
+TreeTransform<Derived>::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
 //===----------------------------------------------------------------------===//

clang/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;

clang/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
 //===----------------------------------------------------------------------===//

clang/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:

clang/test/OpenMP/nesting_of_regions.cpp

@@ -6,29 +6,39 @@ template <class T>
 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<int>();
 }
 

clang/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<int, 5>(argc) + tmain<char, 1>(argv[0][0]));

clang/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
+    ;
   }
 }
 

clang/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");

clang/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 } };