[OpenMP51] Initial support for masked directive and filter clause

[cchen]

Summary

Adds basic parsing/sema/serialization support for the #pragma omp masked
directive.

[cchen]

Fix comments

[ABataev]

marked->masked

clang/include/clang/AST/OpenMPClause.h

8244

condition?

8270–8272

Make it private

clang/lib/Parse/ParseOpenMP.cpp

2955–2957

Why you did not put it to the case with num_threads etc. clauses?

clang/lib/Sema/SemaOpenMP.cpp

4727–4728

Update a reference/text here

4761–4779

Sam, update text

clang/test/OpenMP/masked_ast_print.cpp

27

nonconst threadid tests?

[cchen]

Rebase and fix based on comments.

[ABataev]

clang/lib/Parse/ParseOpenMP.cpp

2813

This can be simplified like this:

    if (!FirstClause) {
      Diag(Tok, diag::err_omp_more_one_clause)
          << getOpenMPDirectiveName(DKind) << getOpenMPClauseName(CKind) << 0;
      ErrorFound = true;
    }
    LLVM_FALLTHROUGH;
case OMPC_filter:

Plus, I think, you should not exclude OMPC_filter from the check, I think only single clause is allowed by the spec.

[cchen]

clang/lib/Parse/ParseOpenMP.cpp

2813

I misunderstood the syntax and will fix this and the tests, thanks!

[cchen]

Fix/Add test for "can not have more than one filter clause" issue and rebase.

[ABataev]

LG

[cchen]

Fix lit-test failure for dispatch_ast_print and rebase

clang/include/clang-c/Index.h

enum CXCursorKind {
   /** OpenMP interop directive.
    */
   CXCursor_OMPInteropDirective = 290,
 
   /** OpenMP dispatch directive.
    */
   CXCursor_OMPDispatchDirective = 291,
 
-  CXCursor_LastStmt = CXCursor_OMPDispatchDirective,
+  /** OpenMP mask directive.
+   */
+  CXCursor_OMPMaskedDirective = 292,
+
+  CXCursor_LastStmt = CXCursor_OMPMaskedDirective,
 
   /**
    * 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 = 300,

clang/include/clang/AST/OpenMPClause.h

const_child_range used_children() const {
     return const_child_range(const_child_iterator(), const_child_iterator());
   }
 
   static bool classof(const OMPClause *T) {
     return T->getClauseKind() == llvm::omp::OMPC_affinity;
   }
 };
 
+/// This represents 'filter' clause in the '#pragma omp ...' directive.
+///
+/// \code
+/// #pragma omp masked filter(tid)
+/// \endcode
+/// In this example directive '#pragma omp masked' has 'filter' clause with
+/// thread id.
+class OMPFilterClause final : public OMPClause, public OMPClauseWithPreInit {
+  friend class OMPClauseReader;
+
+  /// Location of '('.
+  SourceLocation LParenLoc;
+
+  /// Express of the 'filter' clause.
+  Stmt *ThreadID = nullptr;
+
+  /// Set condition.
+  void setThreadID(Expr *TID) { ThreadID = TID; }
+
+public:
+  /// Build 'filter' clause with thread-id \a ThreadID.
+  ///
+  /// \param ThreadID Thread identifier.
+  /// \param HelperE Helper expression associated with this clause.
+  /// \param CaptureRegion Innermost OpenMP region where expressions in this
+  /// clause must be captured.
+  /// \param StartLoc Starting location of the clause.
+  /// \param LParenLoc Location of '('.
+  /// \param EndLoc Ending location of the clause.
+  OMPFilterClause(Expr *ThreadID, Stmt *HelperE,
+                  OpenMPDirectiveKind CaptureRegion, SourceLocation StartLoc,
+                  SourceLocation LParenLoc, SourceLocation EndLoc)
+      : OMPClause(llvm::omp::OMPC_filter, StartLoc, EndLoc),
+        OMPClauseWithPreInit(this), LParenLoc(LParenLoc), ThreadID(ThreadID) {
+    setPreInitStmt(HelperE, CaptureRegion);
+  }
+
+  /// Build an empty clause.
+  OMPFilterClause()
+      : OMPClause(llvm::omp::OMPC_filter, SourceLocation(), SourceLocation()),
+        OMPClauseWithPreInit(this) {}
+
+  /// Sets the location of '('.
+  void setLParenLoc(SourceLocation Loc) { LParenLoc = Loc; }
+
+  /// Returns the location of '('.
+  SourceLocation getLParenLoc() const { return LParenLoc; }
+
+  /// Return thread identifier.
+  Expr *getThreadID() { return cast<Expr>(ThreadID); }
+
+  /// Return thread identifier.
+  Expr *getThreadID() const { return cast<Expr>(ThreadID); }
+
+  child_range children() { return child_range(&ThreadID, &ThreadID + 1); }
+
+  const_child_range children() const {
+    return const_child_range(&ThreadID, &ThreadID + 1);
+  }
+
+  child_range used_children() {
+    return child_range(child_iterator(), child_iterator());
+  }
+  const_child_range used_children() const {
+    return const_child_range(const_child_iterator(), const_child_iterator());
+  }
+
+  static bool classof(const OMPClause *T) {
+    return T->getClauseKind() == llvm::omp::OMPC_filter;
+  }
+};
+
 /// This class implements a simple visitor for OMPClause
 /// subclasses.
 template<class ImplClass, template <typename> class Ptr, typename RetTy>
 class OMPClauseVisitorBase {
 public:
 #define PTR(CLASS) Ptr<CLASS>
 #define DISPATCH(CLASS) \
   return static_cast<ImplClass*>(this)->Visit##CLASS(static_cast<PTR(CLASS)>(S))

clang/include/clang/AST/RecursiveASTVisitor.h

DEF_TRAVERSE_STMT(OMPTargetTeamsDistributeSimdDirective,
                   { TRY_TO(TraverseOMPExecutableDirective(S)); })
 
 DEF_TRAVERSE_STMT(OMPInteropDirective,
                   { TRY_TO(TraverseOMPExecutableDirective(S)); })
 
 DEF_TRAVERSE_STMT(OMPDispatchDirective,
                   { TRY_TO(TraverseOMPExecutableDirective(S)); })
 
+DEF_TRAVERSE_STMT(OMPMaskedDirective,
+                  { TRY_TO(TraverseOMPExecutableDirective(S)); })
+
 // OpenMP clauses.
 template <typename Derived>
 bool RecursiveASTVisitor<Derived>::TraverseOMPClause(OMPClause *C) {
   if (!C)
     return true;
   switch (C->getClauseKind()) {
 #define GEN_CLANG_CLAUSE_CLASS
 #define CLAUSE_CLASS(Enum, Str, Class)                                         \

 bool RecursiveASTVisitor<Derived>::VisitOMPAffinityClause(
     OMPAffinityClause *C) {
   TRY_TO(TraverseStmt(C->getModifier()));
   for (Expr *E : C->varlists())
     TRY_TO(TraverseStmt(E));
   return true;
 }
 
+template <typename Derived>
+bool RecursiveASTVisitor<Derived>::VisitOMPFilterClause(OMPFilterClause *C) {
+  TRY_TO(VisitOMPClauseWithPreInit(C));
+  TRY_TO(TraverseStmt(C->getThreadID()));
+  return true;
+}
+
 // FIXME: look at the following tricky-seeming exprs to see if we
 // need to recurse on anything.  These are ones that have methods
 // returning decls or qualtypes or nestednamespecifier -- though I'm
 // not sure if they own them -- or just seemed very complicated, or
 // had lots of sub-types to explore.
 //
 // VisitOverloadExpr and its children: recurse on template args? etc?
 

clang/include/clang/AST/StmtOpenMP.h

public:
   /// Return location of target-call.
   SourceLocation getTargetCallLoc() const { return TargetCallLoc; }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == OMPDispatchDirectiveClass;
   }
 };
 
+/// this represents '#pragma omp masked' directive.
+/// \code
+/// #pragma omp masked filter(tid)
+/// \endcode
+/// This example shows a directive '#pragma omp masked' with a filter clause
+/// with variable 'tid'.
+class OMPMaskedDirective 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.
+  ///
+  OMPMaskedDirective(SourceLocation StartLoc, SourceLocation EndLoc)
+      : OMPExecutableDirective(OMPMaskedDirectiveClass, llvm::omp::OMPD_masked,
+                               StartLoc, EndLoc) {}
+
+  /// Build an empty directive.
+  ///
+  explicit OMPMaskedDirective()
+      : OMPExecutableDirective(OMPMaskedDirectiveClass, llvm::omp::OMPD_masked,
+                               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 OMPMaskedDirective *
+  Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
+         ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt);
+
+  /// Creates an empty directive.
+  ///
+  /// \param C AST context.
+  ///
+  static OMPMaskedDirective *CreateEmpty(const ASTContext &C,
+                                         unsigned NumClauses, EmptyShell);
+
+  static bool classof(const Stmt *T) {
+    return T->getStmtClass() == OMPMaskedDirectiveClass;
+  }
+};
+
 } // end namespace clang
 
 #endif

clang/include/clang/Basic/StmtNodes.td

 def OMPTeamsDistributeParallelForDirective : StmtNode<OMPLoopDirective>;
 def OMPTargetTeamsDirective : StmtNode<OMPExecutableDirective>;
 def OMPTargetTeamsDistributeDirective : StmtNode<OMPLoopDirective>;
 def OMPTargetTeamsDistributeParallelForDirective : StmtNode<OMPLoopDirective>;
 def OMPTargetTeamsDistributeParallelForSimdDirective : StmtNode<OMPLoopDirective>;
 def OMPTargetTeamsDistributeSimdDirective : StmtNode<OMPLoopDirective>;
 def OMPInteropDirective : StmtNode<OMPExecutableDirective>;
 def OMPDispatchDirective : StmtNode<OMPExecutableDirective>;
+def OMPMaskedDirective : StmtNode<OMPExecutableDirective>;

clang/include/clang/Sema/Sema.h

public:
   StmtResult ActOnOpenMPInteropDirective(ArrayRef<OMPClause *> Clauses,
                                          SourceLocation StartLoc,
                                          SourceLocation EndLoc);
   /// Called on well-formed '\#pragma omp dispatch' after parsing of the
   // /associated statement.
   StmtResult ActOnOpenMPDispatchDirective(ArrayRef<OMPClause *> Clauses,
                                           Stmt *AStmt, SourceLocation StartLoc,
                                           SourceLocation EndLoc);
+  /// Called on well-formed '\#pragma omp masked' after parsing of the
+  // /associated statement.
+  StmtResult ActOnOpenMPMaskedDirective(ArrayRef<OMPClause *> Clauses,
+                                        Stmt *AStmt, SourceLocation StartLoc,
+                                        SourceLocation EndLoc);
 
   /// Checks correctness of linear modifiers.
   bool CheckOpenMPLinearModifier(OpenMPLinearClauseKind LinKind,
                                  SourceLocation LinLoc);
   /// Checks that the specified declaration matches requirements for the linear
   /// decls.
   bool CheckOpenMPLinearDecl(const ValueDecl *D, SourceLocation ELoc,
                              OpenMPLinearClauseKind LinKind, QualType Type,
OMPClause *ActOnOpenMPNovariantsClause(Expr *Condition,
                                          SourceLocation StartLoc,
                                          SourceLocation LParenLoc,
                                          SourceLocation EndLoc);
   /// Called on well-formed 'nocontext' clause.
   OMPClause *ActOnOpenMPNocontextClause(Expr *Condition,
                                         SourceLocation StartLoc,
                                         SourceLocation LParenLoc,
                                         SourceLocation EndLoc);
+  OMPClause *ActOnOpenMPFilterClause(Expr *ThreadID, SourceLocation StartLoc,
+                                     SourceLocation LParenLoc,
+                                     SourceLocation EndLoc);
   /// Called on well-formed 'threads' clause.
   OMPClause *ActOnOpenMPThreadsClause(SourceLocation StartLoc,
                                       SourceLocation EndLoc);
   /// Called on well-formed 'simd' clause.
   OMPClause *ActOnOpenMPSIMDClause(SourceLocation StartLoc,
                                    SourceLocation EndLoc);
   /// Called on well-formed 'nogroup' clause.
   OMPClause *ActOnOpenMPNogroupClause(SourceLocation StartLoc,

clang/include/clang/Serialization/ASTBitCodes.h

enum StmtCode {
   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_INTEROP_DIRECTIVE,
   STMT_OMP_DISPATCH_DIRECTIVE,
+  STMT_OMP_MASKED_DIRECTIVE,
   EXPR_OMP_ARRAY_SECTION,
   EXPR_OMP_ARRAY_SHAPING,
   EXPR_OMP_ITERATOR,
 
   // ARC
   EXPR_OBJC_BRIDGED_CAST, // ObjCBridgedCastExpr
 
   STMT_MS_DEPENDENT_EXISTS, // MSDependentExistsStmt

clang/lib/AST/OpenMPClause.cpp

const OMPClauseWithPreInit *OMPClauseWithPreInit::get(const OMPClause *C) {
   case OMPC_final:
     return static_cast<const OMPFinalClause *>(C);
   case OMPC_priority:
     return static_cast<const OMPPriorityClause *>(C);
   case OMPC_novariants:
     return static_cast<const OMPNovariantsClause *>(C);
   case OMPC_nocontext:
     return static_cast<const OMPNocontextClause *>(C);
+  case OMPC_filter:
+    return static_cast<const OMPFilterClause *>(C);
   case OMPC_default:
   case OMPC_proc_bind:
   case OMPC_safelen:
   case OMPC_simdlen:
   case OMPC_sizes:
   case OMPC_allocator:
   case OMPC_allocate:
   case OMPC_collapse:
if (Expr *Modifier = Node->getModifier()) {
     Modifier->printPretty(OS, nullptr, Policy);
     OS << " :";
     StartSym = ' ';
   }
   VisitOMPClauseList(Node, StartSym);
   OS << ")";
 }
 
+void OMPClausePrinter::VisitOMPFilterClause(OMPFilterClause *Node) {
+  OS << "filter(";
+  Node->getThreadID()->printPretty(OS, nullptr, Policy, 0);
+  OS << ")";
+}
+
 void OMPTraitInfo::getAsVariantMatchInfo(ASTContext &ASTCtx,
                                          VariantMatchInfo &VMI) const {
   for (const OMPTraitSet &Set : Sets) {
     for (const OMPTraitSelector &Selector : Set.Selectors) {
 
       // User conditions are special as we evaluate the condition here.
       if (Selector.Kind == TraitSelector::user_condition) {
         assert(Selector.ScoreOrCondition &&

clang/lib/AST/StmtOpenMP.cpp

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

clang/lib/AST/StmtPrinter.cpp

void StmtPrinter::VisitOMPInteropDirective(OMPInteropDirective *Node) {
   PrintOMPExecutableDirective(Node);
 }
 
 void StmtPrinter::VisitOMPDispatchDirective(OMPDispatchDirective *Node) {
   Indent() << "#pragma omp dispatch";
   PrintOMPExecutableDirective(Node);
 }
 
+void StmtPrinter::VisitOMPMaskedDirective(OMPMaskedDirective *Node) {
+  Indent() << "#pragma omp masked";
+  PrintOMPExecutableDirective(Node);
+}
+
 //===----------------------------------------------------------------------===//
 //  Expr printing methods.
 //===----------------------------------------------------------------------===//
 
 void StmtPrinter::VisitSourceLocExpr(SourceLocExpr *Node) {
   OS << Node->getBuiltinStr() << "()";
 }
 

clang/lib/AST/StmtProfile.cpp

if (C->getInteropVar())
     Profiler->VisitStmt(C->getInteropVar());
 }
 
 void OMPClauseProfiler::VisitOMPDestroyClause(const OMPDestroyClause *C) {
   if (C->getInteropVar())
     Profiler->VisitStmt(C->getInteropVar());
 }
 
+void OMPClauseProfiler::VisitOMPFilterClause(const OMPFilterClause *C) {
+  VistOMPClauseWithPreInit(C);
+  if (C->getThreadID())
+    Profiler->VisitStmt(C->getThreadID());
+}
+
 template<typename T>
 void OMPClauseProfiler::VisitOMPClauseList(T *Node) {
   for (auto *E : Node->varlists()) {
     if (E)
       Profiler->VisitStmt(E);
   }
 }
 

 void StmtProfiler::VisitOMPInteropDirective(const OMPInteropDirective *S) {
   VisitOMPExecutableDirective(S);
 }
 
 void StmtProfiler::VisitOMPDispatchDirective(const OMPDispatchDirective *S) {
   VisitOMPExecutableDirective(S);
 }
 
+void StmtProfiler::VisitOMPMaskedDirective(const OMPMaskedDirective *S) {
+  VisitOMPExecutableDirective(S);
+}
+
 void StmtProfiler::VisitExpr(const Expr *S) {
   VisitStmt(S);
 }
 
 void StmtProfiler::VisitConstantExpr(const ConstantExpr *S) {
   VisitExpr(S);
 }
 

clang/lib/CodeGen/CGStmt.cpp

case Stmt::OMPTargetTeamsDistributeSimdDirectiveClass:
     EmitOMPTargetTeamsDistributeSimdDirective(
         cast<OMPTargetTeamsDistributeSimdDirective>(*S));
     break;
   case Stmt::OMPInteropDirectiveClass:
     llvm_unreachable("Interop directive not supported yet.");
     break;
   case Stmt::OMPDispatchDirectiveClass:
     llvm_unreachable("Dispatch directive not supported yet.");
+  case Stmt::OMPMaskedDirectiveClass:
+    llvm_unreachable("Masked directive not supported yet.");
     break;
   }
 }
 
 bool CodeGenFunction::EmitSimpleStmt(const Stmt *S,
                                      ArrayRef<const Attr *> Attrs) {
   switch (S->getStmtClass()) {
   default:

clang/lib/CodeGen/CGStmtOpenMP.cpp

static void emitOMPAtomicExpr(CodeGenFunction &CGF, OpenMPClauseKind Kind,
   case OMPC_affinity:
   case OMPC_init:
   case OMPC_inbranch:
   case OMPC_notinbranch:
   case OMPC_link:
   case OMPC_use:
   case OMPC_novariants:
   case OMPC_nocontext:
+  case OMPC_filter:
     llvm_unreachable("Clause is not allowed in 'omp atomic'.");
   }
 }
 
 void CodeGenFunction::EmitOMPAtomicDirective(const OMPAtomicDirective &S) {
   llvm::AtomicOrdering AO = llvm::AtomicOrdering::Monotonic;
   bool MemOrderingSpecified = false;
   if (S.getSingleClause<OMPSeqCstClause>()) {

clang/lib/Parse/ParseOpenMP.cpp

Parser::DeclGroupPtrTy Parser::ParseOpenMPDeclarativeDirectiveWithExtDecl(
   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:
   case OMPD_target_teams_distribute_simd:
   case OMPD_dispatch:
+  case OMPD_masked:
     Diag(Tok, diag::err_omp_unexpected_directive)
         << 1 << getOpenMPDirectiveName(DKind);
     break;
   default:
     break;
   }
   while (Tok.isNot(tok::annot_pragma_openmp_end))
     ConsumeAnyToken();

 ///         taskloop' | 'parallel master taskloop simd' | 'distribute' | 'target
 ///         enter data' | 'target exit data' | 'target parallel' | 'target
 ///         parallel for' | 'target update' | 'distribute parallel for' |
 ///         'distribute paralle for simd' | 'distribute simd' | 'target parallel
 ///         for simd' | 'target simd' | 'teams distribute' | 'teams distribute
 ///         simd' | 'teams distribute parallel for simd' | 'teams distribute
 ///         parallel for' | 'target teams' | 'target teams distribute' | 'target
 ///         teams distribute parallel for' | 'target teams distribute parallel
-///         for simd' | 'target teams distribute simd' {clause}
+///         for simd' | 'target teams distribute simd' | 'masked' {clause}
 ///         annot_pragma_openmp_end
 ///
 StmtResult
 Parser::ParseOpenMPDeclarativeOrExecutableDirective(ParsedStmtContext StmtCtx) {
   assert(Tok.is(tok::annot_pragma_openmp) && "Not an OpenMP directive!");
   ParsingOpenMPDirectiveRAII DirScope(*this);
   ParenBraceBracketBalancer BalancerRAIIObj(*this);
   SmallVector<OMPClause *, 5> Clauses;
Parser::ParseOpenMPDeclarativeOrExecutableDirective(ParsedStmtContext StmtCtx) {
   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:
   case OMPD_target_teams_distribute_simd:
-  case OMPD_dispatch: {
+  case OMPD_dispatch:
+  case OMPD_masked: {
     // Special processing for flush and depobj clauses.
     Token ImplicitTok;
     bool ImplicitClauseAllowed = false;
     if (DKind == OMPD_flush || DKind == OMPD_depobj) {
       ImplicitTok = Tok;
       ImplicitClauseAllowed = true;
     }
     ConsumeToken();
case OMPC_nocontext:
     // OpenMP 5.1, 2.3.6 dispatch Construct, Restrictions.
     // At most one novariants clause can appear on a dispatch directive.
     // At most one nocontext clause can appear on a dispatch directive.
     if (!FirstClause) {
       Diag(Tok, diag::err_omp_more_one_clause)
           << getOpenMPDirectiveName(DKind) << getOpenMPClauseName(CKind) << 0;
       ErrorFound = true;
     }
 
     if (CKind == OMPC_ordered && PP.LookAhead(/*N=*/0).isNot(tok::l_paren))
       Clause = ParseOpenMPClause(CKind, WrongDirective);
     else
       Clause = ParseOpenMPSingleExprClause(CKind, WrongDirective);
     break;
   case OMPC_default:
   case OMPC_proc_bind:
   case OMPC_atomic_default_mem_order:
if (DKind != OMPD_interop) {
       Clause = ParseOpenMPClause(CKind, WrongDirective);
       break;
     }
     LLVM_FALLTHROUGH;
   case OMPC_init:
   case OMPC_use:
     Clause = ParseOpenMPInteropClause(CKind, WrongDirective);
     break;
+  case OMPC_filter:
+    Clause = ParseOpenMPSingleExprClause(CKind, WrongDirective);
+    break;
   case OMPC_device_type:
   case OMPC_unknown:
     skipUntilPragmaOpenMPEnd(DKind);
     break;
   case OMPC_threadprivate:
   case OMPC_uniform:
   case OMPC_match:
     if (!WrongDirective)

clang/lib/Sema/SemaOpenMP.cpp

class DSAAttrChecker final : public StmtVisitor<DSAAttrChecker, void> {
   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 ||
         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 ||
ActOnCapturedRegionStart(DSAStack->getConstructLoc(), CurScope, CR_OpenMP,
                              /*OpenMPCaptureLevel=*/1);
     break;
   }
   case OMPD_atomic:
   case OMPD_critical:
   case OMPD_section:
   case OMPD_master:
   case OMPD_tile:
+  case OMPD_masked:
     break;
   case OMPD_simd:
   case OMPD_for:
   case OMPD_for_simd:
   case OMPD_sections:
   case OMPD_single:
   case OMPD_taskgroup:
   case OMPD_distribute:
static bool checkOrderedOrderSpecified(Sema &S,
   return false;
 }
 
 StmtResult Sema::ActOnOpenMPRegionEnd(StmtResult S,
                                       ArrayRef<OMPClause *> Clauses) {
   if (DSAStack->getCurrentDirective() == OMPD_atomic ||
       DSAStack->getCurrentDirective() == OMPD_critical ||
       DSAStack->getCurrentDirective() == OMPD_section ||
-      DSAStack->getCurrentDirective() == OMPD_master)
+      DSAStack->getCurrentDirective() == OMPD_master ||
+      DSAStack->getCurrentDirective() == OMPD_masked)
     return S;
 
   bool ErrorFound = false;
   CaptureRegionUnwinderRAII CaptureRegionUnwinder(
       *this, ErrorFound, DSAStack->getCurrentDirective());
   if (!S.isUsable()) {
     ErrorFound = true;
     return StmtError();
if (CurrentRegion == OMPD_cancellation_point ||
               (SemaRef.getLangOpts().OpenMP >= 50 &&
                (ParentRegion == OMPD_taskloop ||
                 ParentRegion == OMPD_master_taskloop ||
                 ParentRegion == OMPD_parallel_master_taskloop)))) ||
             (CancelRegion == OMPD_sections &&
              (ParentRegion == OMPD_section || ParentRegion == OMPD_sections ||
               ParentRegion == OMPD_parallel_sections)));
       OrphanSeen = ParentRegion == OMPD_unknown;
