[OpenMP 5.1] Parsing and Sema support for `scope` construct

[mdfazlay]

Summary

#pragma omp scope [clause[ [,] clause] ... ]
structured-block

where clause is one of the following:

private(list)
reduction([reduction-modifier ,] reduction-identifier : list)
nowait

Reference:
(1) OpenMP 5.1 Specification - Section 2.9 (Page 106)

[ABataev]

Need to add the tests (and the checks, if required) for the nesting of the regions

[mdfazlay]

In D157933#4586816, @ABataev wrote:

Need to add the tests (and the checks, if required) for the nesting of the regions

I think I have the nesting of regions checks in scope_messages.cpp. Do you prefer to have those checks in nesting_of_regions.cpp file?

[ABataev]

In D157933#4587164, @mdfazlay wrote:

In D157933#4586816, @ABataev wrote:

Need to add the tests (and the checks, if required) for the nesting of the regions

I think I have the nesting of regions checks in scope_messages.cpp. Do you prefer to have those checks in nesting_of_regions.cpp file?

Yes, extend this one

[mdfazlay]

Updated nesting of regions checks.

[ABataev]

Could you also add the nesting tests for outer scope directive? Currently it tests only for inner

[mdfazlay]

In D157933#4591627, @ABataev wrote:

Could you also add the nesting tests for outer scope directive? Currently it tests only for inner

Added. Please take a look.

[ABataev]

LG. Please, update docs/OpenMPSupport.rst

[mdfazlay]

Updated docs/OpenMPSupport.rst

clang/docs/OpenMPSupport.rst

 | memory management            | changes to omp_alloctrait_key enum                           | :none:`unclaimed`        |                                                                       |
 +------------------------------+--------------------------------------------------------------+--------------------------+-----------------------------------------------------------------------+
 | memory model                 | seq_cst clause on flush construct                            | :none:`unclaimed`        |                                                                       |
 +------------------------------+--------------------------------------------------------------+--------------------------+-----------------------------------------------------------------------+
 | misc                         | 'omp_all_memory' keyword and use in 'depend' clause          | :good:`done`             | D125828, D126321                                                      |
 +------------------------------+--------------------------------------------------------------+--------------------------+-----------------------------------------------------------------------+
 | misc                         | error directive                                              | :none:`unclaimed`        |                                                                       |
 +------------------------------+--------------------------------------------------------------+--------------------------+-----------------------------------------------------------------------+
-| misc                         | scope construct                                              | :none:`unclaimed`        |                                                                       |
+| misc                         | scope construct                                              | :none:`worked on`        | D157933                                                               |
 +------------------------------+--------------------------------------------------------------+--------------------------+-----------------------------------------------------------------------+
 | misc                         | routines for controlling and querying team regions           | :none:`unclaimed`        |                                                                       |
 +------------------------------+--------------------------------------------------------------+--------------------------+-----------------------------------------------------------------------+
 | misc                         | changes to ompt_scope_endpoint_t enum                        | :none:`unclaimed`        |                                                                       |
 +------------------------------+--------------------------------------------------------------+--------------------------+-----------------------------------------------------------------------+
 | misc                         | omp_display_env routine                                      | :none:`unclaimed`        |                                                                       |
 +------------------------------+--------------------------------------------------------------+--------------------------+-----------------------------------------------------------------------+
 | misc                         | extended OMP_PLACES syntax                                   | :none:`unclaimed`        |                                                                       |

clang/include/clang-c/Index.h

enum CXCursorKind {
   /** OpenMP parallel masked taskloop simd directive.
    */
   CXCursor_OMPParallelMaskedTaskLoopSimdDirective = 304,
 
   /** OpenMP error directive.
    */
   CXCursor_OMPErrorDirective = 305,
 
-  CXCursor_LastStmt = CXCursor_OMPErrorDirective,
+  /** OpenMP scope directive.
+   */
+  CXCursor_OMPScopeDirective = 306,
+
+  CXCursor_LastStmt = CXCursor_OMPScopeDirective,
 
   /**
    * Cursor that represents the translation unit itself.
    *
    * The translation unit cursor exists primarily to act as the root
    * cursor for traversing the contents of a translation unit.
    */
   CXCursor_TranslationUnit = 350,

clang/include/clang/AST/RecursiveASTVisitor.h

DEF_TRAVERSE_STMT(OMPForSimdDirective,
                   { TRY_TO(TraverseOMPExecutableDirective(S)); })
 
 DEF_TRAVERSE_STMT(OMPSectionsDirective,
                   { TRY_TO(TraverseOMPExecutableDirective(S)); })
 
 DEF_TRAVERSE_STMT(OMPSectionDirective,
                   { TRY_TO(TraverseOMPExecutableDirective(S)); })
 
+DEF_TRAVERSE_STMT(OMPScopeDirective,
+                  { TRY_TO(TraverseOMPExecutableDirective(S)); })
+
 DEF_TRAVERSE_STMT(OMPSingleDirective,
                   { TRY_TO(TraverseOMPExecutableDirective(S)); })
 
 DEF_TRAVERSE_STMT(OMPMasterDirective,
                   { TRY_TO(TraverseOMPExecutableDirective(S)); })
 
 DEF_TRAVERSE_STMT(OMPCriticalDirective, {
   TRY_TO(TraverseDeclarationNameInfo(S->getDirectiveName()));

clang/include/clang/AST/StmtOpenMP.h

public:
   /// Return true if current directive has inner cancel directive.
   bool hasCancel() const { return HasCancel; }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == OMPSectionDirectiveClass;
   }
 };
 
+/// This represents '#pragma omp scope' directive.
+/// \code
+/// #pragma omp scope private(a,b) nowait
+/// \endcode
+/// In this example directive '#pragma omp scope' has clauses 'private' with
+/// the variables 'a' and 'b' and nowait.
+///
+class OMPScopeDirective final : public OMPExecutableDirective {
+  friend class ASTStmtReader;
+  friend class OMPExecutableDirective;
+
+  /// Build directive with the given start and end location.
+  ///
+  /// \param StartLoc Starting location of the directive kind.
+  /// \param EndLoc Ending location of the directive.
+  ///
+  OMPScopeDirective(SourceLocation StartLoc, SourceLocation EndLoc)
+      : OMPExecutableDirective(OMPScopeDirectiveClass, llvm::omp::OMPD_scope,
+                               StartLoc, EndLoc) {}
+
+  /// Build an empty directive.
+  ///
+  explicit OMPScopeDirective()
+      : OMPExecutableDirective(OMPScopeDirectiveClass, llvm::omp::OMPD_scope,
+                               SourceLocation(), SourceLocation()) {}
+
+public:
+  /// 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 OMPScopeDirective *Create(const ASTContext &C, SourceLocation StartLoc,
+                                   SourceLocation EndLoc,
+                                   ArrayRef<OMPClause *> Clauses,
+                                   Stmt *AssociatedStmt);
+
+  /// Creates an empty directive.
+  ///
+  /// \param C AST context.
+  ///
+  static OMPScopeDirective *CreateEmpty(const ASTContext &C,
+                                        unsigned NumClauses, EmptyShell);
+
+  static bool classof(const Stmt *T) {
+    return T->getStmtClass() == OMPScopeDirectiveClass;
+  }
+};
+
 /// This represents '#pragma omp single' directive.
 ///
 /// \code
 /// #pragma omp single private(a,b) copyprivate(c,d)
 /// \endcode
 /// In this example directive '#pragma omp single' has clauses 'private' with
 /// the variables 'a' and 'b' and 'copyprivate' with variables 'c' and 'd'.
 ///

clang/include/clang/Basic/StmtNodes.td

 def OMPTargetEnterDataDirective : StmtNode<OMPExecutableDirective>;
 def OMPTargetExitDataDirective : StmtNode<OMPExecutableDirective>;
 def OMPTargetParallelDirective : StmtNode<OMPExecutableDirective>;
 def OMPTargetParallelForDirective : StmtNode<OMPExecutableDirective>;
 def OMPTargetUpdateDirective : StmtNode<OMPExecutableDirective>;
 def OMPTeamsDirective : StmtNode<OMPExecutableDirective>;
 def OMPCancellationPointDirective : StmtNode<OMPExecutableDirective>;
 def OMPCancelDirective : StmtNode<OMPExecutableDirective>;
+def OMPScopeDirective : StmtNode<OMPExecutableDirective>;
 def OMPTaskLoopDirective : StmtNode<OMPLoopDirective>;
 def OMPTaskLoopSimdDirective : StmtNode<OMPLoopDirective>;
 def OMPMasterTaskLoopDirective : StmtNode<OMPLoopDirective>;
 def OMPMasterTaskLoopSimdDirective : StmtNode<OMPLoopDirective>;
 def OMPParallelMasterTaskLoopDirective : StmtNode<OMPLoopDirective>;
 def OMPParallelMasterTaskLoopSimdDirective : StmtNode<OMPLoopDirective>;
 def OMPMaskedTaskLoopDirective : StmtNode<OMPLoopDirective>;
 def OMPMaskedTaskLoopSimdDirective : StmtNode<OMPLoopDirective>;

clang/include/clang/Sema/Sema.h

public:
   /// of the associated statement.
   StmtResult ActOnOpenMPSectionsDirective(ArrayRef<OMPClause *> Clauses,
                                           Stmt *AStmt, SourceLocation StartLoc,
                                           SourceLocation EndLoc);
   /// Called on well-formed '\#pragma omp section' after parsing of the
   /// associated statement.
   StmtResult ActOnOpenMPSectionDirective(Stmt *AStmt, SourceLocation StartLoc,
                                          SourceLocation EndLoc);
