[OPENMP51]Initial support for the dispatch directive

[mikerice]

Summary

Added basic parsing/sema/serialization support for dispatch directive.

Starting support for 'omp dispatch'. We are working on additional patches for the 'novariants' and 'nocontext' and 'adjust_args' and 'append_args' for 'omp declare variant'.

[ABataev]

clang/include/clang/AST/StmtOpenMP.h

5150

final

5201

const

clang/lib/Basic/OpenMPKinds.cpp

649–651

Why do you need to push OMPD_dispatch here? Maybe OMPD_unknown should be enough?

clang/lib/Sema/SemaOpenMP.cpp

9766–9768

Why Expr->IgnoreParenImpCasts() does not work here?

[mikerice]

Thanks for the review.

clang/lib/Sema/SemaOpenMP.cpp

9766–9768

No reason not to use IgnoreParenImpCasts() instead of IgnoreParens() as far as I know. That should eliminate the need for visiting MaterializeTemporaryExpr. It unfortunately doesn't skip over CXXBindTemporaryExpr. Or were you suggesting something else?

[ABataev]

clang/lib/Sema/SemaOpenMP.cpp

9766–9768

Then just extend IgnoreParenImpCasts to support MaterializeTemporaryExpr and control it by the parameter.

[mikerice]

clang/lib/Sema/SemaOpenMP.cpp

9766–9768

CXXBindTemporaryExpr isn't the only reason to use the visitor. It ends up handling the top level statements and ExprWithCleanups easily and is fairly understandable to me. I went ahead and hand wrote the code to see what it would look like. Turns out to be long chains of one line if statement like this:

static Expr *getDirectCallExpr(Expr *E) {
  E = E->IgnoreParenImpCasts();
  if (auto *BTE = dyn_cast<CXXBindTemporaryExpr>(E))
    E = BTE->getSubExpr();
  if (auto *CE = dyn_cast<CallExpr>(E))
    if (CE->getDirectCallee())
      return E;
  return nullptr;
}

  SourceLocation TargetCallLoc;

  if (!CurContext->isDependentContext()) {
    Expr *TargetCall = nullptr;

    auto *E = dyn_cast<Expr>(S);
    if (!E) {
      Diag(S->getBeginLoc(), diag::err_omp_dispatch_statement_call);
      return StmtError();
    }

    if (auto *EWC = dyn_cast<ExprWithCleanups>(S))
      E = EWC->getSubExpr();

    E = E->IgnoreParenImpCasts();

    if (auto *CastE = dyn_cast<CastExpr>(E))
      if (CastE->getCastKind() == CK_ToVoid)
        E = CastE->getSubExpr()->IgnoreParenImpCasts();

    if (auto *COCE = dyn_cast<CXXOperatorCallExpr>(E)) {
      if (COCE->getOperator() == OO_Equal) {
        if (Expr *TE = getDirectCallExpr(COCE->getArg(1)))
          TargetCall = TE;
        else if (COCE->getDirectCallee())
          TargetCall = COCE;
      }
    } else if (auto *BO = dyn_cast<BinaryOperator>(E)) {
      if (BO->getOpcode() == BO_Assign)
        if (Expr *TE = getDirectCallExpr(BO->getRHS()))
          TargetCall = TE;
    } else if (auto *CE = dyn_cast<CallExpr>(E)) {
      if (CE->getDirectCallee())
        TargetCall = E;
    }
    if (!TargetCall) {
      Diag(E->getBeginLoc(), diag::err_omp_dispatch_statement_call);
      return StmtError();
    }
    TargetCallLoc = TargetCall->getExprLoc();
  }

I didn't originally write the visitor code so I am not attached to it or anything. Do you think this is better? Is there some rule-of-thumb when to use visitors and when to write it out by hand?

[ABataev]

clang/lib/Sema/SemaOpenMP.cpp

9766–9768

I think something like this will work

static Expr *getDirectCallExpr(Expr *E) {
  E = E->IgnoreParenCasts();
  if (auto *CE = dyn_cast<CallExpr>(E))
    if (CE->getDirectCallee())
      return E;
  return nullptr;
}

  SourceLocation TargetCallLoc;

  if (!CurContext->isDependentContext()) {
    Expr *TargetCall = nullptr;

    auto *E = dyn_cast<Expr>(S);
    if (!E) {
      Diag(S->getBeginLoc(), diag::err_omp_dispatch_statement_call);
      return StmtError();
    }

    E = E->IgnoreParenCasts();

    if (auto *BO = dyn_cast<BinaryOperator>(E)) {
      if (BO->getOpcode() == BO_Assign)
        TargetCall = getDirectCallExpr(BO->getRHS());
    } else {
      if (auto *COCE = dyn_cast<CXXOperatorCallExpr>(E))
        if (COCE->getOperator() == OO_Equal)
          TargetCall = getDirectCallExpr(COCE->getArg(1));
      if (!TargetCall)
        TargetCall = getDirectCallExpr(E);
    }
    if (!TargetCall) {
      Diag(E->getBeginLoc(), diag::err_omp_dispatch_statement_call);
      return StmtError();
    }
    TargetCallLoc = TargetCall->getExprLoc();
  }