-    } else if (CurrentRegion == OMPD_master) {
+    } else if (CurrentRegion == OMPD_master || CurrentRegion == OMPD_masked) {
       // OpenMP [2.16, Nesting of Regions]
       // A master region may not be closely nested inside a worksharing,
       // atomic, or explicit task region.
       NestingProhibited = isOpenMPWorksharingDirective(ParentRegion) ||
                           isOpenMPTaskingDirective(ParentRegion);
     } else if (CurrentRegion == OMPD_critical && CurrentName.getName()) {
       // OpenMP [2.16, Nesting of Regions]
       // A critical region may not be nested (closely or otherwise) inside a
       // critical region with the same name. Note that this restriction is not
       // sufficient to prevent deadlock.
       SourceLocation PreviousCriticalLoc;
if (CurrentRegion == OMPD_cancellation_point ||
           SemaRef.Diag(PreviousCriticalLoc,
                        diag::note_omp_previous_critical_region);
         return true;
       }
     } else if (CurrentRegion == OMPD_barrier) {
       // OpenMP [2.16, Nesting of Regions]
       // A barrier region may not be closely nested inside a worksharing,
       // explicit task, critical, ordered, atomic, or master region.
-      NestingProhibited = isOpenMPWorksharingDirective(ParentRegion) ||
-                          isOpenMPTaskingDirective(ParentRegion) ||
-                          ParentRegion == OMPD_master ||
-                          ParentRegion == OMPD_parallel_master ||
-                          ParentRegion == OMPD_critical ||
-                          ParentRegion == OMPD_ordered;
+      NestingProhibited =
+          isOpenMPWorksharingDirective(ParentRegion) ||
+          ParentRegion == OMPD_master || ParentRegion == OMPD_masked ||
+          ParentRegion == OMPD_critical || ParentRegion == OMPD_ordered;
     } else if (isOpenMPWorksharingDirective(CurrentRegion) &&
                !isOpenMPParallelDirective(CurrentRegion) &&
                !isOpenMPTeamsDirective(CurrentRegion)) {
       // OpenMP [2.16, Nesting of Regions]
       // A worksharing region may not be closely nested inside a worksharing,
       // explicit task, critical, ordered, atomic, or master region.
-      NestingProhibited = isOpenMPWorksharingDirective(ParentRegion) ||
-                          isOpenMPTaskingDirective(ParentRegion) ||
-                          ParentRegion == OMPD_master ||
-                          ParentRegion == OMPD_parallel_master ||
-                          ParentRegion == OMPD_critical ||
-                          ParentRegion == OMPD_ordered;
+      NestingProhibited =
+          isOpenMPWorksharingDirective(ParentRegion) ||
+          ParentRegion == OMPD_master || ParentRegion == OMPD_masked ||
+          ParentRegion == OMPD_critical || ParentRegion == OMPD_ordered;
       Recommend = ShouldBeInParallelRegion;
     } else if (CurrentRegion == OMPD_ordered) {
       // OpenMP [2.16, Nesting of Regions]
       // An ordered region may not be closely nested inside a critical,
       // atomic, or explicit task region.
       // An ordered region must be closely nested inside a loop region (or
       // parallel loop region) with an ordered clause.
       // OpenMP [2.8.1,simd Construct, Restrictions]
       // An ordered construct with the simd clause is the only OpenMP construct
if (checkCancelRegion(*this, Kind, CancelRegion, StartLoc) ||
     return StmtError();
 
   llvm::SmallVector<OMPClause *, 8> ClausesWithImplicit;
   VarsWithInheritedDSAType VarsWithInheritedDSA;
   bool ErrorFound = false;
   ClausesWithImplicit.append(Clauses.begin(), Clauses.end());
   if (AStmt && !CurContext->isDependentContext() && Kind != OMPD_atomic &&
       Kind != OMPD_critical && Kind != OMPD_section && Kind != OMPD_master &&
-      !isOpenMPLoopTransformationDirective(Kind)) {
+      Kind != OMPD_masked && !isOpenMPLoopTransformationDirective(Kind)) {
     assert(isa<CapturedStmt>(AStmt) && "Captured statement expected");
 
     // Check default data sharing attributes for referenced variables.
     DSAAttrChecker DSAChecker(DSAStack, *this, cast<CapturedStmt>(AStmt));
     int ThisCaptureLevel = getOpenMPCaptureLevels(Kind);
     Stmt *S = AStmt;
     while (--ThisCaptureLevel >= 0)
       S = cast<CapturedStmt>(S)->getCapturedStmt();
case OMPD_single:
     Res = ActOnOpenMPSingleDirective(ClausesWithImplicit, AStmt, StartLoc,
                                      EndLoc);
     break;
   case OMPD_master:
     assert(ClausesWithImplicit.empty() &&
            "No clauses are allowed for 'omp master' directive");
     Res = ActOnOpenMPMasterDirective(AStmt, StartLoc, EndLoc);
     break;
+  case OMPD_masked:
+    Res = ActOnOpenMPMaskedDirective(ClausesWithImplicit, AStmt, StartLoc,
+                                     EndLoc);
+    break;
   case OMPD_critical:
     Res = ActOnOpenMPCriticalDirective(DirName, ClausesWithImplicit, AStmt,
                                        StartLoc, EndLoc);
     break;
   case OMPD_parallel_for:
     Res = ActOnOpenMPParallelForDirective(ClausesWithImplicit, AStmt, StartLoc,
                                           EndLoc, VarsWithInheritedDSA);
     AllowedNameModifiers.push_back(OMPD_parallel);
StmtResult Sema::ActOnOpenMPMasterDirective(Stmt *AStmt,
   if (!AStmt)
     return StmtError();
 
   setFunctionHasBranchProtectedScope();
 
   return OMPMasterDirective::Create(Context, StartLoc, EndLoc, AStmt);
 }
 
+StmtResult Sema::ActOnOpenMPMaskedDirective(ArrayRef<OMPClause *> Clauses,
+                                            Stmt *AStmt,
+                                            SourceLocation StartLoc,
+                                            SourceLocation EndLoc) {
+  if (!AStmt)
+    return StmtError();
+
+  setFunctionHasBranchProtectedScope();
+
+  return OMPMaskedDirective::Create(Context, StartLoc, EndLoc, Clauses, AStmt);
+}
+
 StmtResult Sema::ActOnOpenMPCriticalDirective(
     const DeclarationNameInfo &DirName, ArrayRef<OMPClause *> Clauses,
     Stmt *AStmt, SourceLocation StartLoc, SourceLocation EndLoc) {
   if (!AStmt)
     return StmtError();
 
   bool ErrorFound = false;
   llvm::APSInt Hint;
case OMPC_detach:
     Res = ActOnOpenMPDetachClause(Expr, StartLoc, LParenLoc, EndLoc);
     break;
   case OMPC_novariants:
     Res = ActOnOpenMPNovariantsClause(Expr, StartLoc, LParenLoc, EndLoc);
     break;
   case OMPC_nocontext:
     Res = ActOnOpenMPNocontextClause(Expr, StartLoc, LParenLoc, EndLoc);
     break;
+  case OMPC_filter:
+    Res = ActOnOpenMPFilterClause(Expr, StartLoc, LParenLoc, EndLoc);
+    break;
   case OMPC_device:
   case OMPC_if:
   case OMPC_default:
   case OMPC_proc_bind:
   case OMPC_schedule:
   case OMPC_private:
   case OMPC_firstprivate:
   case OMPC_lastprivate:
case OMPC_if:
     case OMPD_end_declare_target:
     case OMPD_teams:
     case OMPD_tile:
     case OMPD_for:
     case OMPD_sections:
     case OMPD_section:
     case OMPD_single:
     case OMPD_master:
+    case OMPD_masked:
     case OMPD_critical:
     case OMPD_taskgroup:
     case OMPD_distribute:
     case OMPD_ordered:
     case OMPD_atomic:
     case OMPD_teams_distribute:
     case OMPD_requires:
       llvm_unreachable("Unexpected OpenMP directive with if-clause");
case OMPC_num_teams:
     case OMPD_simd:
     case OMPD_tile:
     case OMPD_for:
     case OMPD_for_simd:
     case OMPD_sections:
     case OMPD_section:
     case OMPD_single:
     case OMPD_master:
+    case OMPD_masked:
     case OMPD_critical:
     case OMPD_taskgroup:
     case OMPD_distribute:
     case OMPD_ordered:
     case OMPD_atomic:
     case OMPD_distribute_simd:
     case OMPD_requires:
       llvm_unreachable("Unexpected OpenMP directive with num_teams-clause");
case OMPC_thread_limit:
     case OMPD_simd:
     case OMPD_tile:
     case OMPD_for:
     case OMPD_for_simd:
     case OMPD_sections:
     case OMPD_section:
     case OMPD_single:
     case OMPD_master:
+    case OMPD_masked:
     case OMPD_critical:
     case OMPD_taskgroup:
     case OMPD_distribute:
     case OMPD_ordered:
     case OMPD_atomic:
     case OMPD_distribute_simd:
     case OMPD_requires:
       llvm_unreachable("Unexpected OpenMP directive with thread_limit-clause");
case OMPC_schedule:
     case OMPD_declare_target:
     case OMPD_end_declare_target:
     case OMPD_simd:
     case OMPD_tile:
     case OMPD_sections:
     case OMPD_section:
     case OMPD_single:
     case OMPD_master:
+    case OMPD_masked:
     case OMPD_critical:
     case OMPD_taskgroup:
     case OMPD_distribute:
     case OMPD_ordered:
     case OMPD_atomic:
     case OMPD_distribute_simd:
     case OMPD_target_teams:
     case OMPD_requires:
case OMPC_dist_schedule:
     case OMPD_simd:
     case OMPD_tile:
     case OMPD_for:
     case OMPD_for_simd:
     case OMPD_sections:
     case OMPD_section:
     case OMPD_single:
     case OMPD_master:
+    case OMPD_masked:
     case OMPD_critical:
     case OMPD_taskgroup:
     case OMPD_ordered:
     case OMPD_atomic:
     case OMPD_target_teams:
     case OMPD_requires:
       llvm_unreachable("Unexpected OpenMP directive with dist_schedule clause");
     case OMPD_unknown:
case OMPC_device:
     case OMPD_simd:
     case OMPD_tile:
     case OMPD_for:
     case OMPD_for_simd:
     case OMPD_sections:
     case OMPD_section:
     case OMPD_single:
     case OMPD_master:
+    case OMPD_masked:
     case OMPD_critical:
     case OMPD_taskgroup:
     case OMPD_distribute:
     case OMPD_ordered:
     case OMPD_atomic:
     case OMPD_distribute_simd:
     case OMPD_requires:
       llvm_unreachable("Unexpected OpenMP directive with device-clause");
case OMPC_priority:
     case OMPD_simd:
     case OMPD_tile:
     case OMPD_for:
     case OMPD_for_simd:
     case OMPD_sections:
     case OMPD_section:
     case OMPD_single:
     case OMPD_master:
+    case OMPD_masked:
     case OMPD_critical:
     case OMPD_taskgroup:
     case OMPD_distribute:
     case OMPD_ordered:
     case OMPD_atomic:
     case OMPD_distribute_simd:
     case OMPD_requires:
       llvm_unreachable("Unexpected OpenMP directive with grainsize-clause");
     case OMPD_unknown:
     default:
       llvm_unreachable("Unknown OpenMP directive");
     }
     break;
   case OMPC_novariants:
   case OMPC_nocontext:
     switch (DKind) {
     case OMPD_dispatch:
       CaptureRegion = OMPD_task;
       break;
     default:
       llvm_unreachable("Unexpected OpenMP directive");
     }
     break;
+  case OMPC_filter:
+    switch (DKind) {
+    case OMPD_masked:
+      CaptureRegion = OMPD_parallel;
+      break;
+    default:
+      llvm_unreachable("Unknown OpenMP directive");
+    }
+    break;
   case OMPC_firstprivate:
   case OMPC_lastprivate:
   case OMPC_reduction:
   case OMPC_task_reduction:
   case OMPC_in_reduction:
   case OMPC_linear:
   case OMPC_default:
   case OMPC_proc_bind:
if (CaptureRegion != OMPD_unknown && !CurContext->isDependentContext()) {
       HelperValStmt = buildPreInits(Context, Captures);
     }
   }
 
   return new (Context) OMPNocontextClause(ValExpr, HelperValStmt, CaptureRegion,
                                           StartLoc, LParenLoc, EndLoc);
 }
 
+OMPClause *Sema::ActOnOpenMPFilterClause(Expr *ThreadID,
+                                         SourceLocation StartLoc,
+                                         SourceLocation LParenLoc,
+                                         SourceLocation EndLoc) {
+  Expr *ValExpr = ThreadID;
+  Stmt *HelperValStmt = nullptr;
+
+  OpenMPDirectiveKind DKind = DSAStack->getCurrentDirective();
+  OpenMPDirectiveKind CaptureRegion =
+      getOpenMPCaptureRegionForClause(DKind, OMPC_filter, LangOpts.OpenMP);
+  if (CaptureRegion != OMPD_unknown && !CurContext->isDependentContext()) {
+    ValExpr = MakeFullExpr(ValExpr).get();
+    llvm::MapVector<const Expr *, DeclRefExpr *> Captures;
+    ValExpr = tryBuildCapture(*this, ValExpr, Captures).get();
+    HelperValStmt = buildPreInits(Context, Captures);
+  }
+  return new (Context) OMPFilterClause(ValExpr, HelperValStmt, CaptureRegion,
+                                       StartLoc, LParenLoc, EndLoc);
+}
+
 OMPClause *Sema::ActOnOpenMPVarListClause(
     OpenMPClauseKind Kind, ArrayRef<Expr *> VarList, Expr *DepModOrTailExpr,
     const OMPVarListLocTy &Locs, SourceLocation ColonLoc,
     CXXScopeSpec &ReductionOrMapperIdScopeSpec,
     DeclarationNameInfo &ReductionOrMapperId, int ExtraModifier,
     ArrayRef<OpenMPMapModifierKind> MapTypeModifiers,
     ArrayRef<SourceLocation> MapTypeModifiersLoc, bool IsMapTypeImplicit,
     SourceLocation ExtraModifierLoc,

clang/lib/Sema/TreeTransform.h

   /// Subclasses may override this routine to provide different behavior.
   OMPClause *RebuildOMPNocontextClause(Expr *Condition, SourceLocation StartLoc,
                                        SourceLocation LParenLoc,
                                        SourceLocation EndLoc) {
     return getSema().ActOnOpenMPNocontextClause(Condition, StartLoc, LParenLoc,
                                                 EndLoc);
   }
 
+  /// Build a new OpenMP 'filter' clause.
+  ///
+  /// By default, performs semantic analysis to build the new OpenMP clause.
+  /// Subclasses may override this routine to provide different behavior.
+  OMPClause *RebuildOMPFilterClause(Expr *ThreadID, SourceLocation StartLoc,
+                                    SourceLocation LParenLoc,
+                                    SourceLocation EndLoc) {
+    return getSema().ActOnOpenMPFilterClause(ThreadID, StartLoc, LParenLoc,
+                                             EndLoc);
+  }
+
   /// Rebuild the operand to an Objective-C \@synchronized statement.
   ///
   /// By default, performs semantic analysis to build the new statement.
   /// Subclasses may override this routine to provide different behavior.
   ExprResult RebuildObjCAtSynchronizedOperand(SourceLocation atLoc,
                                               Expr *object) {
     return getSema().ActOnObjCAtSynchronizedOperand(atLoc, object);
   }
TreeTransform<Derived>::TransformOMPDispatchDirective(OMPDispatchDirective *D) {
   DeclarationNameInfo DirName;
   getDerived().getSema().StartOpenMPDSABlock(OMPD_dispatch, DirName, nullptr,
                                              D->getBeginLoc());
   StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
   getDerived().getSema().EndOpenMPDSABlock(Res.get());
   return Res;
 }
 
+template <typename Derived>
+StmtResult
+TreeTransform<Derived>::TransformOMPMaskedDirective(OMPMaskedDirective *D) {
+  DeclarationNameInfo DirName;
+  getDerived().getSema().StartOpenMPDSABlock(OMPD_masked, DirName, nullptr,
+                                             D->getBeginLoc());
+  StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
+  getDerived().getSema().EndOpenMPDSABlock(Res.get());
+  return Res;
+}
+
 //===----------------------------------------------------------------------===//
 // OpenMP clause transformation
 //===----------------------------------------------------------------------===//
 template <typename Derived>
 OMPClause *TreeTransform<Derived>::TransformOMPIfClause(OMPIfClause *C) {
   ExprResult Cond = getDerived().TransformExpr(C->getCondition());
   if (Cond.isInvalid())
     return nullptr;
TreeTransform<Derived>::TransformOMPNocontextClause(OMPNocontextClause *C) {
   ExprResult Cond = getDerived().TransformExpr(C->getCondition());
   if (Cond.isInvalid())
     return nullptr;
   return getDerived().RebuildOMPNocontextClause(
       Cond.get(), C->getBeginLoc(), C->getLParenLoc(), C->getEndLoc());
 }
 
 template <typename Derived>
+OMPClause *
+TreeTransform<Derived>::TransformOMPFilterClause(OMPFilterClause *C) {
+  ExprResult ThreadID = getDerived().TransformExpr(C->getThreadID());
+  if (ThreadID.isInvalid())
+    return nullptr;
+  return getDerived().RebuildOMPFilterClause(ThreadID.get(), C->getBeginLoc(),
+                                             C->getLParenLoc(), C->getEndLoc());
+}
+
+template <typename Derived>
 OMPClause *TreeTransform<Derived>::TransformOMPUnifiedAddressClause(
     OMPUnifiedAddressClause *C) {
   llvm_unreachable("unified_address clause cannot appear in dependent context");
 }
 
 template <typename Derived>
 OMPClause *TreeTransform<Derived>::TransformOMPUnifiedSharedMemoryClause(
     OMPUnifiedSharedMemoryClause *C) {

clang/lib/Serialization/ASTReader.cpp

case llvm::omp::OMPC_detach:
     C = new (Context) OMPDetachClause();
     break;
   case llvm::omp::OMPC_uses_allocators:
     C = OMPUsesAllocatorsClause::CreateEmpty(Context, Record.readInt());
     break;
   case llvm::omp::OMPC_affinity:
     C = OMPAffinityClause::CreateEmpty(Context, Record.readInt());
     break;
+  case llvm::omp::OMPC_filter:
+    C = new (Context) OMPFilterClause();
+    break;
 #define OMP_CLAUSE_NO_CLASS(Enum, Str)                                         \
   case llvm::omp::Enum:                                                        \
     break;
 #include "llvm/Frontend/OpenMP/OMPKinds.def"
   default:
     break;
   }
   assert(C && "Unknown OMPClause type");

 }
 
 void OMPClauseReader::VisitOMPOrderClause(OMPOrderClause *C) {
   C->setKind(Record.readEnum<OpenMPOrderClauseKind>());
   C->setLParenLoc(Record.readSourceLocation());
   C->setKindKwLoc(Record.readSourceLocation());
 }
 
+void OMPClauseReader::VisitOMPFilterClause(OMPFilterClause *C) {
+  VisitOMPClauseWithPreInit(C);
+  C->setThreadID(Record.readSubExpr());
+  C->setLParenLoc(Record.readSourceLocation());
+}
+
 OMPTraitInfo *ASTRecordReader::readOMPTraitInfo() {
   OMPTraitInfo &TI = getContext().getNewOMPTraitInfo();
   TI.Sets.resize(readUInt32());
   for (auto &Set : TI.Sets) {
     Set.Kind = readEnum<llvm::omp::TraitSet>();
     Set.Selectors.resize(readUInt32());
     for (auto &Selector : Set.Selectors) {
       Selector.Kind = readEnum<llvm::omp::TraitSelector>();

clang/lib/Serialization/ASTReaderStmt.cpp

 }
 
 void ASTStmtReader::VisitOMPDispatchDirective(OMPDispatchDirective *D) {
   VisitStmt(D);
   VisitOMPExecutableDirective(D);
   D->setTargetCallLoc(Record.readSourceLocation());
 }
 
+void ASTStmtReader::VisitOMPMaskedDirective(OMPMaskedDirective *D) {
+  VisitStmt(D);
+  VisitOMPExecutableDirective(D);
+}
+
 //===----------------------------------------------------------------------===//
 // ASTReader Implementation
 //===----------------------------------------------------------------------===//
 
 Stmt *ASTReader::ReadStmt(ModuleFile &F) {
   switch (ReadingKind) {
   case Read_None:
     llvm_unreachable("should not call this when not reading anything");
case STMT_OMP_INTEROP_DIRECTIVE:
           Context, Record[ASTStmtReader::NumStmtFields], Empty);
       break;
 
     case STMT_OMP_DISPATCH_DIRECTIVE:
       S = OMPDispatchDirective::CreateEmpty(
           Context, Record[ASTStmtReader::NumStmtFields], Empty);
       break;
 
+    case STMT_OMP_MASKED_DIRECTIVE: {
+      S = OMPMaskedDirective::CreateEmpty(
+          Context, Record[ASTStmtReader::NumStmtFields], Empty);
+      break;
+    }
+
     case EXPR_CXX_OPERATOR_CALL:
       S = CXXOperatorCallExpr::CreateEmpty(
           Context, /*NumArgs=*/Record[ASTStmtReader::NumExprFields],
           /*HasFPFeatures=*/Record[ASTStmtReader::NumExprFields + 1], Empty);
       break;
 
     case EXPR_CXX_MEMBER_CALL:
       S = CXXMemberCallExpr::CreateEmpty(

clang/lib/Serialization/ASTWriter.cpp

void OMPClauseWriter::VisitOMPNovariantsClause(OMPNovariantsClause *C) {
   VisitOMPClauseWithPreInit(C);
   Record.AddStmt(C->getCondition());
   Record.AddSourceLocation(C->getLParenLoc());
 }
 
 void OMPClauseWriter::VisitOMPNocontextClause(OMPNocontextClause *C) {
   VisitOMPClauseWithPreInit(C);
   Record.AddStmt(C->getCondition());
+}
+
+void OMPClauseWriter::VisitOMPFilterClause(OMPFilterClause *C) {
+  VisitOMPClauseWithPreInit(C);
+  Record.AddStmt(C->getThreadID());
   Record.AddSourceLocation(C->getLParenLoc());
 }
 
 void OMPClauseWriter::VisitOMPPrivateClause(OMPPrivateClause *C) {
   Record.push_back(C->varlist_size());
   Record.AddSourceLocation(C->getLParenLoc());
   for (auto *VE : C->varlists()) {
     Record.AddStmt(VE);

clang/lib/Serialization/ASTWriterStmt.cpp

 
 void ASTStmtWriter::VisitOMPDispatchDirective(OMPDispatchDirective *D) {
   VisitStmt(D);
   VisitOMPExecutableDirective(D);
   Record.AddSourceLocation(D->getTargetCallLoc());
   Code = serialization::STMT_OMP_DISPATCH_DIRECTIVE;
 }
 
+void ASTStmtWriter::VisitOMPMaskedDirective(OMPMaskedDirective *D) {
+  VisitStmt(D);
+  VisitOMPExecutableDirective(D);
+  Code = serialization::STMT_OMP_MASKED_DIRECTIVE;
+}
+
 //===----------------------------------------------------------------------===//
 // ASTWriter Implementation
 //===----------------------------------------------------------------------===//
 
 unsigned ASTWriter::RecordSwitchCaseID(SwitchCase *S) {
   assert(SwitchCaseIDs.find(S) == SwitchCaseIDs.end() &&
          "SwitchCase recorded twice");
   unsigned NextID = SwitchCaseIDs.size();

clang/lib/StaticAnalyzer/Core/ExprEngine.cpp

switch (S->getStmtClass()) {
     case Stmt::OMPTargetTeamsDirectiveClass:
     case Stmt::OMPTargetTeamsDistributeDirectiveClass:
     case Stmt::OMPTargetTeamsDistributeParallelForDirectiveClass:
     case Stmt::OMPTargetTeamsDistributeParallelForSimdDirectiveClass:
     case Stmt::OMPTargetTeamsDistributeSimdDirectiveClass:
     case Stmt::OMPTileDirectiveClass:
     case Stmt::OMPInteropDirectiveClass:
     case Stmt::OMPDispatchDirectiveClass:
+    case Stmt::OMPMaskedDirectiveClass:
     case Stmt::CapturedStmtClass: {
       const ExplodedNode *node = Bldr.generateSink(S, Pred, Pred->getState());
       Engine.addAbortedBlock(node, currBldrCtx->getBlock());
       break;
     }
 
     case Stmt::ParenExprClass:
       llvm_unreachable("ParenExprs already handled.");

clang/test/OpenMP/masked_ast_print.cpp

+// RUN: %clang_cc1 -verify -fopenmp -fopenmp-version=51 -ast-print %s | FileCheck %s
+// RUN: %clang_cc1 -fopenmp -fopenmp-version=51 -x c++ -std=c++11 -emit-pch -o %t %s
+// RUN: %clang_cc1 -fopenmp -fopenmp-version=51 -std=c++11 -include-pch %t -fsyntax-only -verify %s -ast-print | FileCheck %s
+
+// RUN: %clang_cc1 -verify -fopenmp-simd -fopenmp-version=51 -ast-print %s | FileCheck %s
+// RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=51 -x c++ -std=c++11 -emit-pch -o %t %s
+// RUN: %clang_cc1 -fopenmp-simd -fopenmp-version=51 -std=c++11 -include-pch %t -fsyntax-only -verify %s -ast-print | FileCheck %s
+// expected-no-diagnostics
+
+#ifndef HEADER
+#define HEADER
+
+void foo() {}
+
+int main (int argc, char **argv) {
+  int b = argc, c, d, e, f, g;
+  static int a;
+// CHECK: static int a;
+#pragma omp parallel
+{
+#pragma omp masked
+{
+  a=2;
+}
+
+#pragma omp masked filter(1) filter(2)
+{
+  a=3;
+}
+}
+// CHECK-NEXT: #pragma omp parallel
+// CHECK-NEXT: {
+// CHECK-NEXT: #pragma omp masked{{$}}
+// CHECK-NEXT: {
+// CHECK-NEXT: a = 2;
+// CHECK-NEXT: }
+// CHECK-NEXT: #pragma omp masked filter(1) filter(2){{$}}
+// CHECK-NEXT: {
+// CHECK-NEXT: a = 3;
+// CHECK-NEXT: }
+// CHECK-NEXT: }
+  return (0);
+}
+
+#endif

clang/test/OpenMP/masked_messages.cpp

+// RUN: %clang_cc1 -verify -fopenmp %s -Wuninitialized
+
+// RUN: %clang_cc1 -verify -fopenmp-simd %s -Wuninitialized
+
+void xxx(int argc) {
+  int x; // expected-note {{initialize the variable 'x' to silence this warning}}
+#pragma omp masked
+  argc = x; // expected-warning {{variable 'x' is uninitialized when used here}}
+}
+
+void yyy(int argc) {
+  int x; // expected-note {{initialize the variable 'x' to silence this warning}}
+#pragma omp masked filter(1) filter(2)
+  argc = x; // expected-warning {{variable 'x' is uninitialized when used here}}
+}
+
+int foo();
+
+int main() {
+  #pragma omp masked
+  ;
+  #pragma omp masked filter(1) filter(2) filter(3)
+  ;
+  #pragma omp masked nowait // expected-error {{unexpected OpenMP clause 'nowait' in directive '#pragma omp masked'}}
+  #pragma omp masked unknown // expected-warning {{extra tokens at the end of '#pragma omp masked' are ignored}}
+  foo();
+  {
+    #pragma omp masked
+  } // expected-error {{expected statement}}
+  {
+    #pragma omp masked filter(2)
+  } // expected-error {{expected statement}}
+  #pragma omp for
+  for (int i = 0; i < 10; ++i) {
+    foo();
+    #pragma omp masked filter(1) // expected-error {{region cannot be closely nested inside 'for' region}}
+    foo();
+  }
+  #pragma omp sections
+  {
+    foo();
+    #pragma omp masked // expected-error {{region cannot be closely nested inside 'sections' region}}
+    foo();
+  }
+  #pragma omp single
+  for (int i = 0; i < 10; ++i) {
+    foo();
+    #pragma omp masked allocate(i) // expected-error {{region cannot be closely nested inside 'single' region}} expected-error {{unexpected OpenMP clause 'allocate' in directive '#pragma omp masked'}}
+    foo();
+  }
+  #pragma omp masked
+  for (int i = 0; i < 10; ++i) {
+    foo();
+    #pragma omp masked
+    foo();
+  }
+  #pragma omp for ordered
+  for (int i = 0; i < 10; ++i)
+  #pragma omp masked // expected-error {{region cannot be closely nested inside 'for' region}}
+  {
+    foo();
+  }
+
+  return 0;
+}
+
+int foo() {
+  L1: // expected-note {{jump exits scope of OpenMP structured block}}
+    foo();
+  #pragma omp masked filter(0)
+  {
+    foo();
+    goto L1; // expected-error {{cannot jump from this goto statement to its label}}
+  }
+  goto L2; // expected-error {{cannot jump from this goto statement to its label}}
+  #pragma omp masked filter(-2) filter(1) filter(10)
+  { // expected-note {{jump bypasses OpenMP structured block}}
+    L2:
+    foo();
+  }
+
+  return 0;
+}

clang/test/OpenMP/nesting_of_regions.cpp

#pragma omp single
   bar();
 
 #pragma omp parallel
 #pragma omp master
   {
     bar();
   }
 #pragma omp parallel
+#pragma omp masked
+  {
+    bar();
+  }
+#pragma omp parallel
 #pragma omp critical
   {
     bar();
   }
 #pragma omp parallel
 #pragma omp parallel for
   for (int i = 0; i < 10; ++i)
     ;
#pragma omp simd
   for (int i = 0; i < 10; ++i) {
 #pragma omp master // 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 masked // 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 critical // 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 parallel for // expected-error {{OpenMP constructs may not be nested inside a simd region}}
#pragma omp for
   for (int i = 0; i < 10; ++i) {
 #pragma omp master // expected-error {{region cannot be closely nested inside 'for' region}}
     {
       bar();
     }
   }
 #pragma omp for
   for (int i = 0; i < 10; ++i) {
+#pragma omp masked // expected-error {{region cannot be closely nested inside 'for' region}}
+    {
+      bar();
+    }
+  }
+#pragma omp for
+  for (int i = 0; i < 10; ++i) {
 #pragma omp critical
     {
       bar();
     }
   }
 #pragma omp for
   for (int i = 0; i < 10; ++i) {
 #pragma omp parallel
#pragma omp for simd
   for (int i = 0; i < 10; ++i) {
 #pragma omp master // 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 masked // 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 critical // 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 parallel for // expected-error {{OpenMP constructs may not be nested inside a simd region}}
#pragma omp master // OK
     }
 #pragma omp master // expected-error {{region cannot be closely nested inside 'sections' region}}
     bar();
   }
 #pragma omp sections
   {
 #pragma omp parallel
     {
+#pragma omp masked // OK
+      {
+        bar();
+      }
+#pragma omp for // OK
+      for (int i = 0; i < 10; ++i)
+        ;
+#pragma omp masked // OK
+      {
+        bar();
+      }
+    }
+#pragma omp masked // expected-error {{region cannot be closely nested inside 'sections' region}}
+    bar();
+  }
+#pragma omp sections
+  {
+#pragma omp parallel
+    {
 #pragma omp critical(A) // OK
       {
         bar();
       }
 #pragma omp for // OK
       for (int i = 0; i < 10; ++i)
         ;
 #pragma omp critical // OK

 #pragma omp sections
   {
 #pragma omp section
     {
 #pragma omp single // expected-error {{region cannot be closely nested inside 'section' region; perhaps you forget to enclose 'omp single' directive into a parallel region?}}
       bar();
 #pragma omp master // expected-error {{region cannot be closely nested inside 'section' region}}
       bar();
+#pragma omp masked // expected-error {{region cannot be closely nested inside 'section' region}}
+      bar();
 #pragma omp critical
       bar();
     }
   }
 #pragma omp sections
   {
 #pragma omp section
     {
#pragma omp single
   {
 #pragma omp master // expected-error {{region cannot be closely nested inside 'single' region}}
     {
       bar();
     }
   }
 #pragma omp single
   {
+#pragma omp masked // expected-error {{region cannot be closely nested inside 'single' region}}
+    {
+      bar();
+    }
+  }
+#pragma omp single
+  {
 #pragma omp parallel master
     {
       bar();
     }
   }
 #pragma omp single
   {
 #pragma omp critical
#pragma omp target teams distribute parallel for simd // OK
   }
 #pragma omp master
   {
 #pragma omp target teams distribute simd // OK
     for (int i = 0; i < 10; ++i)
       ;
   }
 
+// MASKED DIRECTIVE
+#pragma omp masked
+  {
+#pragma omp for // expected-error {{region cannot be closely nested inside 'masked' region; perhaps you forget to enclose 'omp for' directive into a parallel region?}}
+    for (int i = 0; i < 10; ++i)
+      ;
+  }
+#pragma omp masked
+  {
+#pragma omp simd
+    for (int i = 0; i < 10; ++i)
+      ;
+  }
+#pragma omp masked
+  {
+#pragma omp for simd // expected-error {{region cannot be closely nested inside 'masked' region; perhaps you forget to enclose 'omp for simd' directive into a parallel region?}}
+    for (int i = 0; i < 10; ++i)
+      ;
+  }
+#pragma omp masked
+  {
+#pragma omp parallel
+    for (int i = 0; i < 10; ++i)
+      ;
+  }
+#pragma omp masked
+  {
+#pragma omp single // expected-error {{region cannot be closely nested inside 'masked' region; perhaps you forget to enclose 'omp single' directive into a parallel region?}}
+    {
+      bar();
+    }
+  }
+#pragma omp masked
+  {
+#pragma omp masked // OK, though second 'masked' is redundant
+    {
+      bar();
+    }
+  }
+#pragma omp masked
+  {
+#pragma omp critical
+    {
+      bar();
+    }
+  }
+#pragma omp masked
+  {
+#pragma omp sections // expected-error {{region cannot be closely nested inside 'masked' region; perhaps you forget to enclose 'omp sections' directive into a parallel region?}}
+    {
+      bar();
+    }
+  }
+#pragma omp masked
+  {
+#pragma omp parallel
+    {
+#pragma omp masked // OK
+      {
+        bar();
+      }
+#pragma omp for // OK
+      for (int i = 0; i < 10; ++i)
+        ;
+#pragma omp for simd // OK
+      for (int i = 0; i < 10; ++i)
+        ;
+#pragma omp sections // OK
+      {
+        bar();
+      }
+    }
+  }
+#pragma omp masked
+  {
+#pragma omp parallel
+    {
+#pragma omp for // OK
+      for (int i = 0; i < 10; ++i)
+        ;
+#pragma omp for simd // OK
+      for (int i = 0; i < 10; ++i)
+        ;
+#pragma omp sections // OK
+      {
+        bar();
+      }
+    }
+  }
+#pragma omp masked
+  {
+#pragma omp parallel for
+    for (int i = 0; i < 10; ++i)
+      ;
+  }
+#pragma omp masked
+  {
+#pragma omp parallel for simd
+    for (int i = 0; i < 10; ++i)
+      ;
+  }
+#pragma omp masked
+  {
+#pragma omp parallel sections
+    {
+      bar();
+    }
+  }
+#pragma omp masked
+  {
+#pragma omp task
+    {
+      bar();
+    }
+  }
+#pragma omp masked
+  {
+#pragma omp taskyield
+    bar();
+  }
+#pragma omp masked
+  {
+#pragma omp barrier // expected-error {{region cannot be closely nested inside 'masked' region}}
+    bar();
+  }
+#pragma omp masked
+  {
+#pragma omp scan // expected-error {{region cannot be closely nested inside 'masked' region}}
+    bar();
+  }
+#pragma omp masked
+  {
+#pragma omp taskwait
+    bar();
+  }
+#pragma omp masked
+  {
+#pragma omp flush
+    bar();
+  }
+#pragma omp masked
+  {
+#pragma omp ordered // expected-error {{region cannot be closely nested inside 'masked' region; perhaps you forget to enclose 'omp ordered' directive into a for or a parallel for region with 'ordered' clause?}}
+    bar();
+  }
+#pragma omp masked
+  {
+#pragma omp atomic
+    ++a;
+  }
+#pragma omp masked
+  {
+#pragma omp target
+    ++a;
+  }
+#pragma omp masked
+  {
+#pragma omp target parallel
+    ++a;
+  }
+#pragma omp masked
+  {
+#pragma omp target parallel for
+    for (int i = 0; i < 10; ++i)
+      ;
+  }
+#pragma omp masked
+  {
+#pragma omp target enter data map(to: a)
+    ++a;
+  }
+#pragma omp masked
+  {
+#pragma omp target exit data map(from: a)
+    ++a;
+  }
+#pragma omp masked
+  {
+#pragma omp teams // expected-error {{region cannot be closely nested inside 'masked' region; perhaps you forget to enclose 'omp teams' directive into a target region?}}
+    ++a;
+  }
+#pragma omp masked
+  {
+#pragma omp taskloop
+  for (int i = 0; i < 10; ++i)
+    ++a;
+  }
+#pragma omp masked
+  {
+#pragma omp distribute // expected-error {{region cannot be closely nested inside 'masked' region; perhaps you forget to enclose 'omp distribute' directive into a teams region?}}
+    for (int i = 0; i < 10; ++i)
+      ;
+  }
+#pragma omp masked
+  {
+#pragma omp target update to(a)
+    bar();
+  }
+#pragma omp masked
+  {
+#pragma omp distribute parallel for // expected-error {{region cannot be closely nested inside 'masked' region; perhaps you forget to enclose 'omp distribute parallel for' directive into a teams region?}}
+    for (int i = 0; i < 10; ++i)
+      ;
+  }
+#pragma omp masked
+  {
+#pragma omp distribute parallel for simd // expected-error {{region cannot be closely nested inside 'masked' 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 masked
+  {
+#pragma omp distribute simd // expected-error {{region cannot be closely nested inside 'masked' region; perhaps you forget to enclose 'omp distribute simd' directive into a teams region?}}
+    for (int i = 0; i < 10; ++i)
+      ;
+  }
+#pragma omp masked
+  {
+#pragma omp target simd // OK
+    for (int i = 0; i < 10; ++i)
+      ;
+  }
+#pragma omp masked
+  {
+#pragma omp teams distribute // expected-error {{region cannot be closely nested inside 'masked' region; perhaps you forget to enclose 'omp teams distribute' directive into a target region?}}
+    for (int i = 0; i < 10; ++i)
+      ;
+  }
+#pragma omp masked
+  {
+#pragma omp teams distribute simd // expected-error {{region cannot be closely nested inside 'masked' region; perhaps you forget to enclose 'omp teams distribute simd' directive into a target region?}}
+    for (int i = 0; i < 10; ++i)
+      ;
+  }
+#pragma omp masked
+  {
+#pragma omp teams distribute parallel for simd // expected-error {{region cannot be closely nested inside 'masked' 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 masked
+  {
+#pragma omp teams distribute parallel for // expected-error {{region cannot be closely nested inside 'masked' 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 masked
+  {
+#pragma omp target teams // OK
+    a++;
+  }
+#pragma omp masked
+  {
+#pragma omp target teams distribute // OK
+    for (int i = 0; i < 10; ++i)
+      ;
+  }
+#pragma omp masked
+  {
+#pragma omp target teams distribute parallel for // OK
+    for (int i = 0; i < 10; ++i)
+      ;
+  }
+#pragma omp masked
+  {
+#pragma omp target teams distribute parallel for simd // OK
+    for (int i = 0; i < 10; ++i)
+      ;
+  }
+#pragma omp masked
+  {
+#pragma omp target teams distribute simd // OK
+    for (int i = 0; i < 10; ++i)
+      ;
+  }
+
 // CRITICAL DIRECTIVE
 #pragma omp critical
   {
 #pragma omp for // expected-error {{region cannot be closely nested inside 'critical' region; perhaps you forget to enclose 'omp for' directive into a parallel region?}}
     for (int i = 0; i < 10; ++i)
       ;
   }
 #pragma omp critical
#pragma omp single // expected-error {{region cannot be closely nested inside 'critical' region; perhaps you forget to enclose 'omp single' directive into a parallel region?}}
     }
   }
 #pragma omp critical
   {
 #pragma omp master // OK, though second 'master' is redundant
     {
       bar();
     }
+#pragma omp masked // OK, though second 'masked' is redundant
+    {
+      bar();
+    }
   }
 #pragma omp critical
   {
 #pragma omp critical
     {
       bar();
     }
   }
 #pragma omp critical
   {
 #pragma omp sections // expected-error {{region cannot be closely nested inside 'critical' region; perhaps you forget to enclose 'omp sections' directive into a parallel region?}}
     {
       bar();
     }
   }
 #pragma omp critical
   {
 #pragma omp parallel
     {
 #pragma omp master // OK
       {
         bar();
       }
+#pragma omp masked // OK
+      {
+        bar();
+      }
 #pragma omp for // OK
       for (int i = 0; i < 10; ++i)
         ;
 #pragma omp for simd // OK
       for (int i = 0; i < 10; ++i)
         ;
 #pragma omp sections // OK
       {
#pragma omp single // expected-error {{region cannot be closely nested inside 'parallel for' region; perhaps you forget to enclose 'omp single' directive into a parallel region?}}
   }
 
 #pragma omp parallel for
   for (int i = 0; i < 10; ++i) {
 #pragma omp master // expected-error {{region cannot be closely nested inside 'parallel for' region}}
     {
       bar();
     }
+#pragma omp masked // 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 critical
     {
       bar();
     }
#pragma omp single // 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 master // expected-error {{OpenMP constructs may not be nested inside a simd region}}
     {
       bar();
     }
+#pragma omp masked // 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 critical // expected-error {{OpenMP constructs may not be nested inside a simd region}}
     {
       bar();
     }
#pragma omp single // expected-error {{region cannot be closely nested inside 'parallel master' region; perhaps you forget to enclose 'omp single' directive into a parallel region?}}
     }
   }
 #pragma omp parallel master
   {
 #pragma omp master // OK, though second 'master' is redundant
     {
       bar();
     }
+#pragma omp masked // OK, though second 'master' is redundant
+    {
+      bar();
+    }
   }
 #pragma omp parallel master
   {
 #pragma omp critical
     {
       bar();
     }
   }
#pragma omp single // expected-error {{region cannot be closely nested inside 'section' region; perhaps you forget to enclose 'omp single' directive into a parallel region?}}
     }
   }
 #pragma omp parallel sections
   {
 #pragma omp section
     {
 #pragma omp master // expected-error {{region cannot be closely nested inside 'section' region}}
       bar();
+#pragma omp masked // expected-error {{region cannot be closely nested inside 'section' region}}
+      bar();
     }
   }
 #pragma omp parallel sections
   {
 #pragma omp section
     {
 #pragma omp critical
       bar();
#pragma omp section // expected-error {{'omp section' directive must be closely nested to a sections region, not a task region}}
   }
 #pragma omp task
 #pragma omp single // expected-error {{region cannot be closely nested inside 'task' region; perhaps you forget to enclose 'omp single' directive into a parallel region?}}
   bar();
 #pragma omp task
 #pragma omp master // expected-error {{region cannot be closely nested inside 'task' region}}
   bar();
 #pragma omp task
+#pragma omp masked // expected-error {{region cannot be closely nested inside 'task' region}}
+  bar();
+#pragma omp task
 #pragma omp critical
   bar();
 
 #pragma omp task
 #pragma omp parallel for
   for (int i = 0; i < 10; ++i)
     ;
 #pragma omp task
#pragma omp single // expected-error {{region cannot be closely nested inside 'ordered' region; perhaps you forget to enclose 'omp single' directive into a parallel region?}}
     }
   }
 #pragma omp ordered
   {
 #pragma omp master // OK, though second 'ordered' is redundant
     {
       bar();
     }
+#pragma omp masked // OK, though second 'ordered' is redundant
+    {
+      bar();
+    }
   }
 #pragma omp ordered
   {
 #pragma omp critical
     {
       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 master // expected-error {{OpenMP constructs may not be nested inside an atomic region}}
     {
       bar();
     }
+#pragma omp masked // expected-error {{OpenMP constructs may not be nested inside an atomic 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 parallel master // expected-error {{OpenMP constructs may not be nested inside an atomic region}}
     {
       bar();
#pragma omp single
   bar();
 
 #pragma omp target
 #pragma omp master
   {
     bar();
   }
 #pragma omp target
+#pragma omp masked
+  {
+    bar();
+  }
+#pragma omp target
 #pragma omp critical
   {
     bar();
   }
 #pragma omp target
 #pragma omp parallel for
   for (int i = 0; i < 10; ++i)
     ;

 #pragma omp single
   bar();
 
 #pragma omp target parallel
 #pragma omp master
   {
     bar();
   }
+#pragma omp target parallel
+#pragma omp masked
+  {
+    bar();
+  }
 #pragma omp target
 #pragma omp parallel master
   {
     bar();
   }
 #pragma omp target parallel
 #pragma omp critical
   {

 #pragma omp master // expected-error {{region cannot be closely nested inside 'target parallel for' region}}
     {
       bar();
     }
   }
 
 #pragma omp target parallel for
   for (int i = 0; i < 10; ++i) {
+#pragma omp masked // expected-error {{region cannot be closely nested inside 'target parallel for' region}}
+    {
+      bar();
+    }
+  }
+
+#pragma omp target parallel for
+  for (int i = 0; i < 10; ++i) {
 #pragma omp critical
     {
       bar();
     }
   }
 
 #pragma omp target parallel for
   for (int i = 0; i < 10; ++i) {

 #pragma omp target
 #pragma omp teams
 #pragma omp master // expected-error {{region cannot be closely nested inside 'teams' region; perhaps you forget to enclose 'omp master' directive into a parallel region?}}
   {
     bar();
   }
 #pragma omp target
 #pragma omp teams
+#pragma omp masked // expected-error {{region cannot be closely nested inside 'teams' region; perhaps you forget to enclose 'omp masked' directive into a parallel region?}}
+  {
+    bar();
+  }
+#pragma omp target
+#pragma omp teams
 #pragma omp critical // expected-error {{region cannot be closely nested inside 'teams' region; perhaps you forget to enclose 'omp critical' directive into a parallel region?}}
   {
     bar();
   }
 #pragma omp target
 #pragma omp teams
 #pragma omp parallel for
   for (int i = 0; i < 10; ++i)
#pragma omp taskloop
   for (int i = 0; i < 10; ++i) {
 #pragma omp master // expected-error {{region cannot be closely nested inside 'taskloop' region}}
     {
       bar();
     }
   }
 #pragma omp taskloop
   for (int i = 0; i < 10; ++i) {
+#pragma omp masked // expected-error {{region cannot be closely nested inside 'taskloop' region}}
+    {
+      bar();
+    }
+  }
+#pragma omp taskloop
+  for (int i = 0; i < 10; ++i) {
 #pragma omp critical
     {
       bar();
     }
   }
 #pragma omp taskloop
   for (int i = 0; i < 10; ++i) {
 #pragma omp parallel
#pragma omp master
     {
       bar();
     }
   }
 #pragma omp target
 #pragma omp teams
 #pragma omp distribute
   for (int i = 0; i < 10; ++i) {
+#pragma omp masked
+    {
+      bar();
+    }
+  }
+#pragma omp target
+#pragma omp teams
+#pragma omp distribute
+  for (int i = 0; i < 10; ++i) {
 #pragma omp critical
     {
       bar();
     }
   }
 #pragma omp target
 #pragma omp teams
 #pragma omp distribute
#pragma omp master // expected-error {{region cannot be closely nested inside 'distribute parallel for' region}}
     {
       bar();
     }
   }
 #pragma omp target
 #pragma omp teams
 #pragma omp distribute parallel for
   for (int i = 0; i < 10; ++i) {
+#pragma omp masked // expected-error {{region cannot be closely nested inside 'distribute parallel for' region}}
+    {
+      bar();
+    }
+  }
+#pragma omp target
+#pragma omp teams
+#pragma omp distribute parallel for
+  for (int i = 0; i < 10; ++i) {
 #pragma omp critical
     {
       bar();
     }
   }
 #pragma omp target
 #pragma omp teams
 #pragma omp distribute parallel for
#pragma omp master // 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 masked // 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 critical // 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
#pragma omp target simd
   for (int i = 0; i < 10; ++i) {
 #pragma omp master // 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 masked // 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 critical // 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 parallel // expected-error {{OpenMP constructs may not be nested inside a simd region}}

 #pragma omp master // OK
     {
       bar();
     }
   }
 #pragma omp target
 #pragma omp teams distribute
   for (int i = 0; i < 10; ++i) {
+#pragma omp masked // OK
+    {
+      bar();
+    }
+  }
+#pragma omp target
+#pragma omp teams distribute
+  for (int i = 0; i < 10; ++i) {
 #pragma omp critical // OK
     {
       bar();
     }
   }
 #pragma omp target
 #pragma omp teams distribute
   for (int i = 0; i < 10; ++i) {

 #pragma omp master // OK
     {
       bar();
     }
   }
 #pragma omp target
 #pragma omp teams distribute
   for (int i = 0; i < 10; ++i) {
+#pragma omp masked // OK
+    {
+      bar();
+    }
+  }
+#pragma omp target
+#pragma omp teams distribute
+  for (int i = 0; i < 10; ++i) {
 #pragma omp critical // OK
     {
       bar();
     }
   }
 #pragma omp target
 #pragma omp teams distribute
   for (int i = 0; i < 10; ++i) {

 #pragma omp master // 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 masked // 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 critical // 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 master // 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 masked // 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 critical // 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 master // expected-error {{region cannot be closely nested inside 'teams distribute parallel for' region}}
     {
       bar();
     }
   }
 #pragma omp target
 #pragma omp teams distribute parallel for
   for (int i = 0; i < 10; ++i) {
+#pragma omp masked // expected-error {{region cannot be closely nested inside 'teams distribute parallel for' region}}
+    {
+      bar();
+    }
+  }
+#pragma omp target
+#pragma omp teams distribute parallel for
+  for (int i = 0; i < 10; ++i) {
 #pragma omp critical // OK
     {
       bar();
     }
   }
 #pragma omp target
 #pragma omp teams distribute parallel for
   for (int i = 0; i < 10; ++i) {
#pragma omp single // expected-error {{region cannot be closely nested inside 'target teams' region; perhaps you forget to enclose 'omp single' directive into a parallel region?}}
   bar();
 
 #pragma omp target teams
 #pragma omp master // expected-error {{region cannot be closely nested inside 'target teams' region; perhaps you forget to enclose 'omp master' directive into a parallel region?}}
   {
     bar();
   }
 #pragma omp target teams
+#pragma omp masked // expected-error {{region cannot be closely nested inside 'target teams' region; perhaps you forget to enclose 'omp masked' directive into a parallel region?}}
+  {
+    bar();
+  }
+#pragma omp target teams
 #pragma omp critical // expected-error {{region cannot be closely nested inside 'target teams' region; perhaps you forget to enclose 'omp critical' directive into a parallel region?}}
   {
     bar();
   }
 #pragma omp target teams
 #pragma omp parallel for
   for (int i = 0; i < 10; ++i)
     ;
#pragma omp target teams distribute
   for (int i = 0; i < 10; ++i) {
 #pragma omp master // OK
     {
       bar();
     }
   }
 #pragma omp target teams distribute
   for (int i = 0; i < 10; ++i) {
+#pragma omp masked // OK
+    {
+      bar();
+    }
+  }
+#pragma omp target teams distribute
+  for (int i = 0; i < 10; ++i) {
 #pragma omp critical // OK
     {
       bar();
     }
   }
 #pragma omp target teams distribute
   for (int i = 0; i < 10; ++i) {
 #pragma omp parallel // OK
#pragma omp target teams distribute parallel for
   for (int i = 0; i < 10; ++i) {
 #pragma omp master // expected-error {{region cannot be closely nested inside 'target teams distribute parallel for' region}}
     {
       bar();
     }
   }
 #pragma omp target teams distribute parallel for
   for (int i = 0; i < 10; ++i) {
+#pragma omp masked // expected-error {{region cannot be closely nested inside 'target teams distribute parallel for' region}}
+    {
+      bar();
+    }
+  }
+#pragma omp target teams distribute parallel for
+  for (int i = 0; i < 10; ++i) {
 #pragma omp critical // OK
     {
       bar();
     }
   }
 #pragma omp target teams distribute parallel for
   for (int i = 0; i < 10; ++i) {
 #pragma omp parallel // OK
#pragma omp target teams distribute parallel for simd
   for (int i = 0; i < 10; ++i) {
 #pragma omp master // 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 masked // 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 critical // 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 parallel // 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 master // 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 masked // 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 critical // 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 parallel // expected-error {{OpenMP constructs may not be nested inside a simd region}}
#pragma omp sections
     bar();
   }
 #pragma omp parallel
 #pragma omp single
   bar();
 #pragma omp parallel
 #pragma omp master
   bar();
+#pragma omp parallel
+#pragma omp masked
+  bar();
 #pragma omp parallel master
   bar();
 #pragma omp parallel
 #pragma omp critical
   bar();
 #pragma omp parallel
 #pragma omp parallel for
   for (int i = 0; i < 10; ++i)
#pragma omp section // expected-error {{OpenMP constructs may not be nested inside a simd region}}
     }
   }
 #pragma omp simd
   for (int i = 0; i < 10; ++i) {
 #pragma omp single // expected-error {{OpenMP constructs may not be nested inside a simd region}}
     bar();
 #pragma omp master // expected-error {{OpenMP constructs may not be nested inside a simd region}}
     bar();
+#pragma omp masked // 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 single // expected-error {{OpenMP constructs may not be nested inside a simd region}}
     bar();
 #pragma omp critical // expected-error {{OpenMP constructs may not be nested inside a simd region}}
     bar();
   }
#pragma omp section // expected-error {{'omp section' directive must be closely nested to a sections region, not a for region}}
     }
   }
 #pragma omp for
   for (int i = 0; i < 10; ++i) {
 #pragma omp single // expected-error {{region cannot be closely nested inside 'for' region; perhaps you forget to enclose 'omp single' directive into a parallel region?}}
     bar();
 #pragma omp master // expected-error {{region cannot be closely nested inside 'for' region}}
     bar();
+#pragma omp masked // expected-error {{region cannot be closely nested inside 'for' region}}
+    bar();
 #pragma omp critical
     bar();
   }
 #pragma omp for
   for (int i = 0; i < 10; ++i) {
 #pragma omp parallel
     {
 #pragma omp single // OK
#pragma omp section // 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 single // expected-error {{OpenMP constructs may not be nested inside a simd region}}
     bar();
 #pragma omp master // expected-error {{OpenMP constructs may not be nested inside a simd region}}
     bar();
+#pragma omp masked // 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 single // expected-error {{OpenMP constructs may not be nested inside a simd region}}
     bar();
 #pragma omp critical // expected-error {{OpenMP constructs may not be nested inside a simd region}}
     bar();
   }

 #pragma omp sections
   {
 #pragma omp critical
     bar();
 #pragma omp single // expected-error {{region cannot be closely nested inside 'sections' region; perhaps you forget to enclose 'omp single' directive into a parallel region?}}
     bar();
 #pragma omp master // expected-error {{region cannot be closely nested inside 'sections' region}}
     bar();
+#pragma omp masked // expected-error {{region cannot be closely nested inside 'sections' region}}
+    bar();
   }
 #pragma omp sections
   {
 #pragma omp parallel
     {
 #pragma omp single // OK
       {
         bar();

 #pragma omp sections
   {
 #pragma omp section
     {
 #pragma omp single // expected-error {{region cannot be closely nested inside 'section' region; perhaps you forget to enclose 'omp single' directive into a parallel region?}}
       bar();
 #pragma omp master // expected-error {{region cannot be closely nested inside 'section' region}}
       bar();
+#pragma omp masked // expected-error {{region cannot be closely nested inside 'section' region}}
+      bar();
 #pragma omp critical
       bar();
     }
   }
 #pragma omp sections
   {
 #pragma omp section
     {

 #pragma omp single
   {
 #pragma omp single // expected-error {{region cannot be closely nested inside 'single' region; perhaps you forget to enclose 'omp single' directive into a parallel region?}}
     {
       bar();
     }
 #pragma omp master // expected-error {{region cannot be closely nested inside 'single' region}}
     bar();
+#pragma omp masked // expected-error {{region cannot be closely nested inside 'single' region}}
+    bar();
 #pragma omp critical
     bar();
   }
 #pragma omp single
   {
 #pragma omp sections // expected-error {{region cannot be closely nested inside 'single' region; perhaps you forget to enclose 'omp sections' directive into a parallel region?}}
     {
       bar();
#pragma omp target teams distribute parallel for simd // OK
   }
 #pragma omp master
   {
 #pragma omp target teams distribute simd // OK
     for (int i = 0; i < 10; ++i)
       ;
   }
 
+// MASKED DIRECTIVE
+#pragma omp masked
+  {
+#pragma omp for // expected-error {{region cannot be closely nested inside 'masked' region; perhaps you forget to enclose 'omp for' directive into a parallel region?}}
+    for (int i = 0; i < 10; ++i)
+      ;
+  }
+#pragma omp masked
+  {
+#pragma omp simd
+    for (int i = 0; i < 10; ++i)
+      ;
+  }
+#pragma omp masked
+  {
+#pragma omp for simd // expected-error {{region cannot be closely nested inside 'masked' region; perhaps you forget to enclose 'omp for simd' directive into a parallel region?}}
+    for (int i = 0; i < 10; ++i)
+      ;
+  }
+#pragma omp masked
+  {
+#pragma omp parallel
+    for (int i = 0; i < 10; ++i)
+      ;
+  }
+#pragma omp parallel master
+  {
+    for (int i = 0; i < 10; ++i)
+      ;
+  }
+#pragma omp masked
+  {
+#pragma omp single // expected-error {{region cannot be closely nested inside 'masked' region; perhaps you forget to enclose 'omp single' directive into a parallel region?}}
+    {
+      bar();
+    }
+  }
+#pragma omp masked
+  {
+#pragma omp masked // OK, though second 'masked' is redundant
+    {
+      bar();
+    }
+  }
+#pragma omp masked
+  {
+#pragma omp critical
+    {
+      bar();
+    }
+  }
+#pragma omp masked
+  {
+#pragma omp sections // expected-error {{region cannot be closely nested inside 'masked' region; perhaps you forget to enclose 'omp sections' directive into a parallel region?}}
+    {
+      bar();
+    }
+  }
+#pragma omp masked
+  {
+#pragma omp parallel
+    {
+#pragma omp masked // OK
+      {
+        bar();
+      }
+#pragma omp for // OK
+      for (int i = 0; i < 10; ++i)
+        ;
+#pragma omp for simd // OK
+      for (int i = 0; i < 10; ++i)
+        ;
+#pragma omp sections // OK
+      {
+        bar();
+      }
+    }
+  }
+#pragma omp masked
+  {
+#pragma omp parallel master
+    {
+      bar();
+    }
+  }
+#pragma omp masked
+  {
+#pragma omp parallel for
+    for (int i = 0; i < 10; ++i)
+      ;
+  }
+#pragma omp masked
+  {
+#pragma omp parallel for simd
+    for (int i = 0; i < 10; ++i)
+      ;
+  }
+#pragma omp masked
+  {
+#pragma omp parallel sections
+    {
+      bar();
+    }
+  }
+#pragma omp masked
+  {
+#pragma omp task
+    {
+      bar();
+    }
+  }
+#pragma omp masked
+  {
+#pragma omp taskyield
+    bar();
+  }
+#pragma omp masked
+  {
+#pragma omp barrier // expected-error {{region cannot be closely nested inside 'masked' region}}
+    bar();
+  }
+#pragma omp masked
+  {
+#pragma omp scan // expected-error {{region cannot be closely nested inside 'masked' region}}
+    bar();
+  }
+#pragma omp masked
+  {
+#pragma omp taskwait
+    bar();
+  }
+#pragma omp masked
+  {
+#pragma omp flush
+    bar();
+  }
+#pragma omp masked
+  {
+#pragma omp ordered // expected-error {{region cannot be closely nested inside 'masked' region; perhaps you forget to enclose 'omp ordered' directive into a for or a parallel for region with 'ordered' clause?}}
+    bar();
+  }
+#pragma omp masked
+  {
+#pragma omp atomic
+    ++a;
+  }
+#pragma omp masked
+  {
+#pragma omp target
+    ++a;
+  }
+#pragma omp masked
+  {
+#pragma omp target parallel
+    ++a;
+  }
+#pragma omp masked
+  {
+#pragma omp target parallel for
+    for (int i = 0; i < 10; ++i)
+      ;
+  }
+#pragma omp masked
+  {
+#pragma omp target enter data map(to: a)
+    ++a;
+  }
+#pragma omp masked
+  {
+#pragma omp target exit data map(from: a)
+    ++a;
+  }
+#pragma omp masked
+  {
+#pragma omp teams // expected-error {{region cannot be closely nested inside 'masked' region; perhaps you forget to enclose 'omp teams' directive into a target region?}}
+    ++a;
+  }
+#pragma omp masked
+  {
+#pragma omp taskloop
+  for (int i = 0; i < 10; ++i)
+    ++a;
+  }
+#pragma omp masked
+  {
+#pragma omp distribute // expected-error {{region cannot be closely nested inside 'masked' region; perhaps you forget to enclose 'omp distribute' directive into a teams region?}}
+    for (int i = 0; i < 10; ++i)
+      ;
+  }
+#pragma omp masked
+  {
+#pragma omp target update to(a)
+    ++a;
+  }
+#pragma omp masked
+  {
+#pragma omp distribute parallel for // expected-error {{region cannot be closely nested inside 'masked' region; perhaps you forget to enclose 'omp distribute parallel for' directive into a teams region?}}
+    for (int i = 0; i < 10; ++i)
+      ;
+  }
+#pragma omp masked
+  {
+#pragma omp distribute parallel for simd // expected-error {{region cannot be closely nested inside 'masked' 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 masked
+  {
+#pragma omp distribute simd // expected-error {{region cannot be closely nested inside 'masked' region; perhaps you forget to enclose 'omp distribute simd' directive into a teams region?}}
+    for (int i = 0; i < 10; ++i)
+      ;
+  }
+#pragma omp masked
+  {
+#pragma omp target simd // OK
+    for (int i = 0; i < 10; ++i)
+      ;
+  }
+#pragma omp masked
+  {
+#pragma omp teams distribute // expected-error {{region cannot be closely nested inside 'masked' region; perhaps you forget to enclose 'omp teams distribute' directive into a target region?}}
+    for (int i = 0; i < 10; ++i)
+      ;
+  }
+#pragma omp masked
+  {
+#pragma omp teams distribute simd // expected-error {{region cannot be closely nested inside 'masked' region; perhaps you forget to enclose 'omp teams distribute simd' directive into a target region?}}
+    for (int i = 0; i < 10; ++i)
+      ;
+  }
+#pragma omp masked
+  {
+#pragma omp teams distribute parallel for simd // expected-error {{region cannot be closely nested inside 'masked' 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 masked
+  {
+#pragma omp teams distribute parallel for // expected-error {{region cannot be closely nested inside 'masked' 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 masked
+  {
+#pragma omp target teams // OK
+    a++;
+  }
+#pragma omp masked
+  {
+#pragma omp target teams distribute // OK
+    for (int i = 0; i < 10; ++i)
+      ;
+  }
+#pragma omp masked
+  {
+#pragma omp target teams distribute parallel for // OK
+    for (int i = 0; i < 10; ++i)
+      ;
+  }
+#pragma omp masked
+  {
+#pragma omp target teams distribute parallel for simd // OK
+    for (int i = 0; i < 10; ++i)
+      ;
+  }
+#pragma omp masked
+  {
+#pragma omp target teams distribute simd // OK
+    for (int i = 0; i < 10; ++i)
+      ;
+  }
+
 // CRITICAL DIRECTIVE
 #pragma omp critical
   {
 #pragma omp for // expected-error {{region cannot be closely nested inside 'critical' region; perhaps you forget to enclose 'omp for' directive into a parallel region?}}
     for (int i = 0; i < 10; ++i)
       ;
   }
 #pragma omp critical
#pragma omp single // expected-error {{region cannot be closely nested inside 'critical' region; perhaps you forget to enclose 'omp single' directive into a parallel region?}}
     }
   }
 #pragma omp critical
   {
 #pragma omp master // OK, though second 'master' is redundant
     {
       bar();
     }
+#pragma omp masked // OK, though second 'master' is redundant
+    {
+      bar();
+    }
   }
 #pragma omp critical
   {
 #pragma omp critical
     {
       bar();
     }
   }
 #pragma omp critical
   {
 #pragma omp sections // expected-error {{region cannot be closely nested inside 'critical' region; perhaps you forget to enclose 'omp sections' directive into a parallel region?}}
     {
       bar();
     }
   }
 #pragma omp critical
   {
 #pragma omp parallel
     {
 #pragma omp master // OK
       {
         bar();
       }
+#pragma omp masked // OK
+      {
+        bar();
+      }
 #pragma omp for // OK
       for (int i = 0; i < 10; ++i)
         ;
 #pragma omp for simd // OK
       for (int i = 0; i < 10; ++i)
         ;
 #pragma omp sections // OK
       {

 #pragma omp single // expected-error {{region cannot be closely nested inside 'parallel for' region; perhaps you forget to enclose 'omp single' directive into a parallel region?}}
     {
       bar();
     }
 #pragma omp master // expected-error {{region cannot be closely nested inside 'parallel for' region}}
     {
       bar();
     }
+#pragma omp masked // expected-error {{region cannot be closely nested inside 'parallel for' region}}
+    {
+      bar();
+    }
 #pragma omp critical
     {
       bar();
     }
   }
 #pragma omp parallel for
   for (int i = 0; i < 10; ++i) {
 #pragma omp parallel
     {
 #pragma omp single // OK
       {
         bar();
       }
 #pragma omp master // OK
       {
         bar();
       }
+#pragma omp masked // OK
+      {
+        bar();
+      }
 #pragma omp critical // OK
       {
         bar();
       }
 #pragma omp for // OK
       for (int i = 0; i < 10; ++i)
         ;
 #pragma omp for simd // OK

 
 #pragma omp parallel for simd
   for (int i = 0; i < 10; ++i) {
 #pragma omp master // 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 masked // 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 critical // expected-error {{OpenMP constructs may not be nested inside a simd region}}
     {
       bar();
     }
   }

 #pragma omp parallel sections
   {
 #pragma omp section
     {
 #pragma omp single // expected-error {{region cannot be closely nested inside 'section' region; perhaps you forget to enclose 'omp single' directive into a parallel region?}}
       bar();
 #pragma omp master // expected-error {{region cannot be closely nested inside 'section' region}}
       bar();
+#pragma omp masked // expected-error {{region cannot be closely nested inside 'section' region}}
+      bar();
 #pragma omp critical
       bar();
     }
   }
 #pragma omp parallel sections
   {
 #pragma omp parallel
     {
 #pragma omp single // OK
       {
         bar();
       }
 #pragma omp master // OK
       {
         bar();
       }
+#pragma omp masked // OK
+      {
+        bar();
+      }
 #pragma omp critical // OK
       {
         bar();
       }
 #pragma omp for // OK
       for (int i = 0; i < 10; ++i)
         ;
 #pragma omp for simd // OK
#pragma omp section // expected-error {{'omp section' directive must be closely nested to a sections region, not a task region}}
   }
 #pragma omp task
 #pragma omp single // expected-error {{region cannot be closely nested inside 'task' region; perhaps you forget to enclose 'omp single' directive into a parallel region?}}
   bar();
 #pragma omp task
 #pragma omp master // expected-error {{region cannot be closely nested inside 'task' region}}
   bar();
 #pragma omp task
+#pragma omp masked // expected-error {{region cannot be closely nested inside 'task' region}}
+  bar();
+#pragma omp task
 #pragma omp critical
   bar();
 #pragma omp task
 #pragma omp parallel for
   for (int i = 0; i < 10; ++i)
     ;
 #pragma omp task
 #pragma omp parallel for simd
#pragma omp master // expected-error {{OpenMP constructs may not be nested inside an atomic 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 masked // expected-error {{OpenMP constructs may not be nested inside an atomic 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 critical // expected-error {{OpenMP constructs may not be nested inside an atomic 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 single
   bar();
 
 #pragma omp target
 #pragma omp master
   {
     bar();
   }
 #pragma omp target
+#pragma omp masked
+  {
+    bar();
+  }
+#pragma omp target
 #pragma omp critical
   {
     bar();
   }
 #pragma omp target
 #pragma omp parallel for
   for (int i = 0; i < 10; ++i)
     ;
#pragma omp single
   bar();
 
 #pragma omp target parallel
 #pragma omp master
   {
     bar();
   }
 #pragma omp target parallel
+#pragma omp masked
+  {
+    bar();
+  }
+#pragma omp target parallel
 #pragma omp critical
   {
     bar();
   }
 #pragma omp target parallel
 #pragma omp parallel for
   for (int i = 0; i < 10; ++i)
     ;

 
 #pragma omp target parallel for
   for (int i = 0; i < 10; ++i) {
 #pragma omp master // expected-error {{region cannot be closely nested inside 'target parallel for' region}}
     {
       bar();
     }
   }
+#pragma omp target parallel for
+  for (int i = 0; i < 10; ++i) {
+#pragma omp masked // expected-error {{region cannot be closely nested inside 'target parallel for' region}}
+    {
+      bar();
+    }
+  }
 
 #pragma omp target parallel for
   for (int i = 0; i < 10; ++i) {
 #pragma omp critical
     {
       bar();
     }
   }

 #pragma omp target
 #pragma omp teams
 #pragma omp master // expected-error {{region cannot be closely nested inside 'teams' region; perhaps you forget to enclose 'omp master' directive into a parallel region?}}
   {
     bar();
   }
 #pragma omp target
 #pragma omp teams
+#pragma omp masked // expected-error {{region cannot be closely nested inside 'teams' region; perhaps you forget to enclose 'omp masked' directive into a parallel region?}}
+  {
+    bar();
+  }
+#pragma omp target
+#pragma omp teams
 #pragma omp critical // expected-error {{region cannot be closely nested inside 'teams' region; perhaps you forget to enclose 'omp critical' directive into a parallel region?}}
   {
     bar();
   }
 #pragma omp target
 #pragma omp teams
 #pragma omp parallel for
   for (int i = 0; i < 10; ++i)
#pragma omp taskloop
   for (int i = 0; i < 10; ++i) {
 #pragma omp master // expected-error {{region cannot be closely nested inside 'taskloop' region}}
     {
       bar();
     }
   }
 #pragma omp taskloop
   for (int i = 0; i < 10; ++i) {
+#pragma omp masked // expected-error {{region cannot be closely nested inside 'taskloop' region}}
+    {
+      bar();
+    }
+  }
+#pragma omp taskloop
+  for (int i = 0; i < 10; ++i) {
 #pragma omp critical
     {
       bar();
     }
   }
 #pragma omp taskloop
   for (int i = 0; i < 10; ++i) {
 #pragma omp parallel
#pragma omp master
     {
       bar();
     }
   }
 #pragma omp target
 #pragma omp teams
 #pragma omp distribute
   for (int i = 0; i < 10; ++i) {
+#pragma omp masked
+    {
+      bar();
+    }
+  }
+#pragma omp target
+#pragma omp teams
+#pragma omp distribute
+  for (int i = 0; i < 10; ++i) {
 #pragma omp critical
     {
       bar();
     }
   }
 #pragma omp target
 #pragma omp teams
 #pragma omp distribute
#pragma omp master // expected-error {{region cannot be closely nested inside 'distribute parallel for' region}}
     {
       bar();
     }
   }
 #pragma omp target
 #pragma omp teams
 #pragma omp distribute parallel for
   for (int i = 0; i < 10; ++i) {
+#pragma omp masked // expected-error {{region cannot be closely nested inside 'distribute parallel for' region}}
+    {
+      bar();
+    }
+  }
+#pragma omp target
+#pragma omp teams
+#pragma omp distribute parallel for
+  for (int i = 0; i < 10; ++i) {
 #pragma omp critical
     {
       bar();
     }
   }
 #pragma omp target
 #pragma omp teams
 #pragma omp distribute parallel for
#pragma omp master // 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 masked // 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 critical // 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
#pragma omp master // 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 masked // 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 critical // expected-error {{OpenMP constructs may not be nested inside a simd region}}
     {
       bar();
     }
   }
 #pragma omp target
 #pragma omp teams
 #pragma omp distribute simd
#pragma omp target simd
   for (int i = 0; i < 10; ++i) {
 #pragma omp master // 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 masked // 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 critical // 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 parallel // expected-error {{OpenMP constructs may not be nested inside a simd region}}

 #pragma omp master // OK
     {
       bar();
     }
   }
 #pragma omp target
 #pragma omp teams distribute
   for (int i = 0; i < 10; ++i) {
+#pragma omp masked // OK
+    {
+      bar();
+    }
+  }
+#pragma omp target
+#pragma omp teams distribute
+  for (int i = 0; i < 10; ++i) {
 #pragma omp critical // OK
     {
       bar();
     }
   }
 #pragma omp target
 #pragma omp teams distribute
   for (int i = 0; i < 10; ++i) {

 #pragma omp master // 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 masked // 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 critical // 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 master // 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 masked // 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 critical // 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 master // expected-error {{region cannot be closely nested inside 'teams distribute parallel for' region}}
     {
       bar();
     }
   }
 #pragma omp target
 #pragma omp teams distribute parallel for
   for (int i = 0; i < 10; ++i) {
+#pragma omp masked // expected-error {{region cannot be closely nested inside 'teams distribute parallel for' region}}
+    {
+      bar();
+    }
+  }
+#pragma omp target
+#pragma omp teams distribute parallel for
+  for (int i = 0; i < 10; ++i) {
 #pragma omp critical // OK
     {
       bar();
     }
   }
 #pragma omp target
 #pragma omp teams distribute parallel for
   for (int i = 0; i < 10; ++i) {
#pragma omp single // expected-error {{region cannot be closely nested inside 'target teams' region; perhaps you forget to enclose 'omp single' directive into a parallel region?}}
   bar();
 
 #pragma omp target teams
 #pragma omp master // expected-error {{region cannot be closely nested inside 'target teams' region; perhaps you forget to enclose 'omp master' directive into a parallel region?}}
   {
     bar();
   }
 #pragma omp target teams
+#pragma omp masked // expected-error {{region cannot be closely nested inside 'target teams' region; perhaps you forget to enclose 'omp masked' directive into a parallel region?}}
+  {
+    bar();
+  }
+#pragma omp target teams
 #pragma omp critical // expected-error {{region cannot be closely nested inside 'target teams' region; perhaps you forget to enclose 'omp critical' directive into a parallel region?}}
   {
     bar();
   }
 #pragma omp target teams
 #pragma omp parallel for
   for (int i = 0; i < 10; ++i)
     ;
#pragma omp target teams distribute
   for (int i = 0; i < 10; ++i) {
 #pragma omp master // OK
     {
       bar();
     }
   }
 #pragma omp target teams distribute
   for (int i = 0; i < 10; ++i) {
+#pragma omp masked // OK
+    {
+      bar();
+    }
+  }
+#pragma omp target teams distribute
+  for (int i = 0; i < 10; ++i) {
 #pragma omp critical // OK
     {
       bar();
     }
   }
 #pragma omp target teams distribute
   for (int i = 0; i < 10; ++i) {
 #pragma omp parallel // OK
#pragma omp target teams distribute parallel for
   for (int i = 0; i < 10; ++i) {
 #pragma omp master // expected-error {{region cannot be closely nested inside 'target teams distribute parallel for' region}}
     {
       bar();
     }
   }
 #pragma omp target teams distribute parallel for
   for (int i = 0; i < 10; ++i) {
+#pragma omp masked // expected-error {{region cannot be closely nested inside 'target teams distribute parallel for' region}}
+    {
+      bar();
+    }
+  }
+#pragma omp target teams distribute parallel for
+  for (int i = 0; i < 10; ++i) {
 #pragma omp critical // OK
     {
       bar();
     }
   }
 #pragma omp target teams distribute parallel for
   for (int i = 0; i < 10; ++i) {
 #pragma omp parallel // OK
#pragma omp target teams distribute parallel for simd
   for (int i = 0; i < 10; ++i) {
 #pragma omp master // 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 masked // 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 critical // 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 parallel // 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 master // 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 masked // 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 critical // 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 parallel // expected-error {{OpenMP constructs may not be nested inside a simd region}}

clang/tools/libclang/CIndex.cpp

 void OMPClauseEnqueue::VisitOMPNovariantsClause(const OMPNovariantsClause *C) {
   Visitor->AddStmt(C->getCondition());
 }
 
 void OMPClauseEnqueue::VisitOMPNocontextClause(const OMPNocontextClause *C) {
   Visitor->AddStmt(C->getCondition());
 }
 
+void OMPClauseEnqueue::VisitOMPFilterClause(const OMPFilterClause *C) {
+  VisitOMPClauseWithPreInit(C);
+  Visitor->AddStmt(C->getThreadID());
+}
+
 void OMPClauseEnqueue::VisitOMPUnifiedAddressClause(
     const OMPUnifiedAddressClause *) {}
 
 void OMPClauseEnqueue::VisitOMPUnifiedSharedMemoryClause(
     const OMPUnifiedSharedMemoryClause *) {}
 
 void OMPClauseEnqueue::VisitOMPReverseOffloadClause(
     const OMPReverseOffloadClause *) {}
case CXCursor_OMPTargetTeamsDistributeParallelForSimdDirective:
     return cxstring::createRef(
         "OMPTargetTeamsDistributeParallelForSimdDirective");
   case CXCursor_OMPTargetTeamsDistributeSimdDirective:
     return cxstring::createRef("OMPTargetTeamsDistributeSimdDirective");
   case CXCursor_OMPInteropDirective:
     return cxstring::createRef("OMPInteropDirective");
   case CXCursor_OMPDispatchDirective:
     return cxstring::createRef("OMPDispatchDirective");
+  case CXCursor_OMPMaskedDirective:
+    return cxstring::createRef("OMPMaskedDirective");
   case CXCursor_OverloadCandidate:
     return cxstring::createRef("OverloadCandidate");
   case CXCursor_TypeAliasTemplateDecl:
     return cxstring::createRef("TypeAliasTemplateDecl");
   case CXCursor_StaticAssert:
     return cxstring::createRef("StaticAssert");
   case CXCursor_FriendDecl:
     return cxstring::createRef("FriendDecl");

clang/tools/libclang/CXCursor.cpp

case Stmt::OMPTargetTeamsDistributeSimdDirectiveClass:
     K = CXCursor_OMPTargetTeamsDistributeSimdDirective;
     break;
   case Stmt::OMPInteropDirectiveClass:
     K = CXCursor_OMPInteropDirective;
     break;
   case Stmt::OMPDispatchDirectiveClass:
     K = CXCursor_OMPDispatchDirective;
     break;
+  case Stmt::OMPMaskedDirectiveClass:
+    K = CXCursor_OMPMaskedDirective;
+    break;
   case Stmt::BuiltinBitCastExprClass:
     K = CXCursor_BuiltinBitCastExpr;
   }
 
   CXCursor C = {K, 0, {Parent, S, TU}};
   return C;
 }
 

flang/lib/Semantics/check-omp-structure.cpp

 CHECK_SIMPLE_CLAUSE(UsesAllocators, OMPC_uses_allocators)
 CHECK_SIMPLE_CLAUSE(Update, OMPC_update)
 CHECK_SIMPLE_CLAUSE(UseDeviceAddr, OMPC_use_device_addr)
 CHECK_SIMPLE_CLAUSE(Write, OMPC_write)
 CHECK_SIMPLE_CLAUSE(Init, OMPC_init)
 CHECK_SIMPLE_CLAUSE(Use, OMPC_use)
 CHECK_SIMPLE_CLAUSE(Novariants, OMPC_novariants)
 CHECK_SIMPLE_CLAUSE(Nocontext, OMPC_nocontext)
+CHECK_SIMPLE_CLAUSE(Filter, OMPC_filter)
 
 CHECK_REQ_SCALAR_INT_CLAUSE(Allocator, OMPC_allocator)
 CHECK_REQ_SCALAR_INT_CLAUSE(Grainsize, OMPC_grainsize)
 CHECK_REQ_SCALAR_INT_CLAUSE(NumTasks, OMPC_num_tasks)
 CHECK_REQ_SCALAR_INT_CLAUSE(NumTeams, OMPC_num_teams)
 CHECK_REQ_SCALAR_INT_CLAUSE(NumThreads, OMPC_num_threads)
 CHECK_REQ_SCALAR_INT_CLAUSE(Priority, OMPC_priority)
 CHECK_REQ_SCALAR_INT_CLAUSE(ThreadLimit, OMPC_thread_limit)

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

def OMPC_Unknown : Clause<"unknown"> {
   let isImplicit = true;
   let isDefault = true;
 }
 def OMPC_Link : Clause<"link"> {
   let flangClass = "OmpObjectList";
 }
 def OMPC_Inbranch : Clause<"inbranch"> {}
 def OMPC_Notinbranch : Clause<"notinbranch"> {}
+def OMPC_Filter : Clause<"filter"> {
+  let clangClass = "OMPFilterClause";
+  let flangClass = "ScalarIntExpr";
+}
 
 //===----------------------------------------------------------------------===//
 // Definition of OpenMP directives
 //===----------------------------------------------------------------------===//
 
 def OMP_ThreadPrivate : Directive<"threadprivate"> {}
 def OMP_Parallel : Directive<"parallel"> {
   let allowedClauses = [
let allowedClauses = [
     VersionedClause<OMPC_Device>,
     VersionedClause<OMPC_IsDevicePtr>,
     VersionedClause<OMPC_NoWait>,
     VersionedClause<OMPC_Depend>,
     VersionedClause<OMPC_Novariants>,
     VersionedClause<OMPC_Nocontext>
   ];
 }
+def OMP_masked : Directive<"masked"> {
+  let allowedClauses = [
+    VersionedClause<OMPC_Filter, 51>
+  ];
+}
 def OMP_Unknown : Directive<"unknown"> {
   let isDefault = true;
 }