+  /// Called on well-formed '\#pragma omp scope' after parsing of the
+  /// associated statement.
+  StmtResult ActOnOpenMPScopeDirective(ArrayRef<OMPClause *> Clauses,
+                                       Stmt *AStmt, SourceLocation StartLoc,
+                                       SourceLocation EndLoc);
   /// Called on well-formed '\#pragma omp single' after parsing of the
   /// associated statement.
   StmtResult ActOnOpenMPSingleDirective(ArrayRef<OMPClause *> Clauses,
                                         Stmt *AStmt, SourceLocation StartLoc,
                                         SourceLocation EndLoc);
   /// Called on well-formed '\#pragma omp master' after parsing of the
   /// associated statement.
   StmtResult ActOnOpenMPMasterDirective(Stmt *AStmt, SourceLocation StartLoc,

clang/include/clang/Serialization/ASTBitCodes.h

enum StmtCode {
   STMT_OMP_TEAMS_DISTRIBUTE_SIMD_DIRECTIVE,
   STMT_OMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE,
   STMT_OMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE,
   STMT_OMP_TARGET_TEAMS_DIRECTIVE,
   STMT_OMP_TARGET_TEAMS_DISTRIBUTE_DIRECTIVE,
   STMT_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE,
   STMT_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE,
   STMT_OMP_TARGET_TEAMS_DISTRIBUTE_SIMD_DIRECTIVE,
+  STMT_OMP_SCOPE_DIRECTIVE,
   STMT_OMP_INTEROP_DIRECTIVE,
   STMT_OMP_DISPATCH_DIRECTIVE,
   STMT_OMP_MASKED_DIRECTIVE,
   STMT_OMP_GENERIC_LOOP_DIRECTIVE,
   STMT_OMP_TEAMS_GENERIC_LOOP_DIRECTIVE,
   STMT_OMP_TARGET_TEAMS_GENERIC_LOOP_DIRECTIVE,
   STMT_OMP_PARALLEL_GENERIC_LOOP_DIRECTIVE,
   STMT_OMP_TARGET_PARALLEL_GENERIC_LOOP_DIRECTIVE,

clang/lib/AST/StmtOpenMP.cpp

 }
 
 OMPSectionDirective *OMPSectionDirective::CreateEmpty(const ASTContext &C,
                                                       EmptyShell) {
   return createEmptyDirective<OMPSectionDirective>(C, /*NumClauses=*/0,
                                                    /*HasAssociatedStmt=*/true);
 }
 
+OMPScopeDirective *OMPScopeDirective::Create(const ASTContext &C,
+                                             SourceLocation StartLoc,
+                                             SourceLocation EndLoc,
+                                             ArrayRef<OMPClause *> Clauses,
+                                             Stmt *AssociatedStmt) {
+  return createDirective<OMPScopeDirective>(C, Clauses, AssociatedStmt,
+                                            /*NumChildren=*/0, StartLoc,
+                                            EndLoc);
+}
+
+OMPScopeDirective *OMPScopeDirective::CreateEmpty(const ASTContext &C,
+                                                  unsigned NumClauses,
+                                                  EmptyShell) {
+  return createEmptyDirective<OMPScopeDirective>(C, NumClauses,
+                                                 /*HasAssociatedStmt=*/true);
+}
+
 OMPSingleDirective *OMPSingleDirective::Create(const ASTContext &C,
                                                SourceLocation StartLoc,
                                                SourceLocation EndLoc,
                                                ArrayRef<OMPClause *> Clauses,
                                                Stmt *AssociatedStmt) {
   return createDirective<OMPSingleDirective>(C, Clauses, AssociatedStmt,
                                              /*NumChildren=*/0, StartLoc,
                                              EndLoc);

clang/lib/AST/StmtPrinter.cpp

void StmtPrinter::VisitOMPSectionsDirective(OMPSectionsDirective *Node) {
   PrintOMPExecutableDirective(Node);
 }
 
 void StmtPrinter::VisitOMPSectionDirective(OMPSectionDirective *Node) {
   Indent() << "#pragma omp section";
   PrintOMPExecutableDirective(Node);
 }
 
+void StmtPrinter::VisitOMPScopeDirective(OMPScopeDirective *Node) {
+  Indent() << "#pragma omp scope";
+  PrintOMPExecutableDirective(Node);
+}
+
 void StmtPrinter::VisitOMPSingleDirective(OMPSingleDirective *Node) {
   Indent() << "#pragma omp single";
   PrintOMPExecutableDirective(Node);
 }
 
 void StmtPrinter::VisitOMPMasterDirective(OMPMasterDirective *Node) {
   Indent() << "#pragma omp master";
   PrintOMPExecutableDirective(Node);

clang/lib/AST/StmtProfile.cpp

 void StmtProfiler::VisitOMPSectionsDirective(const OMPSectionsDirective *S) {
   VisitOMPExecutableDirective(S);
 }
 
 void StmtProfiler::VisitOMPSectionDirective(const OMPSectionDirective *S) {
   VisitOMPExecutableDirective(S);
 }
 
+void StmtProfiler::VisitOMPScopeDirective(const OMPScopeDirective *S) {
+  VisitOMPExecutableDirective(S);
+}
+
 void StmtProfiler::VisitOMPSingleDirective(const OMPSingleDirective *S) {
   VisitOMPExecutableDirective(S);
 }
 
 void StmtProfiler::VisitOMPMasterDirective(const OMPMasterDirective *S) {
   VisitOMPExecutableDirective(S);
 }
 

clang/lib/Basic/OpenMPKinds.cpp

void clang::getOpenMPCaptureRegions(
   case OMPD_master:
   case OMPD_critical:
   case OMPD_taskgroup:
   case OMPD_distribute:
   case OMPD_ordered:
   case OMPD_atomic:
   case OMPD_target_data:
   case OMPD_distribute_simd:
+  case OMPD_scope:
   case OMPD_dispatch:
     CaptureRegions.push_back(OMPD_unknown);
     break;
   case OMPD_tile:
   case OMPD_unroll:
     // loop transformations do not introduce captures.
     break;
   case OMPD_threadprivate:

clang/lib/CodeGen/CGStmt.cpp

EmitOMPTargetTeamsDistributeSimdDirective(
         cast<OMPTargetTeamsDistributeSimdDirective>(*S));
     break;
   case Stmt::OMPInteropDirectiveClass:
     EmitOMPInteropDirective(cast<OMPInteropDirective>(*S));
     break;
   case Stmt::OMPDispatchDirectiveClass:
     llvm_unreachable("Dispatch directive not supported yet.");
     break;
+  case Stmt::OMPScopeDirectiveClass:
+    llvm_unreachable("scope not supported with FE outlining");
   case Stmt::OMPMaskedDirectiveClass:
     EmitOMPMaskedDirective(cast<OMPMaskedDirective>(*S));
     break;
   case Stmt::OMPGenericLoopDirectiveClass:
     EmitOMPGenericLoopDirective(cast<OMPGenericLoopDirective>(*S));
     break;
   case Stmt::OMPTeamsGenericLoopDirectiveClass:
     EmitOMPTeamsGenericLoopDirective(cast<OMPTeamsGenericLoopDirective>(*S));

clang/lib/Parse/ParseOpenMP.cpp

Parser::DeclGroupPtrTy Parser::ParseOpenMPDeclarativeDirectiveWithExtDecl(
   case OMPD_parallel_masked_taskloop_simd:
   case OMPD_distribute:
   case OMPD_target_update:
   case OMPD_distribute_parallel_for:
   case OMPD_distribute_parallel_for_simd:
   case OMPD_distribute_simd:
   case OMPD_target_parallel_for_simd:
   case OMPD_target_simd:
+  case OMPD_scope:
   case OMPD_teams_distribute:
   case OMPD_teams_distribute_simd:
   case OMPD_teams_distribute_parallel_for_simd:
   case OMPD_teams_distribute_parallel_for:
   case OMPD_target_teams:
   case OMPD_target_teams_distribute:
   case OMPD_target_teams_distribute_parallel_for:
   case OMPD_target_teams_distribute_parallel_for_simd:
StmtResult Parser::ParseOpenMPDeclarativeOrExecutableDirective(
   case OMPD_target_data:
   case OMPD_target_parallel:
   case OMPD_target_parallel_for:
   case OMPD_loop:
   case OMPD_teams_loop:
   case OMPD_target_teams_loop:
   case OMPD_parallel_loop:
   case OMPD_target_parallel_loop:
+  case OMPD_scope:
   case OMPD_taskloop:
   case OMPD_taskloop_simd:
   case OMPD_master_taskloop:
   case OMPD_masked_taskloop:
   case OMPD_master_taskloop_simd:
   case OMPD_masked_taskloop_simd:
   case OMPD_parallel_master_taskloop:
   case OMPD_parallel_masked_taskloop:

clang/lib/Sema/SemaExceptionSpec.cpp

CanThrowResult Sema::canThrow(const Stmt *S) {
   case Stmt::OMPTargetParallelForSimdDirectiveClass:
   case Stmt::OMPTargetSimdDirectiveClass:
   case Stmt::OMPTargetTeamsDirectiveClass:
   case Stmt::OMPTargetTeamsDistributeDirectiveClass:
   case Stmt::OMPTargetTeamsDistributeParallelForDirectiveClass:
   case Stmt::OMPTargetTeamsDistributeParallelForSimdDirectiveClass:
   case Stmt::OMPTargetTeamsDistributeSimdDirectiveClass:
   case Stmt::OMPTargetUpdateDirectiveClass:
+  case Stmt::OMPScopeDirectiveClass:
   case Stmt::OMPTaskDirectiveClass:
   case Stmt::OMPTaskgroupDirectiveClass:
   case Stmt::OMPTaskLoopDirectiveClass:
   case Stmt::OMPTaskLoopSimdDirectiveClass:
   case Stmt::OMPTaskwaitDirectiveClass:
   case Stmt::OMPTaskyieldDirectiveClass:
   case Stmt::OMPErrorDirectiveClass:
   case Stmt::OMPTeamsDirectiveClass:

clang/lib/Sema/SemaOpenMP.cpp

void VisitSubCaptures(OMPExecutableDirective *S) {
     // Check implicitly captured variables.
     if (!S->hasAssociatedStmt() || !S->getAssociatedStmt())
       return;
     if (S->getDirectiveKind() == OMPD_atomic ||
         S->getDirectiveKind() == OMPD_critical ||
         S->getDirectiveKind() == OMPD_section ||
         S->getDirectiveKind() == OMPD_master ||
         S->getDirectiveKind() == OMPD_masked ||
+        S->getDirectiveKind() == OMPD_scope ||
         isOpenMPLoopTransformationDirective(S->getDirectiveKind())) {
       Visit(S->getAssociatedStmt());
       return;
     }
     visitSubCaptures(S->getInnermostCapturedStmt());
     // Try to capture inner this->member references to generate correct mappings
     // and diagnostics.
     if (TryCaptureCXXThisMembers ||
void Sema::ActOnOpenMPRegionStart(OpenMPDirectiveKind DKind, Scope *CurScope) {
   case OMPD_for:
   case OMPD_for_simd:
   case OMPD_sections:
   case OMPD_single:
   case OMPD_taskgroup:
   case OMPD_distribute:
   case OMPD_distribute_simd:
   case OMPD_ordered:
+  case OMPD_scope:
   case OMPD_target_data:
   case OMPD_dispatch: {
     Sema::CapturedParamNameType Params[] = {
         std::make_pair(StringRef(), QualType()) // __context with shared vars
     };
     ActOnCapturedRegionStart(DSAStack->getConstructLoc(), CurScope, CR_OpenMP,
                              Params);
     break;
if (CurrentRegion == OMPD_cancellation_point ||
         SemaRef.Diag(StartLoc,
                      diag::err_omp_prohibited_region_critical_same_name)
             << CurrentName.getName();
         if (PreviousCriticalLoc.isValid())
           SemaRef.Diag(PreviousCriticalLoc,
                        diag::note_omp_previous_critical_region);
         return true;
       }
-    } else if (CurrentRegion == OMPD_barrier) {
+    } else if (CurrentRegion == OMPD_barrier || CurrentRegion == OMPD_scope) {
+      // OpenMP 5.1 [2.22, Nesting of Regions]
+      // A scope region may not be closely nested inside a worksharing, loop,
+      // task, taskloop, critical, ordered, atomic, or masked region.
       // OpenMP 5.1 [2.22, Nesting of Regions]
       // A barrier region may not be closely nested inside a worksharing, loop,
       // task, taskloop, critical, ordered, atomic, or masked region.
       NestingProhibited =
           isOpenMPWorksharingDirective(ParentRegion) ||
           isOpenMPGenericLoopDirective(ParentRegion) ||
           isOpenMPTaskingDirective(ParentRegion) ||
           ParentRegion == OMPD_master || ParentRegion == OMPD_masked ||
case OMPD_parallel_for:
     break;
   case OMPD_parallel_for_simd:
     Res = ActOnOpenMPParallelForSimdDirective(
         ClausesWithImplicit, AStmt, StartLoc, EndLoc, VarsWithInheritedDSA);
     AllowedNameModifiers.push_back(OMPD_parallel);
     if (LangOpts.OpenMP >= 50)
       AllowedNameModifiers.push_back(OMPD_simd);
     break;
+  case OMPD_scope:
+    Res =
+        ActOnOpenMPScopeDirective(ClausesWithImplicit, AStmt, StartLoc, EndLoc);
+    break;
   case OMPD_parallel_master:
     Res = ActOnOpenMPParallelMasterDirective(ClausesWithImplicit, AStmt,
                                              StartLoc, EndLoc);
     AllowedNameModifiers.push_back(OMPD_parallel);
     break;
   case OMPD_parallel_masked:
     Res = ActOnOpenMPParallelMaskedDirective(ClausesWithImplicit, AStmt,
                                              StartLoc, EndLoc);
OMPClause *Sema::ActOnOpenMPNontemporalClause(ArrayRef<Expr *> VarList,
 
   if (Vars.empty())
     return nullptr;
 
   return OMPNontemporalClause::Create(Context, StartLoc, LParenLoc, EndLoc,
                                       Vars);
 }
 
+StmtResult Sema::ActOnOpenMPScopeDirective(ArrayRef<OMPClause *> Clauses,
+                                           Stmt *AStmt, SourceLocation StartLoc,
+                                           SourceLocation EndLoc) {
+  if (!AStmt)
+    return StmtError();
+
+  setFunctionHasBranchProtectedScope();
+
+  return OMPScopeDirective::Create(Context, StartLoc, EndLoc, Clauses, AStmt);
+}
+
 OMPClause *Sema::ActOnOpenMPInclusiveClause(ArrayRef<Expr *> VarList,
                                             SourceLocation StartLoc,
                                             SourceLocation LParenLoc,
                                             SourceLocation EndLoc) {
   SmallVector<Expr *, 8> Vars;
   for (Expr *RefExpr : VarList) {
     assert(RefExpr && "NULL expr in OpenMP nontemporal clause.");
     SourceLocation ELoc;

clang/lib/Sema/TreeTransform.h

getDerived().getSema().StartOpenMPDSABlock(OMPD_section, DirName, nullptr,
                                              D->getBeginLoc());
   StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
   getDerived().getSema().EndOpenMPDSABlock(Res.get());
   return Res;
 }
 
 template <typename Derived>
 StmtResult
+TreeTransform<Derived>::TransformOMPScopeDirective(OMPScopeDirective *D) {
+  DeclarationNameInfo DirName;
+  getDerived().getSema().StartOpenMPDSABlock(OMPD_scope, DirName, nullptr,
+                                             D->getBeginLoc());
+  StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
+  getDerived().getSema().EndOpenMPDSABlock(Res.get());
+  return Res;
+}
+
+template <typename Derived>
+StmtResult
 TreeTransform<Derived>::TransformOMPSingleDirective(OMPSingleDirective *D) {
   DeclarationNameInfo DirName;
   getDerived().getSema().StartOpenMPDSABlock(OMPD_single, DirName, nullptr,
                                              D->getBeginLoc());
   StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
   getDerived().getSema().EndOpenMPDSABlock(Res.get());
   return Res;
 }

clang/lib/Serialization/ASTReaderStmt.cpp

 }
 
 void ASTStmtReader::VisitOMPSectionDirective(OMPSectionDirective *D) {
   VisitStmt(D);
   VisitOMPExecutableDirective(D);
   D->setHasCancel(Record.readBool());
 }
 
+void ASTStmtReader::VisitOMPScopeDirective(OMPScopeDirective *D) {
+  VisitStmt(D);
+  VisitOMPExecutableDirective(D);
+}
+
 void ASTStmtReader::VisitOMPSingleDirective(OMPSingleDirective *D) {
   VisitStmt(D);
   VisitOMPExecutableDirective(D);
 }
 
 void ASTStmtReader::VisitOMPMasterDirective(OMPMasterDirective *D) {
   VisitStmt(D);
   VisitOMPExecutableDirective(D);
case STMT_OMP_SECTIONS_DIRECTIVE:
       S = OMPSectionsDirective::CreateEmpty(
           Context, Record[ASTStmtReader::NumStmtFields], Empty);
       break;
 
     case STMT_OMP_SECTION_DIRECTIVE:
       S = OMPSectionDirective::CreateEmpty(Context, Empty);
       break;
 
+    case STMT_OMP_SCOPE_DIRECTIVE:
+      S = OMPScopeDirective::CreateEmpty(
+          Context, Record[ASTStmtReader::NumStmtFields], Empty);
+      break;
+
     case STMT_OMP_SINGLE_DIRECTIVE:
       S = OMPSingleDirective::CreateEmpty(
           Context, Record[ASTStmtReader::NumStmtFields], Empty);
       break;
 
     case STMT_OMP_MASTER_DIRECTIVE:
       S = OMPMasterDirective::CreateEmpty(Context, Empty);
       break;

clang/lib/Serialization/ASTWriterStmt.cpp

 
 void ASTStmtWriter::VisitOMPSectionDirective(OMPSectionDirective *D) {
   VisitStmt(D);
   VisitOMPExecutableDirective(D);
   Record.writeBool(D->hasCancel());
   Code = serialization::STMT_OMP_SECTION_DIRECTIVE;
 }
 
+void ASTStmtWriter::VisitOMPScopeDirective(OMPScopeDirective *D) {
+  VisitStmt(D);
+  VisitOMPExecutableDirective(D);
+  Code = serialization::STMT_OMP_SCOPE_DIRECTIVE;
+}
+
 void ASTStmtWriter::VisitOMPSingleDirective(OMPSingleDirective *D) {
   VisitStmt(D);
   VisitOMPExecutableDirective(D);
   Code = serialization::STMT_OMP_SINGLE_DIRECTIVE;
 }
 
 void ASTStmtWriter::VisitOMPMasterDirective(OMPMasterDirective *D) {
   VisitStmt(D);

clang/lib/StaticAnalyzer/Core/ExprEngine.cpp

switch (S->getStmtClass()) {
     case Stmt::SEHFinallyStmtClass:
     case Stmt::OMPCanonicalLoopClass:
     case Stmt::OMPParallelDirectiveClass:
     case Stmt::OMPSimdDirectiveClass:
     case Stmt::OMPForDirectiveClass:
     case Stmt::OMPForSimdDirectiveClass:
     case Stmt::OMPSectionsDirectiveClass:
     case Stmt::OMPSectionDirectiveClass:
+    case Stmt::OMPScopeDirectiveClass:
     case Stmt::OMPSingleDirectiveClass:
     case Stmt::OMPMasterDirectiveClass:
     case Stmt::OMPCriticalDirectiveClass:
     case Stmt::OMPParallelForDirectiveClass:
     case Stmt::OMPParallelForSimdDirectiveClass:
     case Stmt::OMPParallelSectionsDirectiveClass:
     case Stmt::OMPParallelMasterDirectiveClass:
     case Stmt::OMPParallelMaskedDirectiveClass:

clang/test/OpenMP/nesting_of_regions.cpp

 // RUN: %clang_cc1 -fsyntax-only -fopenmp -fopenmp-version=45 -fno-openmp-extensions -verify=expected,omp45,omp45warn,omp %s
 // RUN: %clang_cc1 -fsyntax-only -fopenmp -fno-openmp-extensions -verify=expected,omp50,omp %s
 // RUN: %clang_cc1 -fsyntax-only -fopenmp -fopenmp-extensions -verify=expected,omp50 %s
 // RUN: %clang_cc1 -fsyntax-only -fopenmp -fopenmp-version=45 -verify=expected,omp45,omp -fno-openmp-extensions -Wno-openmp %s
 // RUN: %clang_cc1 -fsyntax-only -fopenmp -fopenmp-version=45 -verify=expected,omp45,omp -fno-openmp-extensions -Wno-source-uses-openmp %s
+// RUN: %clang_cc1 -fsyntax-only -fopenmp -fopenmp-version=51 -verify=expected,omp51,omp -fno-openmp-extensions -Wno-source-uses-openmp %s
 
 // RUN: %clang_cc1 -fsyntax-only -fopenmp-simd -fopenmp-version=45 -fno-openmp-extensions -verify=expected,omp45,omp45warn,omp %s
 // RUN: %clang_cc1 -fsyntax-only -fopenmp-simd -verify=expected,omp50,omp -fno-openmp-extensions %s
+// RUN: %clang_cc1 -fsyntax-only -fopenmp-simd -fopenmp-version=51 -verify=expected,omp51,omp -fno-openmp-extensions %s
 // SIMD-ONLY0-NOT: {{__kmpc|__tgt}}
 
 void bar();
 
 template <class T>
 void foo() {
   T a = T();
 // PARALLEL DIRECTIVE

 #pragma omp target teams distribute simd // OK
     for (int i = 0; i < 10; ++i)
       ;
   }
 
 // SIMD DIRECTIVE
 #pragma omp simd
   for (int i = 0; i < 10; ++i) {
-#pragma omp for // omp45-error {{OpenMP constructs may not be nested inside a simd region}} omp50-error {{OpenMP constructs may not be nested inside a simd region except for ordered simd, simd, scan, or atomic directive}}
+#pragma omp for // omp45-error {{OpenMP constructs may not be nested inside a simd region}} omp50-error {{OpenMP constructs may not be nested inside a simd region except for ordered simd, simd, scan, or atomic directive}} omp51-error {{OpenMP constructs may not be nested inside a simd region except for ordered simd, simd, scan, or atomic directive}}
     for (int i = 0; i < 10; ++i)
       ;
   }
 #pragma omp simd
   for (int i = 0; i < 10; ++i) {
 #pragma omp simd // omp45warn-warning {{OpenMP only allows an ordered construct with the simd clause nested in a simd construct}}
     for (int i = 0; i < 10; ++i)
       ;
#pragma omp taskyield // expected-error {{OpenMP constructs may not be nested inside a simd region}}
   }
 #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();
   }
 #pragma omp simd
   for (int i = 0; i < 10; ++i) {
-#pragma omp scan // omp45-error {{OpenMP constructs may not be nested inside a simd region}} omp50-error {{exactly one of 'inclusive' or 'exclusive' clauses is expected}}
+#pragma omp scan // omp45-error {{OpenMP constructs may not be nested inside a simd region}} omp50-error {{exactly one of 'inclusive' or 'exclusive' clauses is expected}} omp51-error {{exactly one of 'inclusive' or 'exclusive' clauses is expected}}
     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();
   }
 #pragma omp simd
#pragma omp taskyield
   }
 #pragma omp for
   for (int i = 0; i < 10; ++i) {
 #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 scan // omp45-error {{region cannot be closely nested inside 'for' region; perhaps you forget to enclose 'omp scan' directive into a for, simd, for simd, parallel for, or parallel for simd region?}} omp50-error {{exactly one of 'inclusive' or 'exclusive' clauses is expected}}
+#pragma omp scan // omp45-error {{region cannot be closely nested inside 'for' region; perhaps you forget to enclose 'omp scan' directive into a for, simd, for simd, parallel for, or parallel for simd region?}} omp50-error {{exactly one of 'inclusive' or 'exclusive' clauses is expected}} omp51-error {{exactly one of 'inclusive' or 'exclusive' clauses is expected}}
     bar();
   }
 #pragma omp for
   for (int i = 0; i < 10; ++i) {
 #pragma omp taskwait
     bar();
   }
 #pragma omp for
#pragma omp taskyield // expected-error {{OpenMP constructs may not be nested inside a simd region}}
   }
 #pragma omp for simd
   for (int i = 0; i < 10; ++i) {
 #pragma omp barrier // expected-error {{OpenMP constructs may not be nested inside a simd region}}
     bar();
   }
 #pragma omp for simd
   for (int i = 0; i < 10; ++i) {
-#pragma omp scan // omp45-error {{OpenMP constructs may not be nested inside a simd region}} omp50-error {{exactly one of 'inclusive' or 'exclusive' clauses is expected}}
+#pragma omp scan // omp45-error {{OpenMP constructs may not be nested inside a simd region}} omp50-error {{exactly one of 'inclusive' or 'exclusive' clauses is expected}} omp51-error {{exactly one of 'inclusive' or 'exclusive' clauses is expected}}
     bar();
   }
 #pragma omp for simd
   for (int i = 0; i < 10; ++i) {
 #pragma omp taskwait // expected-error {{OpenMP constructs may not be nested inside a simd region}}
     bar();
   }
 #pragma omp for simd
#pragma omp taskyield
   }
 #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();
   }
 #pragma omp parallel for
   for (int i = 0; i < 10; ++i) {
-#pragma omp scan // omp45-error {{region cannot be closely nested inside 'parallel for' region}} omp50-error {{exactly one of 'inclusive' or 'exclusive' clauses is expected}}
+#pragma omp scan // omp45-error {{region cannot be closely nested inside 'parallel for' region}} omp50-error {{exactly one of 'inclusive' or 'exclusive' clauses is expected}} omp51-error {{exactly one of 'inclusive' or 'exclusive' clauses is expected}}
     bar();
   }
 #pragma omp parallel for
   for (int i = 0; i < 10; ++i) {
 #pragma omp taskwait
     bar();
   }
 #pragma omp parallel for
#pragma omp taskyield // expected-error {{OpenMP constructs may not be nested inside a simd region}}
   }
 #pragma omp parallel for simd
   for (int i = 0; i < 10; ++i) {
 #pragma omp barrier // expected-error {{OpenMP constructs may not be nested inside a simd region}}
     bar();
   }
 #pragma omp parallel for simd
   for (int i = 0; i < 10; ++i) {
-#pragma omp scan // omp45-error {{OpenMP constructs may not be nested inside a simd region}} omp50-error {{exactly one of 'inclusive' or 'exclusive' clauses is expected}}
+#pragma omp scan // omp45-error {{OpenMP constructs may not be nested inside a simd region}} omp50-error {{exactly one of 'inclusive' or 'exclusive' clauses is expected}} omp51-error {{exactly one of 'inclusive' or 'exclusive' clauses is expected}}
     bar();
   }
 #pragma omp parallel for simd
   for (int i = 0; i < 10; ++i) {
 #pragma omp taskwait // expected-error {{OpenMP constructs may not be nested inside a simd region}}
     bar();
   }
 #pragma omp parallel for simd
#pragma omp distribute parallel for simd
   for (int i = 0; i < 10; ++i) {
 #pragma omp barrier // expected-error {{OpenMP constructs may not be nested inside a simd region}}
     bar();
   }
 #pragma omp target
 #pragma omp teams
 #pragma omp distribute parallel for simd
   for (int i = 0; i < 10; ++i) {
-#pragma omp scan // omp45-error {{OpenMP constructs may not be nested inside a simd region}} omp50-error {{region cannot be closely nested inside 'distribute parallel for simd' region; perhaps you forget to enclose 'omp scan' directive into a for, simd, for simd, parallel for, or parallel for simd region?}}
+#pragma omp scan // omp45-error {{OpenMP constructs may not be nested inside a simd region}} omp50-error {{region cannot be closely nested inside 'distribute parallel for simd' region; perhaps you forget to enclose 'omp scan' directive into a for, simd, for simd, parallel for, or parallel for simd region?}} omp51-error {{region cannot be closely nested inside 'distribute parallel for simd' region; perhaps you forget to enclose 'omp scan' directive into a for, simd, for simd, parallel for, or parallel for simd region?}}
     bar();
   }
 #pragma omp target
 #pragma omp teams
 #pragma omp distribute parallel for simd
   for (int i = 0; i < 10; ++i) {
 #pragma omp taskwait // expected-error {{OpenMP constructs may not be nested inside a simd region}}
     bar();
#pragma omp taskyield // expected-error {{OpenMP constructs may not be nested inside a simd region}}
   }
 #pragma omp target simd
   for (int i = 0; i < 10; ++i) {
 #pragma omp barrier // expected-error {{OpenMP constructs may not be nested inside a simd region}}
     bar();
   }
 #pragma omp target simd
   for (int i = 0; i < 10; ++i) {
-#pragma omp scan // omp45-error {{OpenMP constructs may not be nested inside a simd region}} omp50-error {{region cannot be closely nested inside 'target simd' region; perhaps you forget to enclose 'omp scan' directive into a for, simd, for simd, parallel for, or parallel for simd region?}}
+#pragma omp scan // omp45-error {{OpenMP constructs may not be nested inside a simd region}} omp50-error {{region cannot be closely nested inside 'target simd' region; perhaps you forget to enclose 'omp scan' directive into a for, simd, for simd, parallel for, or parallel for simd region?}} omp51-error {{region cannot be closely nested inside 'target simd' region; perhaps you forget to enclose 'omp scan' directive into a for, simd, for simd, parallel for, or parallel for simd region?}}
     bar();
   }
 #pragma omp target simd
   for (int i = 0; i < 10; ++i) {
 #pragma omp taskwait // expected-error {{OpenMP constructs may not be nested inside a simd region}}
     bar();
   }
 #pragma omp target simd

 #pragma omp teams distribute simd
   for (int i = 0; i < 10; ++i) {
 #pragma omp barrier // expected-error {{OpenMP constructs may not be nested inside a simd region}}
     bar();
   }
 #pragma omp target
 #pragma omp teams distribute simd
   for (int i = 0; i < 10; ++i) {
-#pragma omp scan // omp45-error {{OpenMP constructs may not be nested inside a simd region}} omp50-error {{region cannot be closely nested inside 'teams distribute simd' region; perhaps you forget to enclose 'omp scan' directive into a for, simd, for simd, parallel for, or parallel for simd region?}}
+#pragma omp scan // omp45-error {{OpenMP constructs may not be nested inside a simd region}} omp50-error {{region cannot be closely nested inside 'teams distribute simd' region; perhaps you forget to enclose 'omp scan' directive into a for, simd, for simd, parallel for, or parallel for simd region?}} omp51-error {{region cannot be closely nested inside 'teams distribute simd' region; perhaps you forget to enclose 'omp scan' directive into a for, simd, for simd, parallel for, or parallel for simd region?}}
     bar();
   }
 #pragma omp target
 #pragma omp teams distribute simd
   for (int i = 0; i < 10; ++i) {
 #pragma omp taskwait // expected-error {{OpenMP constructs may not be nested inside a simd region}}
     bar();
   }

 #pragma omp teams distribute parallel for simd
   for (int i = 0; i < 10; ++i) {
 #pragma omp barrier // expected-error {{OpenMP constructs may not be nested inside a simd region}}
     bar();
   }
 #pragma omp target
 #pragma omp teams distribute parallel for simd
   for (int i = 0; i < 10; ++i) {
-#pragma omp scan // omp45-error {{OpenMP constructs may not be nested inside a simd region}} omp50-error {{region cannot be closely nested inside 'teams distribute parallel for simd' region; perhaps you forget to enclose 'omp scan' directive into a for, simd, for simd, parallel for, or parallel for simd region?}}
+#pragma omp scan // omp45-error {{OpenMP constructs may not be nested inside a simd region}} omp50-error {{region cannot be closely nested inside 'teams distribute parallel for simd' region; perhaps you forget to enclose 'omp scan' directive into a for, simd, for simd, parallel for, or parallel for simd region?}} omp51-error {{region cannot be closely nested inside 'teams distribute parallel for simd' region; perhaps you forget to enclose 'omp scan' directive into a for, simd, for simd, parallel for, or parallel for simd region?}}
     bar();
   }
 #pragma omp target
 #pragma omp teams distribute parallel for simd
   for (int i = 0; i < 10; ++i) {
 #pragma omp taskwait // expected-error {{OpenMP constructs may not be nested inside a simd region}}
     bar();
   }
#pragma omp taskyield // expected-error {{OpenMP constructs may not be nested inside a simd region}}
   }
 #pragma omp target teams distribute parallel for simd
   for (int i = 0; i < 10; ++i) {
 #pragma omp barrier // expected-error {{OpenMP constructs may not be nested inside a simd region}}
     bar();
   }
 #pragma omp target teams distribute parallel for simd
   for (int i = 0; i < 10; ++i) {
-#pragma omp scan // omp45-error {{OpenMP constructs may not be nested inside a simd region}} omp50-error {{region cannot be closely nested inside 'target teams distribute parallel for simd' region; perhaps you forget to enclose 'omp scan' directive into a for, simd, for simd, parallel for, or parallel for simd region?}}
+#pragma omp scan // omp45-error {{OpenMP constructs may not be nested inside a simd region}} omp50-error {{region cannot be closely nested inside 'target teams distribute parallel for simd' region; perhaps you forget to enclose 'omp scan' directive into a for, simd, for simd, parallel for, or parallel for simd region?}} omp51-error {{region cannot be closely nested inside 'target teams distribute parallel for simd' region; perhaps you forget to enclose 'omp scan' directive into a for, simd, for simd, parallel for, or parallel for simd region?}}
     bar();
   }
 #pragma omp target teams distribute parallel for simd
   for (int i = 0; i < 10; ++i) {
 #pragma omp taskwait // expected-error {{OpenMP constructs may not be nested inside a simd region}}
     bar();
   }
 #pragma omp target teams distribute parallel for simd
#pragma omp taskyield // expected-error {{OpenMP constructs may not be nested inside a simd region}}
   }
 #pragma omp target teams distribute simd
   for (int i = 0; i < 10; ++i) {
 #pragma omp barrier // expected-error {{OpenMP constructs may not be nested inside a simd region}}
     bar();
   }
 #pragma omp target teams distribute simd
   for (int i = 0; i < 10; ++i) {
-#pragma omp scan // omp45-error {{OpenMP constructs may not be nested inside a simd region}} omp50-error {{region cannot be closely nested inside 'target teams distribute simd' region; perhaps you forget to enclose 'omp scan' directive into a for, simd, for simd, parallel for, or parallel for simd region?}}
+#pragma omp scan // omp45-error {{OpenMP constructs may not be nested inside a simd region}} omp50-error {{region cannot be closely nested inside 'target teams distribute simd' region; perhaps you forget to enclose 'omp scan' directive into a for, simd, for simd, parallel for, or parallel for simd region?}} omp51-error {{region cannot be closely nested inside 'target teams distribute simd' region; perhaps you forget to enclose 'omp scan' directive into a for, simd, for simd, parallel for, or parallel for simd region?}}
     bar();
   }
 #pragma omp target teams distribute simd
   for (int i = 0; i < 10; ++i) {
 #pragma omp taskwait // expected-error {{OpenMP constructs may not be nested inside a simd region}}
     bar();
   }
 #pragma omp target teams distribute simd
#pragma omp target teams distribute parallel for simd // expected-error {{OpenMP constructs may not be nested inside a simd region}}
   }
 #pragma omp target teams distribute simd
   for (int i = 0; i < 10; ++i) {
 #pragma omp target teams distribute simd // expected-error {{OpenMP constructs may not be nested inside a simd region}}
     for (int i = 0; i < 10; ++i)
       ;
   }
 
+  // SCOPE DIRECTIVE
+#pragma omp scope
+#pragma omp parallel // OK
+  bar();
+#pragma omp scope
+#pragma omp parallel for // OK
+  for(int i = 0; i < 10; i++)
+    ;
+#pragma omp scope
+#pragma omp parallel for simd // OK
+  for(int i = 0; i < 10; i++)
+    ;
+#pragma omp scope
+#pragma omp for
+  for (int i = 0; i < 10; ++i)
+    ;
+#pragma omp scope
+#pragma omp simd
+  for (int i = 0; i < 10; ++i)
+    ;
+#pragma omp scope
+#pragma omp for simd
+  for (int i = 0; i < 10; ++i)
+    ;
+#pragma omp scope
+#pragma omp sections
+  {
+    bar();
+  }
+#pragma omp scope
+#pragma omp section // expected-error {{'omp section' directive must be closely nested to a sections region, not a scope region}}
+  {
+    bar();
+  }
+#pragma omp scope
+#pragma omp single
+  bar();
+
+#pragma omp scope
+#pragma omp master
+  {
+    bar();
+  }
+#pragma omp scope
+#pragma omp critical
+  {
+    bar();
+  }
+#pragma omp scope
+#pragma omp parallel sections
+  {
+    bar();
+  }
+#pragma omp scope
+#pragma omp parallel master
+  {
+    bar();
+  }
+#pragma omp scope
+#pragma omp parallel masked
+  {
+    bar();
+  }
+#pragma omp scope
+#pragma omp task
+  {
+    bar();
+  }
+#pragma omp scope
+  {
+#pragma omp taskyield
+    bar();
+  }
+#pragma omp scope
+  {
+#pragma omp barrier
+    bar();
+  }
+#pragma omp scope
+  {
+#pragma omp scan // expected-error {{region cannot be closely nested inside 'scope' region; perhaps you forget to enclose 'omp scan' directive into a for, simd, for simd, parallel for, or parallel for simd region?}}
+    bar();
+  }
+#pragma omp scope
+  {
+#pragma omp taskwait
+    bar();
+  }
+#pragma omp scope
+  {
+#pragma omp flush
+    bar();
+  }
+#pragma omp scope
+  {
+#pragma omp ordered // expected-error {{region cannot be closely nested inside 'scope' region; perhaps you forget to enclose 'omp ordered' directive into a for or a parallel for region with 'ordered' clause?}}
+    bar();
+  }
+#pragma omp scope
+  {
+#pragma omp atomic
+    ++a;
+  }
+#pragma omp scope
+  {
+#pragma omp target parallel
+    ++a;
+  }
+#pragma omp scope
+  {
+#pragma omp target parallel for
+  for (int i = 0; i < 10; ++i)
+    ;
+  }
+#pragma omp scope
+  {
+#pragma omp target enter data map(to: a)
+    ++a;
+  }
+#pragma omp scope
+  {
+#pragma omp target exit data map(from: a)
+    ++a;
+  }
+#pragma omp scope
+  {
+#pragma omp taskloop
+  for (int i = 0; i < 10; ++i)
+    ++a;
+  }
+#pragma omp scope
+  {
+#pragma omp target // OK
+    a++;
+  }
+#pragma omp scope
+  {
+#pragma omp teams // expected-error {{region cannot be closely nested inside 'scope' region; perhaps you forget to enclose 'omp teams' directive into a target region?}}
+    a++;
+  }
+#pragma omp scope
+  {
+#pragma omp target teams // OK
+    a++;
+  }
+#pragma omp scope
+  {
+#pragma omp distribute // expected-error {{region cannot be closely nested inside 'scope' region; perhaps you forget to enclose 'omp distribute' directive into a teams region?}}
+    for (int i = 0; i < 10; ++i)
+      ;
+  }
+ #pragma omp scope
+   {
+ #pragma omp distribute parallel for simd // expected-error {{region cannot be closely nested inside 'scope' region; perhaps you forget to enclose 'omp distribute parallel for simd' directive into a teams region?}}
+     for (int i = 0; i < 10; ++i)
+       ;
+   }
+#pragma omp scope
+  {
+#pragma omp distribute simd // expected-error {{region cannot be closely nested inside 'scope' region; perhaps you forget to enclose 'omp distribute simd' directive into a teams region?}}
+    for (int i = 0; i < 10; ++i)
+      ;
+  }
+#pragma omp scope
+  {
+#pragma omp target simd // OK
+    for (int i = 0; i < 10; ++i)
+      ;
+  }
+#pragma omp scope
+   {
+ #pragma omp teams distribute // expected-error {{region cannot be closely nested inside 'scope' region; perhaps you forget to enclose 'omp teams distribute' directive into a target region?}}
+     for (int i = 0; i < 10; ++i)
+       ;
+   }
+#pragma omp scope
+  {
+#pragma omp teams distribute simd // expected-error {{region cannot be closely nested inside 'scope' region; perhaps you forget to enclose 'omp teams distribute simd' directive into a target region?}}
+    for (int i = 0; i < 10; ++i)
+      ;
+  }
+#pragma omp scope
+  {
+#pragma omp teams distribute parallel for simd // expected-error {{region cannot be closely nested inside 'scope' region; perhaps you forget to enclose 'omp teams distribute parallel for simd' directive into a target region?}}
+    for (int i = 0; i < 10; ++i)
+      ;
+  }
+#pragma omp scope
+  {
+#pragma omp teams distribute parallel for // expected-error {{region cannot be closely nested inside 'scope' region; perhaps you forget to enclose 'omp teams distribute parallel for' directive into a target region?}}
+    for (int i = 0; i < 10; ++i)
+      ;
+  }
+#pragma omp scope
+  {
+#pragma omp target teams // OK
+    ++a;
+  }
+#pragma omp scope
+  {
+#pragma omp target teams distribute // OK
+    for (int i = 0; i < 10; ++i)
+      ;
+  }
+#pragma omp scope
+  {
+#pragma omp target teams distribute parallel for // OK
+    for (int i = 0; i < 10; ++i)
+      ;
+  }
+#pragma omp scope
+  {
+#pragma omp target teams distribute parallel for simd // OK
+    for (int i = 0; i < 10; ++i)
+      ;
+  }
+#pragma omp scope
+  {
+#pragma omp target teams distribute simd // OK
+    for (int i = 0; i < 10; ++i)
+      ;
+  }
+#pragma omp for
+  for (int i = 0; i < 10; ++i) {
+#pragma omp scope // expected-error {{region cannot be closely nested inside 'for' region}}
+    bar();
+  }
+
+#pragma omp for simd
+  for (int i = 0; i < 10; ++i) {
+#pragma omp scope // expected-error {{OpenMP constructs may not be nested inside a simd region}}
+    bar();
+  }
+
+#pragma omp sections
+  {
+#pragma omp scope // expected-error {{region cannot be closely nested inside 'sections' region}}
+    bar();
+  }
+
+#pragma omp sections
+  {
+#pragma omp section
+    {
+#pragma omp scope // expected-error {{region cannot be closely nested inside 'section' region}}
+      bar();
+    }
+  }
+
+#pragma omp single
+  {
+#pragma omp scope // expected-error {{region cannot be closely nested inside 'single' region}}
+    bar();
+  }
+
+#pragma omp master
+  {
+#pragma omp scope // expected-error {{region cannot be closely nested inside 'master' region}}
+    bar();
+  }
+
+#pragma omp critical
+  {
+#pragma omp scope // expected-error {{region cannot be closely nested inside 'critical' region}}
+    bar();
+  }
+
+#pragma omp parallel for
+  for (int i = 0; i < 10; ++i) {
+#pragma omp scope // expected-error {{region cannot be closely nested inside 'parallel for' region}}
+    bar();
+  }
+
+#pragma omp parallel for simd
+  for (int i = 0; i < 10; ++i) {
+#pragma omp scope // expected-error {{OpenMP constructs may not be nested inside a simd region}}
+    bar();
+  }
+
+#pragma omp parallel master
+  {
+#pragma omp scope // expected-error {{region cannot be closely nested inside 'parallel master' region}}
+    bar();
+  }
+
+#pragma omp parallel sections
+  {
+#pragma omp scope // expected-error {{region cannot be closely nested inside 'parallel sections' region}}
+    bar();
+  }
+
+#pragma omp task
+  {
+#pragma omp scope // expected-error {{region cannot be closely nested inside 'task' region}}
+    bar();
+  }
+
+#pragma omp ordered
+  {
+#pragma omp scope // expected-error {{region cannot be closely nested inside 'ordered' region}}
+    bar();
+  }
+
+#pragma omp atomic
+  // expected-error@+2 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an lvalue expression with scalar type}}
+  // expected-note@+1 {{expected an expression statement}}
+  {
+#pragma omp scope // expected-error {{OpenMP constructs may not be nested inside an atomic region}}
+    bar();
+  }
+
+#pragma omp target
+#pragma omp teams
+  {
+#pragma omp scope // expected-error {{region cannot be closely nested inside 'teams' region; perhaps you forget to enclose 'omp scope' directive into a parallel region?}}
+    bar();
+  }
+
+#pragma omp taskloop
+  for (int i = 0; i < 10; ++i) {
+#pragma omp scope // expected-error {{region cannot be closely nested inside 'taskloop' region}}
+    bar();
+  }
+
+#pragma omp target
+#pragma omp teams
+#pragma omp distribute parallel for
+  for (int i = 0; i < 10; ++i) {
+#pragma omp scope // expected-error {{region cannot be closely nested inside 'distribute parallel for' region}}
+    bar();
+  }
+
+#pragma omp target
+#pragma omp teams
+#pragma omp distribute parallel for simd
+  for (int i = 0; i < 10; ++i) {
+#pragma omp scope // expected-error {{OpenMP constructs may not be nested inside a simd region}}
+    bar();
+  }
+
+#pragma omp target simd
+  for (int i = 0; i < 10; ++i) {
+#pragma omp scope // expected-error {{OpenMP constructs may not be nested inside a simd region}}
+    bar();
+  }
+
+#pragma omp target
+#pragma omp teams distribute simd
+  for (int i = 0; i < 10; ++i) {
+#pragma omp scope // expected-error {{OpenMP constructs may not be nested inside a simd region}}
+    bar();
+  }
+
+#pragma omp target
+#pragma omp teams distribute parallel for simd
+  for (int i = 0; i < 10; ++i) {
+#pragma omp scope // expected-error {{OpenMP constructs may not be nested inside a simd region}}
+    bar();
+  }
+
+#pragma omp target
+#pragma omp teams distribute parallel for
+  for (int i = 0; i < 10; ++i) {
+#pragma omp scope // expected-error {{region cannot be closely nested inside 'teams distribute parallel for' region}}
+    bar();
+  }
+
+#pragma omp target teams
+  {
+#pragma omp scope // expected-error {{region cannot be closely nested inside 'target teams' region; perhaps you forget to enclose 'omp scope' directive into a parallel region?}}
+    bar();
+  }
+
+#pragma omp target teams distribute parallel for
+  for (int i = 0; i < 10; ++i) {
+#pragma omp scope // expected-error {{region cannot be closely nested inside 'target teams distribute parallel for' region}}
+    bar();
+  }
+
+#pragma omp target teams distribute parallel for simd
+  for (int i = 0; i < 10; ++i) {
+#pragma omp scope // expected-error {{OpenMP constructs may not be nested inside a simd region}}
+    bar();
+  }
+
+#pragma omp target teams distribute simd
+  for (int i = 0; i < 10; ++i) {
+#pragma omp scope // 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 scope // expected-error {{OpenMP constructs may not be nested inside a simd region}}
+    bar();
+  }
 }
 
 void foo() {
   int a = 0;
 // PARALLEL DIRECTIVE
 #pragma omp parallel
 #pragma omp for
   for (int i = 0; i < 10; ++i)
#pragma omp taskyield // expected-error {{OpenMP constructs may not be nested inside a simd region}}
   }
 #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();
   }
 #pragma omp simd
   for (int i = 0; i < 10; ++i) {
-#pragma omp scan // omp45-error {{OpenMP constructs may not be nested inside a simd region}} omp50-error {{exactly one of 'inclusive' or 'exclusive' clauses is expected}}
+#pragma omp scan // omp45-error {{OpenMP constructs may not be nested inside a simd region}} omp50-error {{exactly one of 'inclusive' or 'exclusive' clauses is expected}} omp51-error {{exactly one of 'inclusive' or 'exclusive' clauses is expected}}
     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();
   }
 #pragma omp simd
#pragma omp taskyield
   }
 #pragma omp for
   for (int i = 0; i < 10; ++i) {
 #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 scan // omp45-error {{region cannot be closely nested inside 'for' region}} omp50-error {{exactly one of 'inclusive' or 'exclusive' clauses is expected}}
+#pragma omp scan // omp45-error {{region cannot be closely nested inside 'for' region}} omp50-error {{exactly one of 'inclusive' or 'exclusive' clauses is expected}} omp51-error {{exactly one of 'inclusive' or 'exclusive' clauses is expected}}
     bar();
   }
 #pragma omp for
   for (int i = 0; i < 10; ++i) {
 #pragma omp taskwait
     bar();
   }
 #pragma omp for
#pragma omp taskyield // expected-error {{OpenMP constructs may not be nested inside a simd region}}
   }
 #pragma omp for simd
   for (int i = 0; i < 10; ++i) {
 #pragma omp barrier // expected-error {{OpenMP constructs may not be nested inside a simd region}}
     bar();
   }
 #pragma omp for simd
   for (int i = 0; i < 10; ++i) {
-#pragma omp scan // omp45-error {{OpenMP constructs may not be nested inside a simd region}} omp50-error {{exactly one of 'inclusive' or 'exclusive' clauses is expected}}
+#pragma omp scan // omp45-error {{OpenMP constructs may not be nested inside a simd region}} omp50-error {{exactly one of 'inclusive' or 'exclusive' clauses is expected}} omp51-error {{exactly one of 'inclusive' or 'exclusive' clauses is expected}}
     bar();
   }
 #pragma omp for simd
   for (int i = 0; i < 10; ++i) {
 #pragma omp taskwait // expected-error {{OpenMP constructs may not be nested inside a simd region}}
     bar();
   }
 #pragma omp for simd
#pragma omp taskyield
   }
 #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();
   }
 #pragma omp parallel for
   for (int i = 0; i < 10; ++i) {
-#pragma omp scan // omp45-error {{region cannot be closely nested inside 'parallel for' region}} omp50-error {{exactly one of 'inclusive' or 'exclusive' clauses is expected}}
+#pragma omp scan // omp45-error {{region cannot be closely nested inside 'parallel for' region}} omp50-error {{exactly one of 'inclusive' or 'exclusive' clauses is expected}} omp51-error {{exactly one of 'inclusive' or 'exclusive' clauses is expected}}
     bar();
   }
 #pragma omp parallel for
   for (int i = 0; i < 10; ++i) {
 #pragma omp taskwait
     bar();
   }
 #pragma omp parallel for