[mikerice]

clang/lib/Sema/SemaOpenMP.cpp

9766–9768

Thanks. That's pretty good but it does not handle the CXXBindTemporaryExpr so the test:

Obj o;
o = foo_obj();

CXXOperatorCallExpr 0x5b50b0 'struct Obj' lvalue '='
|-ImplicitCastExpr 0x5b5098 'struct Obj &(*)(const struct Obj &) noexcept' <FunctionToPointerDecay>
| `-DeclRefExpr 0x5b4f98 'struct Obj &(const struct Obj &) noexcept' lvalue CXXMethod 0x5b4de8 'operator=' 'struct Obj &(const struct Obj &) noexcept'
|-DeclRefExpr 0x5b4d00 'struct Obj' lvalue Var 0x5b4830 'o' 'struct Obj'
`-MaterializeTemporaryExpr 0x5b4f80 'const struct Obj' lvalue
  `-ImplicitCastExpr 0x5b4f68 'const struct Obj' <NoOp>
    `-CXXBindTemporaryExpr 0x5b4dc8 'struct Obj' (CXXTemporary 0x5b4dc8)
      `-CallExpr 0x5b4da0 'struct Obj'
        `-ImplicitCastExpr 0x5b4d88 'struct Obj (*)(void)' <FunctionToPointerDecay>
          `-DeclRefExpr 0x5b4d68 'struct Obj (void)' lvalue Function 0x5af938 'foo_obj' 'struct Obj (void)'

Would choose the operator= call as the target instead of foo_obj(). I am assuming the user would want foo_obj here.

I am not sure there is a single 'Ignore' call that works here. And this case has two levels. An additional call to IgnoreImplicit() in getDirectCallExpr it should take care of it though. I'll upload a new patch.

[ABataev]

clang/lib/Sema/SemaOpenMP.cpp

9766–9768

Yes, just add IgnoreImplicit() call

[mikerice]

Addressed review comments.

[ABataev]

clang/lib/Sema/SemaOpenMP.cpp

9799

E->IgnoreParenCasts()->IgnoreImplicit();?

[mikerice]

Addressed review comment.

[ABataev]

LG

[jdoerfert]

Cool, are you expecting to hook this up to the variant selection logic as well? @jyu2 similarly do you intend to hook up novariant?

We should also update https://clang.llvm.org/docs/OpenMPSupport.html to claim parts you are working on (upstreaming).

[mikerice]

@jyu2 is currently working on the novariants and nocontext clauses. We are still working on the overall construct so I'm not sure yet what more we will have to contribute.

I'll look into updating the support doc.

clang/include/clang-c/Index.h

enum CXCursorKind {
   /** OpenMP canonical loop.
    */
   CXCursor_OMPCanonicalLoop = 289,
 
   /** OpenMP interop directive.
    */
   CXCursor_OMPInteropDirective = 290,
 
-  CXCursor_LastStmt = CXCursor_OMPInteropDirective,
+  /** OpenMP dispatch directive.
+   */
+  CXCursor_OMPDispatchDirective = 291,
+
+  CXCursor_LastStmt = CXCursor_OMPDispatchDirective,
 
   /**
    * 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/RecursiveASTVisitor.h

DEF_TRAVERSE_STMT(OMPTargetTeamsDistributeParallelForSimdDirective,
                   { TRY_TO(TraverseOMPExecutableDirective(S)); })
 
 DEF_TRAVERSE_STMT(OMPTargetTeamsDistributeSimdDirective,
                   { TRY_TO(TraverseOMPExecutableDirective(S)); })
 
 DEF_TRAVERSE_STMT(OMPInteropDirective,
                   { TRY_TO(TraverseOMPExecutableDirective(S)); })
 
+DEF_TRAVERSE_STMT(OMPDispatchDirective,
+                  { 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)                                         \

clang/include/clang/AST/StmtOpenMP.h

public:
   static OMPInteropDirective *CreateEmpty(const ASTContext &C,
                                           unsigned NumClauses, EmptyShell);
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == OMPInteropDirectiveClass;
   }
 };
 
+/// This represents '#pragma omp dispatch' directive.
+///
+/// \code
+/// #pragma omp dispatch device(dnum)
+/// \endcode
+/// This example shows a directive '#pragma omp dispatch' with a
+/// device clause with variable 'dnum'.
+///
+class OMPDispatchDirective : public OMPExecutableDirective {
+  friend class ASTStmtReader;
+  friend class OMPExecutableDirective;
+
+  /// The location of the target-call.
+  SourceLocation TargetCallLoc;
+
+  /// Set the location of the target-call.
+  void setTargetCallLoc(SourceLocation Loc) { TargetCallLoc = Loc; }
+
+  /// Build directive with the given start and end location.
+  ///
+  /// \param StartLoc Starting location of the directive kind.
+  /// \param EndLoc Ending location of the directive.
+  ///
+  OMPDispatchDirective(SourceLocation StartLoc, SourceLocation EndLoc)
+      : OMPExecutableDirective(OMPDispatchDirectiveClass,
+                               llvm::omp::OMPD_dispatch, StartLoc, EndLoc) {}
+
+  /// Build an empty directive.
+  ///
+  explicit OMPDispatchDirective()
+      : OMPExecutableDirective(OMPDispatchDirectiveClass,
+                               llvm::omp::OMPD_dispatch, SourceLocation(),
+                               SourceLocation()) {}
+
+public:
+  /// Creates directive with a list of \a Clauses.
+  ///
+  /// \param C AST context.
+  /// \param StartLoc Starting location of the directive kind.
+  /// \param EndLoc Ending Location of the directive.
+  /// \param Clauses List of clauses.
+  /// \param AssociatedStmt Statement, associated with the directive.
+  /// \param TargetCallLoc Location of the target-call.
+  ///
+  static OMPDispatchDirective *
+  Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
+         ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
+         SourceLocation TargetCallLoc);
+
+  /// Creates an empty directive with the place for \a NumClauses
+  /// clauses.
+  ///
+  /// \param C AST context.
+  /// \param NumClauses Number of clauses.
+  ///
+  static OMPDispatchDirective *CreateEmpty(const ASTContext &C,
+                                           unsigned NumClauses, EmptyShell);
+
+  /// Return location of target-call.
+  SourceLocation getTargetCallLoc() { return TargetCallLoc; }
+
+  static bool classof(const Stmt *T) {
+    return T->getStmtClass() == OMPDispatchDirectiveClass;
+  }
+};
+
 } // end namespace clang
 
 #endif

clang/include/clang/Basic/DiagnosticSemaKinds.td

def err_omp_interop_variable_wrong_type : Error<
   "interop variable must be of type 'omp_interop_t'">;
 def err_omp_interop_prefer_type : Error<
   "prefer_list item must be a string literal or constant integral "
   "expression">;
 def err_omp_interop_bad_depend_clause : Error<
   "'depend' clause requires the 'targetsync' interop type">;
 def err_omp_interop_var_multiple_actions : Error<
   "interop variable %0 used in multiple action clauses">;
+def err_omp_dispatch_statement_call
+    : Error<"statement after '#pragma omp dispatch' must be a direct call"
+            " to a target function or an assignment to one">;
 } // end of OpenMP category
 
 let CategoryName = "Related Result Type Issue" in {
 // Objective-C related result type compatibility
 def warn_related_result_type_compatibility_class : Warning<
   "method is expected to return an instance of its class type "
   "%diff{$, but is declared to return $|"
   ", but is declared to return different type}0,1">;

clang/include/clang/Basic/StmtNodes.td

 def OMPTeamsDistributeParallelForSimdDirective : StmtNode<OMPLoopDirective>;
 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>;

clang/include/clang/Sema/Sema.h

public:
   /// parsing of the associated statement.
   StmtResult ActOnOpenMPTargetTeamsDistributeSimdDirective(
       ArrayRef<OMPClause *> Clauses, Stmt *AStmt, SourceLocation StartLoc,
       SourceLocation EndLoc, VarsWithInheritedDSAType &VarsWithImplicitDSA);
   /// Called on well-formed '\#pragma omp interop'.
   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);
 
   /// 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,

clang/include/clang/Serialization/ASTBitCodes.h

enum StmtCode {
   STMT_OMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE,
   STMT_OMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE,
   STMT_OMP_TARGET_TEAMS_DIRECTIVE,
   STMT_OMP_TARGET_TEAMS_DISTRIBUTE_DIRECTIVE,
   STMT_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE,
   STMT_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE,
   STMT_OMP_TARGET_TEAMS_DISTRIBUTE_SIMD_DIRECTIVE,
   STMT_OMP_INTEROP_DIRECTIVE,
+  STMT_OMP_DISPATCH_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/StmtOpenMP.cpp

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

clang/lib/AST/StmtPrinter.cpp

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

clang/lib/AST/StmtProfile.cpp

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

clang/lib/Basic/OpenMPKinds.cpp

case OMPD_parallel_master_taskloop_simd:
     break;
   case OMPD_target_teams_distribute_parallel_for:
   case OMPD_target_teams_distribute_parallel_for_simd:
     CaptureRegions.push_back(OMPD_task);
     CaptureRegions.push_back(OMPD_target);
     CaptureRegions.push_back(OMPD_teams);
     CaptureRegions.push_back(OMPD_parallel);
     break;
+  case OMPD_dispatch:
+    CaptureRegions.push_back(OMPD_dispatch);
+    break;
   case OMPD_simd:
   case OMPD_for:
   case OMPD_for_simd:
   case OMPD_sections:
   case OMPD_section:
   case OMPD_single:
   case OMPD_master:
   case OMPD_critical:

clang/lib/CodeGen/CGStmt.cpp

case Stmt::OMPTargetTeamsDistributeParallelForSimdDirectiveClass:
     break;
   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.");
+    break;
   }
 }
 
 bool CodeGenFunction::EmitSimpleStmt(const Stmt *S,
                                      ArrayRef<const Attr *> Attrs) {
   switch (S->getStmtClass()) {
   default:
     return false;

clang/lib/Parse/ParseOpenMP.cpp

Parser::DeclGroupPtrTy Parser::ParseOpenMPDeclarativeDirectiveWithExtDecl(
   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:
     Diag(Tok, diag::err_omp_unexpected_directive)
         << 1 << getOpenMPDirectiveName(DKind);
     break;
   default:
     break;
   }
   while (Tok.isNot(tok::annot_pragma_openmp_end))
     ConsumeAnyToken();
Parser::ParseOpenMPDeclarativeOrExecutableDirective(ParsedStmtContext StmtCtx) {
   case OMPD_teams_distribute:
   case OMPD_teams_distribute_simd:
   case OMPD_teams_distribute_parallel_for_simd:
   case OMPD_teams_distribute_parallel_for:
   case OMPD_target_teams:
   case OMPD_target_teams_distribute:
   case OMPD_target_teams_distribute_parallel_for:
   case OMPD_target_teams_distribute_parallel_for_simd:
-  case OMPD_target_teams_distribute_simd: {
+  case OMPD_target_teams_distribute_simd:
+  case OMPD_dispatch: {
     // Special processing for flush and depobj clauses.
     Token ImplicitTok;
     bool ImplicitClauseAllowed = false;
     if (DKind == OMPD_flush || DKind == OMPD_depobj) {
       ImplicitTok = Tok;
       ImplicitClauseAllowed = true;
     }
     ConsumeToken();

clang/lib/Sema/SemaExceptionSpec.cpp

CanThrowResult Sema::canThrow(const Stmt *S) {
   case Stmt::OMPTaskwaitDirectiveClass:
   case Stmt::OMPTaskyieldDirectiveClass:
   case Stmt::OMPTeamsDirectiveClass:
   case Stmt::OMPTeamsDistributeDirectiveClass:
   case Stmt::OMPTeamsDistributeParallelForDirectiveClass:
   case Stmt::OMPTeamsDistributeParallelForSimdDirectiveClass:
   case Stmt::OMPTeamsDistributeSimdDirectiveClass:
   case Stmt::OMPInteropDirectiveClass:
+  case Stmt::OMPDispatchDirectiveClass:
   case Stmt::ReturnStmtClass:
   case Stmt::SEHExceptStmtClass:
   case Stmt::SEHFinallyStmtClass:
   case Stmt::SEHLeaveStmtClass:
   case Stmt::SEHTryStmtClass:
   case Stmt::SwitchStmtClass:
   case Stmt::WhileStmtClass:
     return canSubStmtsThrow(*this, S);

clang/lib/Sema/SemaOpenMP.cpp

void Sema::ActOnOpenMPRegionStart(OpenMPDirectiveKind DKind, Scope *CurScope) {
   case OMPD_for:
   case OMPD_for_simd:
   case OMPD_sections:
   case OMPD_single:
   case OMPD_taskgroup:
   case OMPD_distribute:
   case OMPD_distribute_simd:
   case OMPD_ordered:
-  case OMPD_target_data: {
+  case OMPD_target_data:
+  case OMPD_dispatch: {
     Sema::CapturedParamNameType Params[] = {
         std::make_pair(StringRef(), QualType()) // __context with shared vars
     };
     ActOnCapturedRegionStart(DSAStack->getConstructLoc(), CurScope, CR_OpenMP,
                              Params);
     break;
   }
   case OMPD_task: {
case OMPD_target_teams_distribute_simd:
     if (LangOpts.OpenMP >= 50)
       AllowedNameModifiers.push_back(OMPD_simd);
     break;
   case OMPD_interop:
     assert(AStmt == nullptr &&
            "No associated statement allowed for 'omp interop' directive");
     Res = ActOnOpenMPInteropDirective(ClausesWithImplicit, StartLoc, EndLoc);
     break;
+  case OMPD_dispatch:
+    Res = ActOnOpenMPDispatchDirective(ClausesWithImplicit, AStmt, StartLoc,
+                                       EndLoc);
+    break;
   case OMPD_declare_target:
   case OMPD_end_declare_target:
   case OMPD_threadprivate:
   case OMPD_allocate:
   case OMPD_declare_reduction:
   case OMPD_declare_mapper:
   case OMPD_declare_simd:
   case OMPD_requires:
StmtResult Sema::ActOnOpenMPSectionDirective(Stmt *AStmt,
 
   setFunctionHasBranchProtectedScope();
   DSAStack->setParentCancelRegion(DSAStack->isCancelRegion());
 
   return OMPSectionDirective::Create(Context, StartLoc, EndLoc, AStmt,
                                      DSAStack->isCancelRegion());
 }
 
+namespace {
+class DispatchStmtExprChecker
+    : public StmtVisitor<DispatchStmtExprChecker, bool> {
+  Sema &S;
+  bool TopLevel = true;
+  Expr *TargetCall = nullptr;
+  SourceLocation ErrorLoc;
+
+public:
+  Expr *getTargetCall() { return TargetCall; }
+  SourceLocation getErrorLoc() { return ErrorLoc; }
+  bool VisitCallExpr(CallExpr *E) {
+    if (E->getDirectCallee()) {
+      TargetCall = E;
+      return true;
+    }
+    ErrorLoc = E->getBeginLoc();
+    return false;
+  }
+  bool VisitExprWithCleanups(ExprWithCleanups *E) {
+    return Visit(E->getSubExpr());
+  }
+  bool VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
+    return Visit(E->getSubExpr());
+  }
+  bool VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) {
+    return Visit(E->getSubExpr()->IgnoreParenImpCasts());
+  }
+  bool VisitStmt(Stmt *AS) {
+    ErrorLoc = AS->getBeginLoc();
+    return false;
+  }
+  bool VisitBinaryOperator(BinaryOperator *E) {
+    if (TopLevel && E->getOpcode() == BO_Assign) {
+      TopLevel = false;
+      return Visit(E->getRHS()->IgnoreParens());
+    }
+    ErrorLoc = E->getOperatorLoc();
+    return false;
+  }
+  bool VisitCastExpr(CastExpr *E) {
+    // Allow common cast to void to quiet warnings.
+    if (E->getCastKind() == CK_ToVoid)
+      return Visit(E->getSubExpr()->IgnoreParens());
+    ErrorLoc = E->getBeginLoc();
+    return false;
+  }
+  bool VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
+    if (TopLevel && E->getOperator() == OO_Equal) {
+      TopLevel = false;
+      if (Visit(E->getArg(1)->IgnoreParens()))
+        return true;
+      if (E->getDirectCallee()) {
+        TargetCall = E;
+        return true;
+      }
+    }
+    return VisitCallExpr(E);
+  }
+  explicit DispatchStmtExprChecker(Sema &S) : S(S) {}
+};
+} // namespace
+
+StmtResult Sema::ActOnOpenMPDispatchDirective(ArrayRef<OMPClause *> Clauses,
+                                              Stmt *AStmt,
+                                              SourceLocation StartLoc,
+                                              SourceLocation EndLoc) {
+  if (!AStmt)
+    return StmtError();
+
+  Stmt *S = cast<CapturedStmt>(AStmt)->getCapturedStmt();
+
+  // 5.1 OpenMP
+  // expression-stmt : an expression statement with one of the following forms:
+  //   expression = target-call ( [expression-list] );
+  //   target-call ( [expression-list] );
+
+  SourceLocation TargetCallLoc;
+  DispatchStmtExprChecker Checker(*this);
+  if (!CurContext->isDependentContext()) {
+    if (!Checker.Visit(S)) {
+      Diag(Checker.getErrorLoc(), diag::err_omp_dispatch_statement_call);
+      return StmtError();
+    }
+    assert(Checker.getTargetCall());
+    TargetCallLoc = Checker.getTargetCall()->getExprLoc();
+  }
+
+  setFunctionHasBranchProtectedScope();
+
+  return OMPDispatchDirective::Create(Context, StartLoc, EndLoc, Clauses, AStmt,
+                                      TargetCallLoc);
+}
+
 StmtResult Sema::ActOnOpenMPSingleDirective(ArrayRef<OMPClause *> Clauses,
                                             Stmt *AStmt,
                                             SourceLocation StartLoc,
                                             SourceLocation EndLoc) {
   if (!AStmt)
     return StmtError();
 
   assert(isa<CapturedStmt>(AStmt) && "Captured statement expected");
case OMPC_device:
     case OMPD_target_teams:
     case OMPD_target_parallel:
     case OMPD_target_teams_distribute:
     case OMPD_target_teams_distribute_simd:
     case OMPD_target_parallel_for:
     case OMPD_target_parallel_for_simd:
     case OMPD_target_teams_distribute_parallel_for:
     case OMPD_target_teams_distribute_parallel_for_simd:
+    case OMPD_dispatch:
       CaptureRegion = OMPD_task;
       break;
     case OMPD_target_data:
     case OMPD_interop:
       // Do not capture device-clause expressions.
       break;
     case OMPD_teams_distribute_parallel_for:
     case OMPD_teams_distribute_parallel_for_simd:

clang/lib/Sema/TreeTransform.h

TreeTransform<Derived>::TransformOMPInteropDirective(OMPInteropDirective *D) {
   DeclarationNameInfo DirName;
   getDerived().getSema().StartOpenMPDSABlock(OMPD_interop, DirName, nullptr,
                                              D->getBeginLoc());
   StmtResult Res = getDerived().TransformOMPExecutableDirective(D);
   getDerived().getSema().EndOpenMPDSABlock(Res.get());
   return Res;
 }
 
+template <typename Derived>
+StmtResult
+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;
+}
+
 //===----------------------------------------------------------------------===//
 // OpenMP clause transformation
 //===----------------------------------------------------------------------===//
 template <typename Derived>
 OMPClause *TreeTransform<Derived>::TransformOMPIfClause(OMPIfClause *C) {
   ExprResult Cond = getDerived().TransformExpr(C->getCondition());
   if (Cond.isInvalid())
     return nullptr;

clang/lib/Serialization/ASTReaderStmt.cpp

void ASTStmtReader::VisitOMPTargetTeamsDistributeSimdDirective(
   VisitOMPLoopDirective(D);
 }
 
 void ASTStmtReader::VisitOMPInteropDirective(OMPInteropDirective *D) {
   VisitStmt(D);
   VisitOMPExecutableDirective(D);
 }
 
+void ASTStmtReader::VisitOMPDispatchDirective(OMPDispatchDirective *D) {
+  VisitStmt(D);
+  VisitOMPExecutableDirective(D);
+  D->setTargetCallLoc(Record.readSourceLocation());
+}
+
 //===----------------------------------------------------------------------===//
 // 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_TARGET_TEAMS_DISTRIBUTE_SIMD_DIRECTIVE: {
       break;
     }
 
     case STMT_OMP_INTEROP_DIRECTIVE:
       S = OMPInteropDirective::CreateEmpty(
           Context, Record[ASTStmtReader::NumStmtFields], Empty);
       break;
 
+    case STMT_OMP_DISPATCH_DIRECTIVE:
+      S = OMPDispatchDirective::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/ASTWriterStmt.cpp

 }
 
 void ASTStmtWriter::VisitOMPInteropDirective(OMPInteropDirective *D) {
   VisitStmt(D);
   VisitOMPExecutableDirective(D);
   Code = serialization::STMT_OMP_INTEROP_DIRECTIVE;
 }
 
+void ASTStmtWriter::VisitOMPDispatchDirective(OMPDispatchDirective *D) {
+  VisitStmt(D);
+  VisitOMPExecutableDirective(D);
+  Record.AddSourceLocation(D->getTargetCallLoc());
+  Code = serialization::STMT_OMP_DISPATCH_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::OMPTeamsDistributeParallelForDirectiveClass:
     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::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/dispatch_ast_print.cpp

+// RUN: %clang_cc1 -triple=x86_64-pc-win32 -fopenmp -fopenmp-version=51     \
+// RUN:   -fsyntax-only -verify %s
+
+// RUN: %clang_cc1 -triple x86_64-pc-linux-gnu -fopenmp -fopenmp-version=51 \
+// RUN:   -fsyntax-only -verify %s
+
+// expected-no-diagnostics
+
+// RUN: %clang_cc1 -triple x86_64-pc-linux-gnu -fopenmp -fopenmp-version=51 \
+// RUN:   -ast-print %s | FileCheck %s --check-prefix=PRINT
+
+// RUN: %clang_cc1 -triple x86_64-pc-linux-gnu -fopenmp -fopenmp-version=51 \
+// RUN:   -ast-dump  %s | FileCheck %s --check-prefix=DUMP
+
+// RUN: %clang_cc1 -triple x86_64-pc-linux-gnu -fopenmp -fopenmp-version=51 \
+// RUN:   -emit-pch -o %t %s
+
+// RUN: %clang_cc1 -triple x86_64-pc-linux-gnu -fopenmp -fopenmp-version=51 \
+// RUN:   -include-pch %t -ast-dump-all %s | FileCheck %s --check-prefix=DUMP
+
+// RUN: %clang_cc1 -triple x86_64-pc-linux-gnu -fopenmp -fopenmp-version=51 \
+// RUN:   -include-pch %t -ast-print %s | FileCheck %s --check-prefix=PRINT
+
+#ifndef HEADER
+#define HEADER
+
+int foo_gpu(int A, int *B) { return 0;}
+//PRINT: #pragma omp declare variant(foo_gpu)
+//DUMP: FunctionDecl{{.*}} foo
+//DUMP: OMPDeclareVariantAttr {{.*}}Implicit construct{{.*}}
+#pragma omp declare variant(foo_gpu) \
+    match(construct={dispatch}, device={arch(arm)})
+int foo(int, int*);
+
+template <typename T, typename TP>
+void fooTemp() {
+  T a;
+  TP b;
+  //PRINT: #pragma omp dispatch nowait
+  //DUMP: OMPDispatchDirective
+  //DUMP: OMPNowaitClause
+  #pragma omp dispatch nowait
+  foo(a, b);
+}
+
+int *get_device_ptr();
+int get_device();
+int other();
+
+//DUMP: FunctionDecl{{.*}} test_one
+void test_one()
+{
+  int aaa, bbb, var;
+  //PRINT: #pragma omp dispatch depend(in : var) nowait
+  //DUMP: OMPDispatchDirective
+  //DUMP: OMPDependClause
+  //DUMP: OMPNowaitClause
+  #pragma omp dispatch depend(in:var) nowait
+  foo(aaa, &bbb);
+
+  int *dp = get_device_ptr();
+  int dev = get_device();
+  //PRINT: #pragma omp dispatch device(dev) is_device_ptr(dp)
+  //DUMP: OMPDispatchDirective
+  //DUMP: OMPDeviceClause
+  //DUMP: OMPIs_device_ptrClause
+  #pragma omp dispatch device(dev) is_device_ptr(dp)
+  foo(aaa, dp);
+
+  //PRINT: #pragma omp dispatch
+  //PRINT: foo(other(), &bbb);
+  //DUMP: OMPDispatchDirective
+  #pragma omp dispatch
+  foo(other(), &bbb);
+
+  fooTemp<int, int*>();
+}
+
+struct Obj {
+  Obj();
+  ~Obj();
+  int disp_method_variant1();
+  #pragma omp declare variant(disp_method_variant1)                            \
+    match(construct={dispatch}, device={arch(arm)})
+  int disp_method1();
+
+  static int disp_method_variant2() { return 1; }
+  #pragma omp declare variant(disp_method_variant2)                            \
+    match(construct={dispatch}, device={arch(arm)})
+  static int disp_method2() { return 2; }
+};
+
+Obj foo_vari();
+#pragma omp declare variant(foo_vari) \
+  match(construct={dispatch}, device={arch(arm)})
+Obj foo_obj();
+
+//DUMP: FunctionDecl{{.*}} test_two
+void test_two(Obj o1, Obj &o2, Obj *o3)
+{
+  //PRINT: #pragma omp dispatch
+  //PRINT: o1.disp_method1();
+  //DUMP: OMPDispatchDirective
+  #pragma omp dispatch
+  o1.disp_method1();
+
+  //PRINT: #pragma omp dispatch
+  //PRINT: o2.disp_method1();
+  //DUMP: OMPDispatchDirective
+  #pragma omp dispatch
+  o2.disp_method1();
+
+  //PRINT: #pragma omp dispatch
+  //PRINT: o3->disp_method1();
+  //DUMP: OMPDispatchDirective
+  #pragma omp dispatch
+  o3->disp_method1();
+
+  //PRINT: #pragma omp dispatch
+  //PRINT: Obj::disp_method2();
+  //DUMP: OMPDispatchDirective
+  #pragma omp dispatch
+  Obj::disp_method2();
+
+  int ret;
+  //PRINT: #pragma omp dispatch
+  //PRINT: ret = o1.disp_method1();
+  //DUMP: OMPDispatchDirective
+  #pragma omp dispatch
+  ret = o1.disp_method1();
+
+  //PRINT: #pragma omp dispatch
+  //PRINT: ret = o2.disp_method1();
+  //DUMP: OMPDispatchDirective
+  #pragma omp dispatch
+  ret = o2.disp_method1();
+
+  //PRINT: #pragma omp dispatch
+  //PRINT: ret = o3->disp_method1();
+  //DUMP: OMPDispatchDirective
+  #pragma omp dispatch
+  ret = o3->disp_method1();
+
+  //PRINT: #pragma omp dispatch
+  //PRINT: ret = Obj::disp_method2();
+  //DUMP: OMPDispatchDirective
+  #pragma omp dispatch
+  ret = Obj::disp_method2();
+
+  //PRINT: #pragma omp dispatch
+  //PRINT: (void)Obj::disp_method2();
+  //DUMP: OMPDispatchDirective
+  #pragma omp dispatch
+  (void)Obj::disp_method2();
+
+  // Full C++ operator= case with temps and EH.
+  Obj o;
+  //PRINT: #pragma omp dispatch
+  //PRINT: o = foo_obj();
+  //DUMP: OMPDispatchDirective
+  #pragma omp dispatch
+  o = foo_obj();
+}
+
+struct A {
+  A& disp_operator(A other);
+  #pragma omp declare variant(disp_operator)                            \
+    match(construct={dispatch}, device={arch(arm)})
+  A& operator=(A other);
+};
+
+struct Obj2 {
+  A xx;
+  Obj2& disp_operator(Obj2 other);
+  #pragma omp declare variant(disp_operator)                            \
+    match(construct={dispatch}, device={arch(arm)})
+  Obj2& operator=(Obj2 other);
+
+  void foo() {
+    Obj2 z;
+    //PRINT: #pragma omp dispatch
+    //PRINT: z = z;
+    //DUMP: OMPDispatchDirective
+    #pragma omp dispatch
+    z = z;
+    //PRINT: #pragma omp dispatch
+    //PRINT: z.operator=(z);
+    //DUMP: OMPDispatchDirective
+    #pragma omp dispatch
+    z.operator=(z);
+  }
+  void bar() {
+    Obj2 j;
+    //PRINT: #pragma omp dispatch
+    //PRINT: j = {this->xx};
+    //DUMP: OMPDispatchDirective
+    #pragma omp dispatch
+    j = {this->xx};
+    //PRINT: #pragma omp dispatch
+    //PRINT: j.operator=({this->xx});
+    //DUMP: OMPDispatchDirective
+    #pragma omp dispatch
+    j.operator=({this->xx});
+  }
+};
+
+void test_three()
+{
+  Obj2 z1, z;
+  #pragma omp dispatch
+  z1 = z;
+  #pragma omp dispatch
+  z1.operator=(z);
+}
+#endif // HEADER

clang/test/OpenMP/dispatch_messages.cpp

+// RUN: %clang_cc1 -triple=x86_64-pc-win32 -verify -fopenmp    \
+// RUN:   -x c++ -std=c++14 -fexceptions -fcxx-exceptions %s
+
+// RUN: %clang_cc1 -triple=x86_64-pc-linux-gnu -verify -fopenmp \
+// RUN:   -x c++ -std=c++14 -fexceptions -fcxx-exceptions %s
+
+int disp_variant();
+#pragma omp declare variant(disp_variant) \
+    match(construct = {dispatch}, device = {arch(arm)})
+int disp_call();
+
+struct Obj {
+  int disp_method_variant1();
+  #pragma omp declare variant(disp_method_variant1)                            \
+    match(construct={dispatch}, device={arch(arm)})
+  int disp_method1();
+  int disp_method_variant2();
+  #pragma omp declare variant(disp_method_variant2)                            \
+    match(construct={dispatch}, device={arch(arm)})
+  int disp_method2();
+};
+
+void testit_one(int dnum) {
+  // expected-error@+1 {{cannot contain more than one 'device' clause}}
+  #pragma omp dispatch device(dnum) device(3)
+  disp_call();
+
+  // expected-error@+1 {{cannot contain more than one 'nowait' clause}}
+  #pragma omp dispatch nowait device(dnum) nowait
+  disp_call();
+}
+
+void testit_two() {
+  //expected-error@+2 {{cannot return from OpenMP region}}
+  #pragma omp dispatch
+  return disp_call();
+}
+
+void testit_three(int (*fptr)(void), Obj *obj, int (Obj::*mptr)(void)) {
+  //expected-error@+2 {{statement after '#pragma omp dispatch' must be a direct call to a target function or an assignment to one}}
+  #pragma omp dispatch
+  fptr();
+
+  //expected-error@+2 {{statement after '#pragma omp dispatch' must be a direct call to a target function or an assignment to one}}
+  #pragma omp dispatch
+  (obj->*mptr)();
+
+  int ret;
+
+  //expected-error@+2 {{statement after '#pragma omp dispatch' must be a direct call to a target function or an assignment to one}}
+  #pragma omp dispatch
+  ret = fptr();
+
+  //expected-error@+2 {{statement after '#pragma omp dispatch' must be a direct call to a target function or an assignment to one}}
+  #pragma omp dispatch
+  ret = (obj->*mptr)();
+}
+
+void testit_four(int *x, int y, Obj *obj)
+{
+  //expected-error@+2 {{statement after '#pragma omp dispatch' must be a direct call to a target function or an assignment to one}}
+  #pragma omp dispatch
+  *x = y;
+
+  //expected-error@+2 {{statement after '#pragma omp dispatch' must be a direct call to a target function or an assignment to one}}
+  #pragma omp dispatch
+  y = disp_call() + disp_call();
+
+  //expected-error@+2 {{statement after '#pragma omp dispatch' must be a direct call to a target function or an assignment to one}}
+  #pragma omp dispatch
+  y = (y = disp_call());
+
+  //expected-error@+2 {{statement after '#pragma omp dispatch' must be a direct call to a target function or an assignment to one}}
+  #pragma omp dispatch
+  y += disp_call();
+}

clang/tools/libclang/CIndex.cpp

case CXCursor_OMPTargetTeamsDistributeParallelForDirective:
     return cxstring::createRef("OMPTargetTeamsDistributeParallelForDirective");
   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_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::OMPTargetTeamsDistributeParallelForSimdDirectiveClass:
     K = CXCursor_OMPTargetTeamsDistributeParallelForSimdDirective;
     break;
   case Stmt::OMPTargetTeamsDistributeSimdDirectiveClass:
     K = CXCursor_OMPTargetTeamsDistributeSimdDirective;
     break;
   case Stmt::OMPInteropDirectiveClass:
     K = CXCursor_OMPInteropDirective;
     break;
+  case Stmt::OMPDispatchDirectiveClass:
+    K = CXCursor_OMPDispatchDirective;
+    break;
   case Stmt::BuiltinBitCastExprClass:
     K = CXCursor_BuiltinBitCastExpr;
   }
 
   CXCursor C = {K, 0, {Parent, S, TU}};
   return C;
 }
 

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

let allowedClauses = [
     VersionedClause<OMPC_Device>,
     VersionedClause<OMPC_Depend>,
     VersionedClause<OMPC_Destroy>,
     VersionedClause<OMPC_Init>,
     VersionedClause<OMPC_NoWait>,
     VersionedClause<OMPC_Use>,
   ];
 }
+def OMP_dispatch : Directive<"dispatch"> {
+  let allowedClauses = [
+    VersionedClause<OMPC_Device>,
+    VersionedClause<OMPC_IsDevicePtr>,
+    VersionedClause<OMPC_NoWait>,
+    VersionedClause<OMPC_Depend>
+  ];
+}
 def OMP_Unknown : Directive<"unknown"> {
   let isDefault = true;
 }

llvm/include/llvm/Frontend/OpenMP/OMPKinds.def

 __OMP_TRAIT_SET(user)
 
 __OMP_TRAIT_SELECTOR(user, condition, true)
 
 __OMP_TRAIT_PROPERTY(user, condition, true)
 __OMP_TRAIT_PROPERTY(user, condition, false)
 __OMP_TRAIT_PROPERTY(user, condition, unknown)
 
+__OMP_TRAIT_SELECTOR_AND_PROPERTY(construct, dispatch)
 
 // Note that we put isa last so that the other conditions are checked first.
 // This allows us to issue warnings wrt. isa only if we match otherwise.
 __OMP_TRAIT_SELECTOR(device, isa, true)
 
 // We use "__ANY" as a placeholder in the isa property to denote the
 // conceptual "any", not the literal `any` used in kind. The string we
 // we use is not important except that it will show up in diagnostics.