#pragma omp taskyield // expected-error {{OpenMP constructs may not be nested inside a simd region}}
   }
 #pragma omp parallel for simd
   for (int i = 0; i < 10; ++i) {
 #pragma omp barrier // expected-error {{OpenMP constructs may not be nested inside a simd region}}
     bar();
   }
 #pragma omp parallel for simd
   for (int i = 0; i < 10; ++i) {
-#pragma omp scan // omp45-error {{OpenMP constructs may not be nested inside a simd region}} omp50-error {{exactly one of 'inclusive' or 'exclusive' clauses is expected}}
+#pragma omp scan // omp45-error {{OpenMP constructs may not be nested inside a simd region}} omp50-error {{exactly one of 'inclusive' or 'exclusive' clauses is expected}} omp51-error {{exactly one of 'inclusive' or 'exclusive' clauses is expected}}
     bar();
   }
 #pragma omp parallel for simd
   for (int i = 0; i < 10; ++i) {
 #pragma omp taskwait // expected-error {{OpenMP constructs may not be nested inside a simd region}}
     bar();
   }
 #pragma omp parallel for simd
#pragma omp distribute parallel for simd
   for (int i = 0; i < 10; ++i) {
 #pragma omp barrier // expected-error {{OpenMP constructs may not be nested inside a simd region}}
     bar();
   }
 #pragma omp target
 #pragma omp teams
 #pragma omp distribute parallel for simd
   for (int i = 0; i < 10; ++i) {
-#pragma omp scan // omp45-error {{OpenMP constructs may not be nested inside a simd region}} omp50-error {{region cannot be closely nested inside 'distribute parallel for simd' region; perhaps you forget to enclose 'omp scan' directive into a for, simd, for simd, parallel for, or parallel for simd region?}}
+#pragma omp scan // omp45-error {{OpenMP constructs may not be nested inside a simd region}} omp50-error {{region cannot be closely nested inside 'distribute parallel for simd' region; perhaps you forget to enclose 'omp scan' directive into a for, simd, for simd, parallel for, or parallel for simd region?}} omp51-error {{region cannot be closely nested inside 'distribute parallel for simd' region; perhaps you forget to enclose 'omp scan' directive into a for, simd, for simd, parallel for, or parallel for simd region?}}
     bar();
   }
 #pragma omp target
 #pragma omp teams
 #pragma omp distribute parallel for simd
   for (int i = 0; i < 10; ++i) {
 #pragma omp taskwait // expected-error {{OpenMP constructs may not be nested inside a simd region}}
     bar();
#pragma omp distribute simd
   for (int i = 0; i < 10; ++i) {
 #pragma omp barrier // expected-error {{OpenMP constructs may not be nested inside a simd region}}
     bar();
   }
 #pragma omp target
 #pragma omp teams
 #pragma omp distribute simd
   for (int i = 0; i < 10; ++i) {
-#pragma omp scan // omp45-error {{OpenMP constructs may not be nested inside a simd region}} omp50-error {{region cannot be closely nested inside 'distribute simd' region; perhaps you forget to enclose 'omp scan' directive into a for, simd, for simd, parallel for, or parallel for simd region?}}
+#pragma omp scan // omp45-error {{OpenMP constructs may not be nested inside a simd region}} omp50-error {{region cannot be closely nested inside 'distribute simd' region; perhaps you forget to enclose 'omp scan' directive into a for, simd, for simd, parallel for, or parallel for simd region?}} omp51-error {{region cannot be closely nested inside 'distribute simd' region; perhaps you forget to enclose 'omp scan' directive into a for, simd, for simd, parallel for, or parallel for simd region?}}
     bar();
   }
 #pragma omp target
 #pragma omp teams
 #pragma omp distribute simd
   for (int i = 0; i < 10; ++i) {
 #pragma omp taskwait // expected-error {{OpenMP constructs may not be nested inside a simd region}}
     bar();
#pragma omp taskyield // expected-error {{OpenMP constructs may not be nested inside a simd region}}
   }
 #pragma omp target simd
   for (int i = 0; i < 10; ++i) {
 #pragma omp barrier // expected-error {{OpenMP constructs may not be nested inside a simd region}}
     bar();
   }
 #pragma omp target simd
   for (int i = 0; i < 10; ++i) {
-#pragma omp scan // omp45-error {{OpenMP constructs may not be nested inside a simd region}} omp50-error {{region cannot be closely nested inside 'target simd' region; perhaps you forget to enclose 'omp scan' directive into a for, simd, for simd, parallel for, or parallel for simd region?}}
+#pragma omp scan // omp45-error {{OpenMP constructs may not be nested inside a simd region}} omp50-error {{region cannot be closely nested inside 'target simd' region; perhaps you forget to enclose 'omp scan' directive into a for, simd, for simd, parallel for, or parallel for simd region?}} omp51-error {{region cannot be closely nested inside 'target simd' region; perhaps you forget to enclose 'omp scan' directive into a for, simd, for simd, parallel for, or parallel for simd region?}}
     bar();
   }
 #pragma omp target simd
   for (int i = 0; i < 10; ++i) {
 #pragma omp taskwait // expected-error {{OpenMP constructs may not be nested inside a simd region}}
     bar();
   }
 #pragma omp target simd

 #pragma omp teams distribute simd
   for (int i = 0; i < 10; ++i) {
 #pragma omp barrier // expected-error {{OpenMP constructs may not be nested inside a simd region}}
     bar();
   }
 #pragma omp target
 #pragma omp teams distribute simd
   for (int i = 0; i < 10; ++i) {
-#pragma omp scan // omp45-error {{OpenMP constructs may not be nested inside a simd region}} omp50-error {{region cannot be closely nested inside 'teams distribute simd' region; perhaps you forget to enclose 'omp scan' directive into a for, simd, for simd, parallel for, or parallel for simd region?}}
+#pragma omp scan // omp45-error {{OpenMP constructs may not be nested inside a simd region}} omp50-error {{region cannot be closely nested inside 'teams distribute simd' region; perhaps you forget to enclose 'omp scan' directive into a for, simd, for simd, parallel for, or parallel for simd region?}} omp51-error {{region cannot be closely nested inside 'teams distribute simd' region; perhaps you forget to enclose 'omp scan' directive into a for, simd, for simd, parallel for, or parallel for simd region?}}
     bar();
   }
 #pragma omp target
 #pragma omp teams distribute simd
   for (int i = 0; i < 10; ++i) {
 #pragma omp taskwait // expected-error {{OpenMP constructs may not be nested inside a simd region}}
     bar();
   }

 #pragma omp teams distribute parallel for simd
   for (int i = 0; i < 10; ++i) {
 #pragma omp barrier // expected-error {{OpenMP constructs may not be nested inside a simd region}}
     bar();
   }
 #pragma omp target
 #pragma omp teams distribute parallel for simd
   for (int i = 0; i < 10; ++i) {
-#pragma omp scan // omp45-error {{OpenMP constructs may not be nested inside a simd region}} omp50-error {{region cannot be closely nested inside 'teams distribute parallel for simd' region; perhaps you forget to enclose 'omp scan' directive into a for, simd, for simd, parallel for, or parallel for simd region?}}
+#pragma omp scan // omp45-error {{OpenMP constructs may not be nested inside a simd region}} omp50-error {{region cannot be closely nested inside 'teams distribute parallel for simd' region; perhaps you forget to enclose 'omp scan' directive into a for, simd, for simd, parallel for, or parallel for simd region?}} omp51-error {{region cannot be closely nested inside 'teams distribute parallel for simd' region; perhaps you forget to enclose 'omp scan' directive into a for, simd, for simd, parallel for, or parallel for simd region?}}
     bar();
   }
 #pragma omp target
 #pragma omp teams distribute parallel for simd
   for (int i = 0; i < 10; ++i) {
 #pragma omp taskwait // expected-error {{OpenMP constructs may not be nested inside a simd region}}
     bar();
   }
#pragma omp taskyield // expected-error {{OpenMP constructs may not be nested inside a simd region}}
   }
 #pragma omp target teams distribute parallel for simd
   for (int i = 0; i < 10; ++i) {
 #pragma omp barrier // expected-error {{OpenMP constructs may not be nested inside a simd region}}
     bar();
   }
 #pragma omp target teams distribute parallel for simd
   for (int i = 0; i < 10; ++i) {
-#pragma omp scan // omp45-error {{OpenMP constructs may not be nested inside a simd region}} omp50-error {{region cannot be closely nested inside 'target teams distribute parallel for simd' region; perhaps you forget to enclose 'omp scan' directive into a for, simd, for simd, parallel for, or parallel for simd region?}}
+#pragma omp scan // omp45-error {{OpenMP constructs may not be nested inside a simd region}} omp50-error {{region cannot be closely nested inside 'target teams distribute parallel for simd' region; perhaps you forget to enclose 'omp scan' directive into a for, simd, for simd, parallel for, or parallel for simd region?}} omp51-error {{region cannot be closely nested inside 'target teams distribute parallel for simd' region; perhaps you forget to enclose 'omp scan' directive into a for, simd, for simd, parallel for, or parallel for simd region?}}
     bar();
   }
 #pragma omp target teams distribute parallel for simd
   for (int i = 0; i < 10; ++i) {
 #pragma omp taskwait // expected-error {{OpenMP constructs may not be nested inside a simd region}}
     bar();
   }
 #pragma omp target teams distribute parallel for simd
#pragma omp taskyield // expected-error {{OpenMP constructs may not be nested inside a simd region}}
   }
 #pragma omp target teams distribute simd
   for (int i = 0; i < 10; ++i) {
 #pragma omp barrier // expected-error {{OpenMP constructs may not be nested inside a simd region}}
     bar();
   }
 #pragma omp target teams distribute simd
   for (int i = 0; i < 10; ++i) {
-#pragma omp scan // omp45-error {{OpenMP constructs may not be nested inside a simd region}} omp50-error {{region cannot be closely nested inside 'target teams distribute simd' region; perhaps you forget to enclose 'omp scan' directive into a for, simd, for simd, parallel for, or parallel for simd region?}}
+#pragma omp scan // omp45-error {{OpenMP constructs may not be nested inside a simd region}} omp50-error {{region cannot be closely nested inside 'target teams distribute simd' region; perhaps you forget to enclose 'omp scan' directive into a for, simd, for simd, parallel for, or parallel for simd region?}} omp51-error {{region cannot be closely nested inside 'target teams distribute simd' region; perhaps you forget to enclose 'omp scan' directive into a for, simd, for simd, parallel for, or parallel for simd region?}}
     bar();
   }
 #pragma omp target teams distribute simd
   for (int i = 0; i < 10; ++i) {
 #pragma omp taskwait // expected-error {{OpenMP constructs may not be nested inside a simd region}}
     bar();
   }
 #pragma omp target teams distribute simd
#pragma omp target teams distribute parallel for simd // expected-error {{OpenMP constructs may not be nested inside a simd region}}
   }
 #pragma omp target teams distribute simd
   for (int i = 0; i < 10; ++i) {
 #pragma omp target teams distribute simd // expected-error {{OpenMP constructs may not be nested inside a simd region}}
     for (int i = 0; i < 10; ++i)
       ;
   }
 
+  // SCOPE DIRECTIVE
+#pragma omp scope
+#pragma omp parallel // OK
+  bar();
+#pragma omp scope
+#pragma omp parallel for // OK
+  for(int i = 0; i < 10; i++)
+    ;
+#pragma omp scope
+#pragma omp parallel for simd // OK
+  for(int i = 0; i < 10; i++)
+    ;
+#pragma omp scope
+#pragma omp for
+  for (int i = 0; i < 10; ++i)
+    ;
+#pragma omp scope
+#pragma omp simd
+  for (int i = 0; i < 10; ++i)
+    ;
+#pragma omp scope
+#pragma omp for simd
+  for (int i = 0; i < 10; ++i)
+    ;
+#pragma omp scope
+#pragma omp sections
+  {
+    bar();
+  }
+#pragma omp scope
+#pragma omp section // expected-error {{'omp section' directive must be closely nested to a sections region, not a scope region}}
+  {
+    bar();
+  }
+#pragma omp scope
+#pragma omp single
+  bar();
+
+#pragma omp scope
+#pragma omp master
+  {
+    bar();
+  }
+#pragma omp scope
+#pragma omp critical
+  {
+    bar();
+  }
+#pragma omp scope
+#pragma omp parallel sections
+  {
+    bar();
+  }
+#pragma omp scope
+#pragma omp parallel master
+  {
+    bar();
+  }
+#pragma omp scope
+#pragma omp parallel masked
+  {
+    bar();
+  }
+#pragma omp scope
+#pragma omp task
+  {
+    bar();
+  }
+#pragma omp scope
+  {
+#pragma omp taskyield
+    bar();
+  }
+#pragma omp scope
+  {
+#pragma omp barrier
+    bar();
+  }
+#pragma omp scope
+  {
+#pragma omp scan // expected-error {{region cannot be closely nested inside 'scope' region; perhaps you forget to enclose 'omp scan' directive into a for, simd, for simd, parallel for, or parallel for simd region?}}
+    bar();
+  }
+#pragma omp scope
+  {
+#pragma omp taskwait
+    bar();
+  }
+#pragma omp scope
+  {
+#pragma omp flush
+    bar();
+  }
+#pragma omp scope
+  {
+#pragma omp ordered // expected-error {{region cannot be closely nested inside 'scope' region; perhaps you forget to enclose 'omp ordered' directive into a for or a parallel for region with 'ordered' clause?}}
+    bar();
+  }
+#pragma omp scope
+  {
+#pragma omp atomic
+    ++a;
+  }
+#pragma omp scope
+  {
+#pragma omp target parallel
+    ++a;
+  }
+#pragma omp scope
+  {
+#pragma omp target parallel for
+  for (int i = 0; i < 10; ++i)
+    ;
+  }
+#pragma omp scope
+  {
+#pragma omp target enter data map(to: a)
+    ++a;
+  }
+#pragma omp scope
+  {
+#pragma omp target exit data map(from: a)
+    ++a;
+  }
+#pragma omp scope
+  {
+#pragma omp taskloop
+  for (int i = 0; i < 10; ++i)
+    ++a;
+  }
+#pragma omp scope
+  {
+#pragma omp target // OK
+    a++;
+  }
+#pragma omp scope
+  {
+#pragma omp teams // expected-error {{region cannot be closely nested inside 'scope' region; perhaps you forget to enclose 'omp teams' directive into a target region?}}
+    a++;
+  }
+#pragma omp scope
+  {
+#pragma omp target teams // OK
+    a++;
+  }
+#pragma omp scope
+  {
+#pragma omp distribute // expected-error {{region cannot be closely nested inside 'scope' region; perhaps you forget to enclose 'omp distribute' directive into a teams region?}}
+    for (int i = 0; i < 10; ++i)
+      ;
+  }
+ #pragma omp scope
+   {
+ #pragma omp distribute parallel for simd // expected-error {{region cannot be closely nested inside 'scope' region; perhaps you forget to enclose 'omp distribute parallel for simd' directive into a teams region?}}
+     for (int i = 0; i < 10; ++i)
+       ;
+   }
+#pragma omp scope
+  {
+#pragma omp distribute simd // expected-error {{region cannot be closely nested inside 'scope' region; perhaps you forget to enclose 'omp distribute simd' directive into a teams region?}}
+    for (int i = 0; i < 10; ++i)
+      ;
+  }
+#pragma omp scope
+  {
+#pragma omp target simd // OK
+    for (int i = 0; i < 10; ++i)
+      ;
+  }
+#pragma omp scope
+   {
+ #pragma omp teams distribute // expected-error {{region cannot be closely nested inside 'scope' region; perhaps you forget to enclose 'omp teams distribute' directive into a target region?}}
+     for (int i = 0; i < 10; ++i)
+       ;
+   }
+#pragma omp scope
+  {
+#pragma omp teams distribute simd // expected-error {{region cannot be closely nested inside 'scope' region; perhaps you forget to enclose 'omp teams distribute simd' directive into a target region?}}
+    for (int i = 0; i < 10; ++i)
+      ;
+  }
+#pragma omp scope
+  {
+#pragma omp teams distribute parallel for simd // expected-error {{region cannot be closely nested inside 'scope' region; perhaps you forget to enclose 'omp teams distribute parallel for simd' directive into a target region?}}
+    for (int i = 0; i < 10; ++i)
+      ;
+  }
+#pragma omp scope
+  {
+#pragma omp teams distribute parallel for // expected-error {{region cannot be closely nested inside 'scope' region; perhaps you forget to enclose 'omp teams distribute parallel for' directive into a target region?}}
+    for (int i = 0; i < 10; ++i)
+      ;
+  }
+#pragma omp scope
+  {
+#pragma omp target teams // OK
+    ++a;
+  }
+#pragma omp scope
+  {
+#pragma omp target teams distribute // OK
+    for (int i = 0; i < 10; ++i)
+      ;
+  }
+#pragma omp scope
+  {
+#pragma omp target teams distribute parallel for // OK
+    for (int i = 0; i < 10; ++i)
+      ;
+  }
+#pragma omp scope
+  {
+#pragma omp target teams distribute parallel for simd // OK
+    for (int i = 0; i < 10; ++i)
+      ;
+  }
+#pragma omp scope
+  {
+#pragma omp target teams distribute simd // OK
+    for (int i = 0; i < 10; ++i)
+      ;
+  }
+#pragma omp for
+  for (int i = 0; i < 10; ++i) {
+#pragma omp scope // expected-error {{region cannot be closely nested inside 'for' region}}
+    bar();
+  }
+
+#pragma omp for simd
+  for (int i = 0; i < 10; ++i) {
+#pragma omp scope // expected-error {{OpenMP constructs may not be nested inside a simd region}}
+    bar();
+  }
+
+#pragma omp sections
+  {
+#pragma omp scope // expected-error {{region cannot be closely nested inside 'sections' region}}
+    bar();
+  }
+
+#pragma omp sections
+  {
+#pragma omp section
+    {
+#pragma omp scope // expected-error {{region cannot be closely nested inside 'section' region}}
+      bar();
+    }
+  }
+
+#pragma omp single
+  {
+#pragma omp scope // expected-error {{region cannot be closely nested inside 'single' region}}
+    bar();
+  }
+
+#pragma omp master
+  {
+#pragma omp scope // expected-error {{region cannot be closely nested inside 'master' region}}
+    bar();
+  }
+
+#pragma omp critical
+  {
+#pragma omp scope // expected-error {{region cannot be closely nested inside 'critical' region}}
+    bar();
+  }
+
+#pragma omp parallel for
+  for (int i = 0; i < 10; ++i) {
+#pragma omp scope // expected-error {{region cannot be closely nested inside 'parallel for' region}}
+    bar();
+  }
+
+#pragma omp parallel for simd
+  for (int i = 0; i < 10; ++i) {
+#pragma omp scope // expected-error {{OpenMP constructs may not be nested inside a simd region}}
+    bar();
+  }
+
+#pragma omp parallel master
+  {
+#pragma omp scope // expected-error {{region cannot be closely nested inside 'parallel master' region}}
+    bar();
+  }
+
+#pragma omp parallel sections
+  {
+#pragma omp scope // expected-error {{region cannot be closely nested inside 'parallel sections' region}}
+    bar();
+  }
+
+#pragma omp task
+  {
+#pragma omp scope // expected-error {{region cannot be closely nested inside 'task' region}}
+    bar();
+  }
+
+#pragma omp ordered
+  {
+#pragma omp scope // expected-error {{region cannot be closely nested inside 'ordered' region}}
+    bar();
+  }
+
+#pragma omp atomic
+  // expected-error@+2 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an lvalue expression with scalar type}}
+  // expected-note@+1 {{expected an expression statement}}
+  {
+#pragma omp scope // expected-error {{OpenMP constructs may not be nested inside an atomic region}}
+    bar();
+  }
+
+#pragma omp target
+#pragma omp teams
+  {
+#pragma omp scope // expected-error {{region cannot be closely nested inside 'teams' region; perhaps you forget to enclose 'omp scope' directive into a parallel region?}}
+    bar();
+  }
+
+#pragma omp taskloop
+  for (int i = 0; i < 10; ++i) {
+#pragma omp scope // expected-error {{region cannot be closely nested inside 'taskloop' region}}
+    bar();
+  }
+
+#pragma omp target
+#pragma omp teams
+#pragma omp distribute parallel for
+  for (int i = 0; i < 10; ++i) {
+#pragma omp scope // expected-error {{region cannot be closely nested inside 'distribute parallel for' region}}
+    bar();
+  }
+
+#pragma omp target
+#pragma omp teams
+#pragma omp distribute parallel for simd
+  for (int i = 0; i < 10; ++i) {
+#pragma omp scope // expected-error {{OpenMP constructs may not be nested inside a simd region}}
+    bar();
+  }
+
+#pragma omp target simd
+  for (int i = 0; i < 10; ++i) {
+#pragma omp scope // expected-error {{OpenMP constructs may not be nested inside a simd region}}
+    bar();
+  }
+
+#pragma omp target
+#pragma omp teams distribute simd
+  for (int i = 0; i < 10; ++i) {
+#pragma omp scope // expected-error {{OpenMP constructs may not be nested inside a simd region}}
+    bar();
+  }
+
+#pragma omp target
+#pragma omp teams distribute parallel for simd
+  for (int i = 0; i < 10; ++i) {
+#pragma omp scope // expected-error {{OpenMP constructs may not be nested inside a simd region}}
+    bar();
+  }
+
+#pragma omp target
+#pragma omp teams distribute parallel for
+  for (int i = 0; i < 10; ++i) {
+#pragma omp scope // expected-error {{region cannot be closely nested inside 'teams distribute parallel for' region}}
+    bar();
+  }
+
+#pragma omp target teams
+  {
+#pragma omp scope // expected-error {{region cannot be closely nested inside 'target teams' region; perhaps you forget to enclose 'omp scope' directive into a parallel region?}}
+    bar();
+  }
+
+#pragma omp target teams distribute parallel for
+  for (int i = 0; i < 10; ++i) {
+#pragma omp scope // expected-error {{region cannot be closely nested inside 'target teams distribute parallel for' region}}
+    bar();
+  }
+
+#pragma omp target teams distribute parallel for simd
+  for (int i = 0; i < 10; ++i) {
+#pragma omp scope // expected-error {{OpenMP constructs may not be nested inside a simd region}}
+    bar();
+  }
+
+#pragma omp target teams distribute simd
+  for (int i = 0; i < 10; ++i) {
+#pragma omp scope // 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 scope // expected-error {{OpenMP constructs may not be nested inside a simd region}}
+    bar();
+  }
+
   return foo<int>();
 }
 

clang/test/OpenMP/scope_ast_print.cpp

+//RUN: %clang_cc1 -triple x86_64-pc-linux-gnu\
+//RUN:   -fopenmp -fopenmp-version=51 \
+//RUN:   -x c++ -std=c++14 -fexceptions -fcxx-exceptions                   \
+//RUN:   -Wno-source-uses-openmp -Wno-openmp-clauses                       \
+//RUN:   -ast-print %s | FileCheck %s --check-prefix=PRINT
+
+//RUN: %clang_cc1 -triple x86_64-pc-linux-gnu\
+//RUN:   -fopenmp -fopenmp-version=51 \
+//RUN:   -x c++ -std=c++14 -fexceptions -fcxx-exceptions                   \
+//RUN:   -Wno-source-uses-openmp -Wno-openmp-clauses                       \
+//RUN:   -ast-dump %s | FileCheck %s --check-prefix=DUMP
+
+//RUN: %clang_cc1 -triple x86_64-pc-linux-gnu\
+//RUN:   -fopenmp -fopenmp-version=51 \
+//RUN:   -x c++ -std=c++14 -fexceptions -fcxx-exceptions                   \
+//RUN:   -Wno-source-uses-openmp -Wno-openmp-clauses                       \
+//RUN:   -emit-pch -o %t %s
+
+//RUN: %clang_cc1 -triple x86_64-pc-linux-gnu\
+//RUN:   -fopenmp -fopenmp-version=51 \
+//RUN:   -x c++ -std=c++14 -fexceptions -fcxx-exceptions                   \
+//RUN:   -Wno-source-uses-openmp -Wno-openmp-clauses                       \
+//RUN:   -include-pch %t -ast-print %s | FileCheck %s --check-prefix=PRINT
+
+//RUN: %clang_cc1 -triple x86_64-pc-linux-gnu\
+//RUN:   -fopenmp -fopenmp-version=51 \
+//RUN:   -x c++ -std=c++14 -fexceptions -fcxx-exceptions                   \
+//RUN:   -Wno-source-uses-openmp -Wno-openmp-clauses                       \
+//RUN:   -include-pch %t -ast-dump-all %s | FileCheck %s --check-prefix=DUMP
+
+#ifndef HEADER
+#define HEADER
+int foo1() {
+  int a;
+  int i = 1;
+  #pragma omp scope private(a) reduction(+:i) nowait
+  { 
+    a = 123; 
+    ++i; 
+  }
+  return i;
+}
+
+//DUMP: FunctionDecl {{.*}}foo1 'int ()'
+//DUMP: OMPScopeDirective
+//DUMP: OMPPrivateClause
+//DUMP: DeclRefExpr {{.*}}'int' lvalue Var{{.*}}'a' 'int'
+//DUMP: OMPReductionClause
+//DUMP: DeclRefExpr {{.*}}'int' lvalue Var{{.*}}'i' 'int'
+//DUMP: OMPNowaitClause
+//PRINT: #pragma omp scope private(a) reduction(+: i) nowait
+
+template <typename T>
+T run() {
+  T a;
+  T b;
+
+  #pragma omp scope private(a) reduction(*:b)
+  { 
+    b *= a; 
+  }
+  return b;
+}
+
+int template_test() {
+  double d;
+  d = run<double>();
+  return 0;
+}
+
+//DUMP: FunctionTemplateDecl {{.*}}run
+//DUMP: TemplateTypeParmDecl {{.*}}referenced typename depth 0 index 0 T
+//DUMP: FunctionDecl {{.*}}run 'T ()'
+//DUMP: OMPScopeDirective
+//DUMP: OMPPrivateClause
+//DUMP: DeclRefExpr {{.*}}'T' lvalue Var {{.*}} 'a' 'T'
+//DUMP: OMPReductionClause
+//DUMP: DeclRefExpr {{.*}}'T' lvalue Var {{.*}} 'b' 'T'
+//DUMP: FunctionDecl {{.*}}used run 'double ()'
+//DUMP: TemplateArgument type 'double'
+//DUMP: BuiltinType {{.*}}'double'
+//DUMP: OMPScopeDirective
+//DUMP: OMPPrivateClause
+//DUMP: DeclRefExpr {{.*}}'double':'double' lvalue Var {{.*}} 'a' 'double':'double'
+//DUMP: OMPReductionClause
+//DUMP: DeclRefExpr {{.*}}'double':'double' lvalue Var {{.*}} 'b' 'double':'double'
+//PRINT: #pragma omp scope private(a) reduction(*: b)
+#endif // HEADER

clang/test/OpenMP/scope_messages.cpp

+// RUN: %clang_cc1 -fopenmp -fopenmp-version=51 %s -verify=expected,omp51
+// RUN: %clang_cc1 -fopenmp -fopenmp-version=51 %s -verify=expected,omp51
+
+void test1()
+{
+  int var1;
+  int var2;
+  int var3 = 1;
+
+  // expected-error@+1 {{directive '#pragma omp scope' cannot contain more than one 'nowait' clause}} //omp51-error@+1{{unexpected OpenMP clause 'firstprivate' in directive '#pragma omp scope'}}
+  #pragma omp scope private(var1) firstprivate(var3) nowait nowait
+  { var1 = 123; ++var2; var3 = 2;}
+}

clang/tools/libclang/CIndex.cpp

CXString clang_getCursorKindSpelling(enum CXCursorKind Kind) {
   case CXCursor_OMPForDirective:
     return cxstring::createRef("OMPForDirective");
   case CXCursor_OMPForSimdDirective:
     return cxstring::createRef("OMPForSimdDirective");
   case CXCursor_OMPSectionsDirective:
     return cxstring::createRef("OMPSectionsDirective");
   case CXCursor_OMPSectionDirective:
     return cxstring::createRef("OMPSectionDirective");
+  case CXCursor_OMPScopeDirective:
+    return cxstring::createRef("OMPScopeDirective");
   case CXCursor_OMPSingleDirective:
     return cxstring::createRef("OMPSingleDirective");
   case CXCursor_OMPMasterDirective:
     return cxstring::createRef("OMPMasterDirective");
   case CXCursor_OMPCriticalDirective:
     return cxstring::createRef("OMPCriticalDirective");
   case CXCursor_OMPParallelForDirective:
     return cxstring::createRef("OMPParallelForDirective");

clang/tools/libclang/CXCursor.cpp

case Stmt::OMPForSimdDirectiveClass:
     K = CXCursor_OMPForSimdDirective;
     break;
   case Stmt::OMPSectionsDirectiveClass:
     K = CXCursor_OMPSectionsDirective;
     break;
   case Stmt::OMPSectionDirectiveClass:
     K = CXCursor_OMPSectionDirective;
     break;
+  case Stmt::OMPScopeDirectiveClass:
+    K = CXCursor_OMPScopeDirective;
+    break;
   case Stmt::OMPSingleDirectiveClass:
     K = CXCursor_OMPSingleDirective;
     break;
   case Stmt::OMPMasterDirectiveClass:
     K = CXCursor_OMPMasterDirective;
     break;
   case Stmt::OMPCriticalDirectiveClass:
     K = CXCursor_OMPCriticalDirective;

llvm/include/llvm/Frontend/OpenMP/OMP.td

let allowedClauses = [
     VersionedClause<OMPC_Exclusive, 50>
   ];
 }
 def OMP_Assumes : Directive<"assumes"> {}
 def OMP_BeginAssumes : Directive<"begin assumes"> {}
 def OMP_EndAssumes : Directive<"end assumes"> {}
 def OMP_BeginDeclareVariant : Directive<"begin declare variant"> {}
 def OMP_EndDeclareVariant : Directive<"end declare variant"> {}
+def OMP_scope : Directive<"scope"> {
+  let allowedClauses = [
+    VersionedClause<OMPC_Private, 51>,
+    VersionedClause<OMPC_Reduction, 51>,
+  ];
+  let allowedOnceClauses = [
+    VersionedClause<OMPC_NoWait, 51>
+  ];
+}
 def OMP_ParallelWorkshare : Directive<"parallel workshare"> {
   let allowedClauses = [
     VersionedClause<OMPC_Allocate>,
     VersionedClause<OMPC_Copyin>,
     VersionedClause<OMPC_Default>,
     VersionedClause<OMPC_FirstPrivate>,
     VersionedClause<OMPC_Private>,
     VersionedClause<OMPC_Reduction>,