[OPENMP51]Support for the 'destroy' clause with interop variable

[mikerice]

Summary

Added basic parsing/sema/serialization support to extend the
existing 'destroy' clause for use with the 'interop' directive.

[ABataev]

LG

clang/include/clang/AST/OpenMPClause.h

public:
   }
 
   static bool classof(const OMPClause *T) {
     return T->getClauseKind() == llvm::omp::OMPC_use;
   }
 };
 
 /// This represents 'destroy' clause in the '#pragma omp depobj'
-/// directive.
+/// directive or the '#pragma omp interop' directive..
 ///
 /// \code
 /// #pragma omp depobj(a) destroy
+/// #pragma omp interop destroy(obj)
 /// \endcode
-/// In this example directive '#pragma omp depobj' has 'destroy' clause.
+/// In these examples directive '#pragma omp depobj' and '#pragma omp interop'
+/// have a 'destroy' clause. The 'interop' directive includes an object.
 class OMPDestroyClause final : public OMPClause {
+  friend class OMPClauseReader;
+
+  /// Location of '('.
+  SourceLocation LParenLoc;
+
+  /// Location of interop variable.
+  SourceLocation VarLoc;
+
+  /// The interop variable.
+  Stmt *InteropVar = nullptr;
+
+  /// Set the interop variable.
+  void setInteropVar(Expr *E) { InteropVar = E; }
+
+  /// Sets the location of '('.
+  void setLParenLoc(SourceLocation Loc) { LParenLoc = Loc; }
+
+  /// Sets the location of the interop variable.
+  void setVarLoc(SourceLocation Loc) { VarLoc = Loc; }
+
 public:
+  /// Build 'destroy' clause with an interop variable expression \a InteropVar.
+  ///
+  /// \param InteropVar The interop variable.
+  /// \param StartLoc Starting location of the clause.
+  /// \param LParenLoc Location of '('.
+  /// \param VarLoc Location of the interop variable.
+  /// \param EndLoc Ending location of the clause.
+  OMPDestroyClause(Expr *InteropVar, SourceLocation StartLoc,
+                   SourceLocation LParenLoc, SourceLocation VarLoc,
+                   SourceLocation EndLoc)
+      : OMPClause(llvm::omp::OMPC_destroy, StartLoc, EndLoc),
+        LParenLoc(LParenLoc), VarLoc(VarLoc), InteropVar(InteropVar) {}
+
   /// Build 'destroy' clause.
   ///
   /// \param StartLoc Starting location of the clause.
   /// \param EndLoc Ending location of the clause.
   OMPDestroyClause(SourceLocation StartLoc, SourceLocation EndLoc)
       : OMPClause(llvm::omp::OMPC_destroy, StartLoc, EndLoc) {}
 
   /// Build an empty clause.
   OMPDestroyClause()
       : OMPClause(llvm::omp::OMPC_destroy, SourceLocation(), SourceLocation()) {
   }
 
+  /// Returns the location of '('.
+  SourceLocation getLParenLoc() const { return LParenLoc; }
+
+  /// Returns the location of the interop variable.
+  SourceLocation getVarLoc() const { return VarLoc; }
+
+  /// Returns the interop variable.
+  Expr *getInteropVar() const { return cast_or_null<Expr>(InteropVar); }
+
   child_range children() {
+    if (InteropVar)
+      return child_range(&InteropVar, &InteropVar + 1);
     return child_range(child_iterator(), child_iterator());
   }
 
   const_child_range children() const {
+    if (InteropVar)
+      return const_child_range(&InteropVar, &InteropVar + 1);
     return const_child_range(const_child_iterator(), const_child_iterator());
   }
 
   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());

clang/include/clang/AST/RecursiveASTVisitor.h

 
 template <typename Derived>
 bool RecursiveASTVisitor<Derived>::VisitOMPUseClause(OMPUseClause *C) {
   TRY_TO(TraverseStmt(C->getInteropVar()));
   return true;
 }
 
 template <typename Derived>
-bool RecursiveASTVisitor<Derived>::VisitOMPDestroyClause(OMPDestroyClause *) {
+bool RecursiveASTVisitor<Derived>::VisitOMPDestroyClause(OMPDestroyClause *C) {
+  TRY_TO(TraverseStmt(C->getInteropVar()));
   return true;
 }
 
 template <typename Derived>
 template <typename T>
 bool RecursiveASTVisitor<Derived>::VisitOMPClauseList(T *Node) {
   for (auto *E : Node->varlists()) {
     TRY_TO(TraverseStmt(E));

clang/include/clang/Sema/Sema.h

OMPClause *ActOnOpenMPInitClause(Expr *InteropVar, ArrayRef<Expr *> PrefExprs,
                                    SourceLocation EndLoc);
 
   /// Called on well-formed 'use' clause.
   OMPClause *ActOnOpenMPUseClause(Expr *InteropVar, SourceLocation StartLoc,
                                   SourceLocation LParenLoc,
                                   SourceLocation VarLoc, SourceLocation EndLoc);
 
   /// Called on well-formed 'destroy' clause.
-  OMPClause *ActOnOpenMPDestroyClause(SourceLocation StartLoc,
+  OMPClause *ActOnOpenMPDestroyClause(Expr *InteropVar, SourceLocation StartLoc,
+                                      SourceLocation LParenLoc,
+                                      SourceLocation VarLoc,
                                       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/lib/AST/OpenMPClause.cpp

 }
 
 void OMPClausePrinter::VisitOMPUseClause(OMPUseClause *Node) {
   OS << "use(";
   Node->getInteropVar()->printPretty(OS, nullptr, Policy);
   OS << ")";
 }
 
-void OMPClausePrinter::VisitOMPDestroyClause(OMPDestroyClause *) {
+void OMPClausePrinter::VisitOMPDestroyClause(OMPDestroyClause *Node) {
   OS << "destroy";
+  if (Expr *E = Node->getInteropVar()) {
+    OS << "(";
+    E->printPretty(OS, nullptr, Policy);
+    OS << ")";
+  }
 }
 
 template<typename T>
 void OMPClausePrinter::VisitOMPClauseList(T *Node, char StartSym) {
   for (typename T::varlist_iterator I = Node->varlist_begin(),
                                     E = Node->varlist_end();
        I != E; ++I) {
     assert(*I && "Expected non-null Stmt");

clang/lib/AST/StmtProfile.cpp

void OMPClauseProfiler::VisitOMPInitClause(const OMPInitClause *C) {
   VisitOMPClauseList(C);
 }
 
 void OMPClauseProfiler::VisitOMPUseClause(const OMPUseClause *C) {
   if (C->getInteropVar())
     Profiler->VisitStmt(C->getInteropVar());
 }
 
-void OMPClauseProfiler::VisitOMPDestroyClause(const OMPDestroyClause *) {}
+void OMPClauseProfiler::VisitOMPDestroyClause(const OMPDestroyClause *C) {
+  if (C->getInteropVar())
+    Profiler->VisitStmt(C->getInteropVar());
+}
 
 template<typename T>
 void OMPClauseProfiler::VisitOMPClauseList(T *Node) {
   for (auto *E : Node->varlists()) {
     if (E)
       Profiler->VisitStmt(E);
   }
 }

clang/lib/Parse/ParseOpenMP.cpp

OMPClause *Parser::ParseOpenMPClause(OpenMPDirectiveKind DKind,
   case OMPC_relaxed:
   case OMPC_threads:
   case OMPC_simd:
   case OMPC_nogroup:
   case OMPC_unified_address:
   case OMPC_unified_shared_memory:
   case OMPC_reverse_offload:
   case OMPC_dynamic_allocators:
-  case OMPC_destroy:
     // OpenMP [2.7.1, Restrictions, p. 9]
     //  Only one ordered clause can appear on a loop directive.
     // OpenMP [2.7.1, Restrictions, C/C++, p. 4]
     //  Only one nowait clause can appear on a for directive.
     // OpenMP [5.0, Requires directive, Restrictions]
     //   Each of the requires clauses can appear at most once on the directive.
     if (!FirstClause) {
       Diag(Tok, diag::err_omp_more_one_clause)
if (!FirstClause) {
       ErrorFound = true;
     }
 
     Clause = ParseOpenMPSizesClause();
     break;
   case OMPC_uses_allocators:
     Clause = ParseOpenMPUsesAllocatorClause(DKind);
     break;
+  case OMPC_destroy:
+    if (DKind != OMPD_interop) {
+      if (!FirstClause) {
+        Diag(Tok, diag::err_omp_more_one_clause)
+            << getOpenMPDirectiveName(DKind) << getOpenMPClauseName(CKind) << 0;
+        ErrorFound = true;
+      }
+      Clause = ParseOpenMPClause(CKind, WrongDirective);
+      break;
+    }
+    LLVM_FALLTHROUGH;
   case OMPC_init:
   case OMPC_use:
     Clause = ParseOpenMPInteropClause(CKind, WrongDirective);
     break;
   case OMPC_device_type:
   case OMPC_unknown:
     skipUntilPragmaOpenMPEnd(DKind);
     break;
OMPClause *Parser::ParseOpenMPInteropClause(OpenMPClauseKind Kind,
   if (Kind == OMPC_init)
     return Actions.ActOnOpenMPInitClause(InteropVarExpr.get(), Prefs, IsTarget,
                                          IsTargetSync, Loc, T.getOpenLocation(),
                                          VarLoc, RLoc);
   if (Kind == OMPC_use)
     return Actions.ActOnOpenMPUseClause(InteropVarExpr.get(), Loc,
                                         T.getOpenLocation(), VarLoc, RLoc);
 
+  if (Kind == OMPC_destroy)
+    return Actions.ActOnOpenMPDestroyClause(InteropVarExpr.get(), Loc,
+                                            T.getOpenLocation(), VarLoc, RLoc);
+
   llvm_unreachable("Unexpected interop variable clause.");
 }
 
 /// Parsing of simple OpenMP clauses like 'default' or 'proc_bind'.
 ///
 ///    default-clause:
 ///         'default' '(' 'none' | 'shared' | 'firstprivate' ')'
 ///

clang/lib/Sema/SemaOpenMP.cpp

case OMPC_unified_shared_memory:
     break;
   case OMPC_reverse_offload:
     Res = ActOnOpenMPReverseOffloadClause(StartLoc, EndLoc);
     break;
   case OMPC_dynamic_allocators:
     Res = ActOnOpenMPDynamicAllocatorsClause(StartLoc, EndLoc);
     break;
   case OMPC_destroy:
-    Res = ActOnOpenMPDestroyClause(StartLoc, EndLoc);
+    Res = ActOnOpenMPDestroyClause(/*InteropVar=*/nullptr, StartLoc,
+                                   /*LParenLoc=*/SourceLocation(),
+                                   /*VarLoc=*/SourceLocation(), EndLoc);
     break;
   case OMPC_if:
   case OMPC_final:
   case OMPC_num_threads:
   case OMPC_safelen:
   case OMPC_simdlen:
   case OMPC_sizes:
   case OMPC_allocator:
OMPClause *Sema::ActOnOpenMPReverseOffloadClause(SourceLocation StartLoc,
   return new (Context) OMPReverseOffloadClause(StartLoc, EndLoc);
 }
 
 OMPClause *Sema::ActOnOpenMPDynamicAllocatorsClause(SourceLocation StartLoc,
                                                     SourceLocation EndLoc) {
   return new (Context) OMPDynamicAllocatorsClause(StartLoc, EndLoc);
 }
 
-OMPClause *Sema::ActOnOpenMPDestroyClause(SourceLocation StartLoc,
-                                          SourceLocation EndLoc) {
-  return new (Context) OMPDestroyClause(StartLoc, EndLoc);
-}
-
 StmtResult Sema::ActOnOpenMPInteropDirective(ArrayRef<OMPClause *> Clauses,
                                              SourceLocation StartLoc,
                                              SourceLocation EndLoc) {
 
   // OpenMP 5.1 [2.15.1, interop Construct, Restrictions]
   // At least one action-clause must appear on a directive.
-  // TODO: also add 'destroy' here.
-  if (!hasClauses(Clauses, OMPC_init, OMPC_use, OMPC_nowait)) {
+  if (!hasClauses(Clauses, OMPC_init, OMPC_use, OMPC_destroy, OMPC_nowait)) {
     StringRef Expected = "'init', 'use', 'destroy', or 'nowait'";
     Diag(StartLoc, diag::err_omp_no_clause_for_directive)
         << Expected << getOpenMPDirectiveName(OMPD_interop);
     return StmtError();
   }
 
   // OpenMP 5.1 [2.15.1, interop Construct, Restrictions]
   // A depend clause can only appear on the directive if a targetsync
for (const OMPClause *C : Clauses) {
     if (ClauseKind == OMPC_init) {
       const auto *IC = cast<OMPInitClause>(C);
       VarLoc = IC->getVarLoc();
       DRE = dyn_cast_or_null<DeclRefExpr>(IC->getInteropVar());
     } else if (ClauseKind == OMPC_use) {
       const auto *UC = cast<OMPUseClause>(C);
       VarLoc = UC->getVarLoc();
       DRE = dyn_cast_or_null<DeclRefExpr>(UC->getInteropVar());
+    } else if (ClauseKind == OMPC_destroy) {
+      const auto *DC = cast<OMPDestroyClause>(C);
+      VarLoc = DC->getVarLoc();
+      DRE = dyn_cast_or_null<DeclRefExpr>(DC->getInteropVar());
     }
-    // TODO: 'destroy' clause to be added here.
 
     if (!DRE)
       continue;
 
     if (const auto *VD = dyn_cast<VarDecl>(DRE->getDecl())) {
       if (!InteropVars.insert(VD->getCanonicalDecl()).second) {
         Diag(VarLoc, diag::err_omp_interop_var_multiple_actions) << VD;
         return StmtError();
static bool isValidInteropVariable(Sema &SemaRef, Expr *InteropVarExpr,
   QualType VarType = InteropVarExpr->getType().getUnqualifiedType();
   if (!SemaRef.Context.hasSameType(InteropType, VarType)) {
     SemaRef.Diag(VarLoc, diag::err_omp_interop_variable_wrong_type);
     return false;
   }
 
   // OpenMP 5.1 [2.15.1, interop Construct, Restrictions]
   // The interop-var passed to init or destroy must be non-const.
-  // TODO: 'destroy' clause too.
-  if (Kind == OMPC_init &&
+  if ((Kind == OMPC_init || Kind == OMPC_destroy) &&
       isConstNotMutableType(SemaRef, InteropVarExpr->getType())) {
     SemaRef.Diag(VarLoc, diag::err_omp_interop_variable_expected)
         << /*non-const*/ 1;
     return false;
   }
   return true;
 }
 
OMPClause *Sema::ActOnOpenMPUseClause(Expr *InteropVar, SourceLocation StartLoc,
 
   if (!isValidInteropVariable(*this, InteropVar, VarLoc, OMPC_use))
     return nullptr;
 
   return new (Context)
       OMPUseClause(InteropVar, StartLoc, LParenLoc, VarLoc, EndLoc);
 }
 
+OMPClause *Sema::ActOnOpenMPDestroyClause(Expr *InteropVar,
+                                          SourceLocation StartLoc,
+                                          SourceLocation LParenLoc,
+                                          SourceLocation VarLoc,
+                                          SourceLocation EndLoc) {
+  if (InteropVar &&
+      !isValidInteropVariable(*this, InteropVar, VarLoc, OMPC_destroy))
+    return nullptr;
+
+  return new (Context)
+      OMPDestroyClause(InteropVar, StartLoc, LParenLoc, VarLoc, 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 *RebuildOMPUseClause(Expr *InteropVar, SourceLocation StartLoc,
                                  SourceLocation LParenLoc,
                                  SourceLocation VarLoc, SourceLocation EndLoc) {
     return getSema().ActOnOpenMPUseClause(InteropVar, StartLoc, LParenLoc,
                                           VarLoc, EndLoc);
   }
 
+  /// Build a new OpenMP 'destroy' clause.
+  ///
+  /// By default, performs semantic analysis to build the new OpenMP clause.
+  /// Subclasses may override this routine to provide different behavior.
+  OMPClause *RebuildOMPDestroyClause(Expr *InteropVar, SourceLocation StartLoc,
+                                     SourceLocation LParenLoc,
+                                     SourceLocation VarLoc,
+                                     SourceLocation EndLoc) {
+    return getSema().ActOnOpenMPDestroyClause(InteropVar, StartLoc, LParenLoc,
+                                              VarLoc, 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);
   }
OMPClause *TreeTransform<Derived>::TransformOMPUseClause(OMPUseClause *C) {
   return getDerived().RebuildOMPUseClause(ER.get(), C->getBeginLoc(),
                                           C->getLParenLoc(), C->getVarLoc(),
                                           C->getEndLoc());
 }
 
 template <typename Derived>
 OMPClause *
 TreeTransform<Derived>::TransformOMPDestroyClause(OMPDestroyClause *C) {
-  // No need to rebuild this clause, no template-dependent parameters.
-  return C;
+  ExprResult ER;
+  if (Expr *IV = C->getInteropVar()) {
+    ER = getDerived().TransformExpr(IV);
+    if (ER.isInvalid())
+      return nullptr;
+  }
+  return getDerived().RebuildOMPDestroyClause(ER.get(), C->getBeginLoc(),
+                                              C->getLParenLoc(), C->getVarLoc(),
+                                              C->getEndLoc());
 }
 
 template <typename Derived>
 OMPClause *TreeTransform<Derived>::TransformOMPUnifiedAddressClause(
     OMPUnifiedAddressClause *C) {
   llvm_unreachable("unified_address clause cannot appear in dependent context");
 }
 

clang/lib/Serialization/ASTReader.cpp

 }
 
 void OMPClauseReader::VisitOMPUseClause(OMPUseClause *C) {
   C->setInteropVar(Record.readSubExpr());
   C->setLParenLoc(Record.readSourceLocation());
   C->setVarLoc(Record.readSourceLocation());
 }
 
-void OMPClauseReader::VisitOMPDestroyClause(OMPDestroyClause *) {}
+void OMPClauseReader::VisitOMPDestroyClause(OMPDestroyClause *C) {
+  C->setInteropVar(Record.readSubExpr());
+  C->setLParenLoc(Record.readSourceLocation());
+  C->setVarLoc(Record.readSourceLocation());
+}
 
 void OMPClauseReader::VisitOMPUnifiedAddressClause(OMPUnifiedAddressClause *) {}
 
 void OMPClauseReader::VisitOMPUnifiedSharedMemoryClause(
     OMPUnifiedSharedMemoryClause *) {}
 
 void OMPClauseReader::VisitOMPReverseOffloadClause(OMPReverseOffloadClause *) {}
 

clang/lib/Serialization/ASTWriter.cpp

 }
 
 void OMPClauseWriter::VisitOMPUseClause(OMPUseClause *C) {
   Record.AddStmt(C->getInteropVar());
   Record.AddSourceLocation(C->getLParenLoc());
   Record.AddSourceLocation(C->getVarLoc());
 }
 
-void OMPClauseWriter::VisitOMPDestroyClause(OMPDestroyClause *) {}
+void OMPClauseWriter::VisitOMPDestroyClause(OMPDestroyClause *C) {
+  Record.AddStmt(C->getInteropVar());
+  Record.AddSourceLocation(C->getLParenLoc());
+  Record.AddSourceLocation(C->getVarLoc());
+}
 
 void OMPClauseWriter::VisitOMPPrivateClause(OMPPrivateClause *C) {
   Record.push_back(C->varlist_size());
   Record.AddSourceLocation(C->getLParenLoc());
   for (auto *VE : C->varlists()) {
     Record.AddStmt(VE);
   }
   for (auto *VE : C->private_copies()) {

clang/test/OpenMP/interop_ast_print.cpp

void foo1(int *ap, int dev) {
   #pragma omp interop init(target:I)
 
   //PRINT: #pragma omp interop use(I)
   //DUMP: OMPInteropDirective
   //DUMP: OMPUseClause
   //DUMP: DeclRefExpr{{.*}}'omp_interop_t'{{.*}}Var{{.*}}'I'
   #pragma omp interop use(I)
 
+  //PRINT: #pragma omp interop destroy(I)
+  //DUMP: OMPInteropDirective
+  //DUMP: OMPDestroyClause
+  //DUMP: DeclRefExpr{{.*}}'omp_interop_t'{{.*}}Var{{.*}}'I'
+  #pragma omp interop destroy(I)
+
   //PRINT: #pragma omp interop init(target : IRef)
   //DUMP: OMPInteropDirective
   //DUMP: OMPInitClause
   //DUMP: DeclRefExpr{{.*}}'omp_interop_t'{{.*}}Var{{.*}}'IRef'
   #pragma omp interop init(target:IRef)
 
   //PRINT: #pragma omp interop use(IRef)
   //DUMP: OMPInteropDirective
   //DUMP: OMPUseClause
   //DUMP: DeclRefExpr{{.*}}'omp_interop_t'{{.*}}Var{{.*}}'IRef'
   #pragma omp interop use(IRef)
 
+  //PRINT: #pragma omp interop destroy(IRef)
+  //DUMP: OMPInteropDirective
+  //DUMP: OMPDestroyClause
+  //DUMP: DeclRefExpr{{.*}}'omp_interop_t'{{.*}}Var{{.*}}'IRef'
+  #pragma omp interop destroy(IRef)
+
   const omp_interop_t CI = (omp_interop_t)0;
   //PRINT: #pragma omp interop use(CI)
   //DUMP: OMPInteropDirective
   //DUMP: OMPUseClause
   //DUMP: DeclRefExpr{{.*}}'const omp_interop_t'{{.*}}Var{{.*}}'CI'
   #pragma omp interop use(CI)
 
   //PRINT: #pragma omp interop device(dev) depend(inout : ap) init(targetsync : I)
void foo1(int *ap, int dev) {
   //DUMP: OMPDeviceClause
   //DUMP: DeclRefExpr{{.*}}'dev' 'int'
   //DUMP: OMPDependClause
   //DUMP: DeclRefExpr{{.*}}'ap' 'int *'
   //DUMP: OMPUseClause
   //DUMP: DeclRefExpr{{.*}}'omp_interop_t'{{.*}}Var{{.*}}'I'
   #pragma omp interop device(dev) depend(inout:ap) use(I)
 
+  //PRINT: #pragma omp interop device(dev) depend(inout : ap) destroy(I)
+  //DUMP: OMPInteropDirective
+  //DUMP: OMPDeviceClause
+  //DUMP: DeclRefExpr{{.*}}'dev' 'int'
+  //DUMP: OMPDependClause
+  //DUMP: DeclRefExpr{{.*}}'ap' 'int *'
+  //DUMP: OMPDestroyClause
+  //DUMP: DeclRefExpr{{.*}}'omp_interop_t'{{.*}}Var{{.*}}'I'
+  #pragma omp interop device(dev) depend(inout:ap) destroy(I)
+
   //PRINT: #pragma omp interop init(prefer_type(1,2,3,4,5,6), targetsync : I)
   //DUMP: OMPInteropDirective
   //DUMP: OMPInitClause
   //DUMP: DeclRefExpr{{.*}}'omp_interop_t'{{.*}}Var{{.*}}'I'
   //DUMP: IntegerLiteral{{.*}}1
   //DUMP: IntegerLiteral{{.*}}2
   //DUMP: IntegerLiteral{{.*}}3
   //DUMP: IntegerLiteral{{.*}}4
void foo1(int *ap, int dev) {
 
   //PRINT: #pragma omp interop use(I) use(J)
   //DUMP: OMPInteropDirective
   //DUMP: OMPUseClause
   //DUMP: DeclRefExpr{{.*}}'omp_interop_t'{{.*}}Var{{.*}}'I'
   //DUMP: OMPUseClause
   //DUMP: DeclRefExpr{{.*}}'omp_interop_t'{{.*}}Var{{.*}}'J'
   #pragma omp interop use(I) use(J)
+
+  //PRINT: #pragma omp interop destroy(I) destroy(J)
+  //DUMP: OMPInteropDirective
+  //DUMP: OMPDestroyClause
+  //DUMP: DeclRefExpr{{.*}}'omp_interop_t'{{.*}}Var{{.*}}'I'
+  //DUMP: OMPDestroyClause
+  //DUMP: DeclRefExpr{{.*}}'omp_interop_t'{{.*}}Var{{.*}}'J'
+  #pragma omp interop destroy(I) destroy(J)
+
+  //PRINT: #pragma omp interop init(target : I) destroy(J)
+  //DUMP: OMPInteropDirective
+  //DUMP: OMPInitClause
+  //DUMP: DeclRefExpr{{.*}}'omp_interop_t'{{.*}}Var{{.*}}'I'
+  //DUMP: OMPDestroyClause
+  //DUMP: DeclRefExpr{{.*}}'omp_interop_t'{{.*}}Var{{.*}}'J'
+  #pragma omp interop init(target:I) destroy(J)
+
+  //PRINT: #pragma omp interop destroy(I) use(J)
+  //DUMP: OMPInteropDirective
+  //DUMP: OMPDestroyClause
+  //DUMP: DeclRefExpr{{.*}}'omp_interop_t'{{.*}}Var{{.*}}'I'
+  //DUMP: OMPUseClause
+  //DUMP: DeclRefExpr{{.*}}'omp_interop_t'{{.*}}Var{{.*}}'J'
+  #pragma omp interop destroy(I) use(J)
 }
 
 //DUMP: FunctionTemplateDecl{{.*}}fooTemp
 //DUMP-NEXT: NonTypeTemplateParmDecl{{.*}}'int{{.*}}I
 template <int I>
 void fooTemp() {
   omp_interop_t interop_var;
   //PRINT: #pragma omp interop init(prefer_type(I,4,"level_one"), target : interop_var)
void barTemp(T t) {
   #pragma omp interop init(prefer_type(4,"level_one"), target: t)
 
   //PRINT: #pragma omp interop use(t)
   //DUMP: OMPInteropDirective
   //DUMP: OMPUseClause
   //DUMP: DeclRefExpr{{.*}}ParmVar{{.*}}'t' 'T'
   #pragma omp interop use(t)
 
+  //PRINT: #pragma omp interop destroy(t)
+  //DUMP: OMPInteropDirective
+  //DUMP: OMPDestroyClause
+  //DUMP: DeclRefExpr{{.*}}ParmVar{{.*}}'t' 'T'
+  #pragma omp interop destroy(t)
+
   //DUMP: FunctionDecl{{.*}}barTemp 'void (void *)'
   //DUMP: TemplateArgument type 'void *'
   //DUMP: ParmVarDecl{{.*}}t 'void *'
   //DUMP: OMPInteropDirective
   //DUMP: OMPInitClause
   //DUMP: DeclRefExpr{{.*}}ParmVar{{.*}}'t' 'void *'
   //PRINT: #pragma omp interop init(prefer_type(4,"level_one"), target : t)
   //DUMP: OMPInteropDirective
   //DUMP: OMPUseClause
   //DUMP: DeclRefExpr{{.*}}ParmVar{{.*}}'t' 'void *'
   //PRINT: #pragma omp interop use(t)
+  //DUMP: OMPInteropDirective
+  //DUMP: OMPDestroyClause
+  //DUMP: DeclRefExpr{{.*}}ParmVar{{.*}}'t' 'void *'
+  //PRINT: #pragma omp interop destroy(t)
 }
 
 void bar()
 {
   fooTemp<3>();
   omp_interop_t Ivar;
   barTemp(Ivar);
 }
 
 #endif // HEADER

clang/test/OpenMP/interop_messages.cpp

void foo(int *Ap) {
   #pragma omp interop init(target,foo:InteropVar) init(target:Another)
 
   //expected-error@+1 {{use of undeclared identifier 'NoDeclVar'}}
   #pragma omp interop init(target:NoDeclVar) init(target:Another)
 
   //expected-error@+1 {{use of undeclared identifier 'NoDeclVar'}}
   #pragma omp interop use(NoDeclVar) use(Another)
 
+  //expected-error@+1 {{use of undeclared identifier 'NoDeclVar'}}
+  #pragma omp interop destroy(NoDeclVar) destroy(Another)
+
   //expected-error@+2 {{expected interop type: 'target' and/or 'targetsync'}}
   //expected-error@+1 {{expected expression}}
   #pragma omp interop init(InteropVar) init(target:Another)
 
   //expected-warning@+1 {{missing ':' after interop types}}
   #pragma omp interop init(target InteropVar)
 
   //expected-error@+1 {{expected expression}}
   #pragma omp interop init(prefer_type(1,+,3),target:InteropVar) \
                       init(target:Another)
 
   int IntVar;
   struct S { int I; } SVar;
 
   //expected-error@+1 {{interop variable must be of type 'omp_interop_t'}}
   #pragma omp interop init(prefer_type(1,"sycl",3),target:IntVar) \
                       init(target:Another)
 
   //expected-error@+1 {{interop variable must be of type 'omp_interop_t'}}
   #pragma omp interop use(IntVar) use(Another)
 
   //expected-error@+1 {{interop variable must be of type 'omp_interop_t'}}
+  #pragma omp interop destroy(IntVar) destroy(Another)
+
+  //expected-error@+1 {{interop variable must be of type 'omp_interop_t'}}
   #pragma omp interop init(prefer_type(1,"sycl",3),target:SVar) \
                       init(target:Another)
 
   //expected-error@+1 {{interop variable must be of type 'omp_interop_t'}}
   #pragma omp interop use(SVar) use(Another)
 
+  //expected-error@+1 {{interop variable must be of type 'omp_interop_t'}}
+  #pragma omp interop destroy(SVar) destroy(Another)
+
   int a, b;
   //expected-error@+1 {{expected variable of type 'omp_interop_t'}}
   #pragma omp interop init(target:a+b) init(target:Another)
 
   //expected-error@+1 {{expected variable of type 'omp_interop_t'}}
   #pragma omp interop use(a+b) use(Another)
 
+  //expected-error@+1 {{expected variable of type 'omp_interop_t'}}
+  #pragma omp interop destroy(a+b) destroy(Another)
+
   const omp_interop_t C = (omp_interop_t)5;
   //expected-error@+1 {{expected non-const variable of type 'omp_interop_t'}}
   #pragma omp interop init(target:C) init(target:Another)
 
+  //expected-error@+1 {{expected non-const variable of type 'omp_interop_t'}}
+  #pragma omp interop destroy(C) destroy(Another)
+
   //expected-error@+1 {{prefer_list item must be a string literal or constant integral expression}}
   #pragma omp interop init(prefer_type(1.0),target:InteropVar) \
                       init(target:Another)
 
   //expected-error@+1 {{prefer_list item must be a string literal or constant integral expression}}
   #pragma omp interop init(prefer_type(a),target:InteropVar) \
                       init(target:Another)
 
   //expected-error@+1 {{expected at least one 'init', 'use', 'destroy', or 'nowait' clause for '#pragma omp interop'}}
   #pragma omp interop device(0)
 
   //expected-warning@+1 {{interop type 'target' cannot be specified more than once}}
   #pragma omp interop init(target,targetsync,target:InteropVar)
 
   //expected-error@+1 {{'depend' clause requires the 'targetsync' interop type}}
   #pragma omp interop init(target:InteropVar) depend(inout:Ap)
 
   //expected-error@+1 {{interop variable 'InteropVar' used in multiple action clauses}}
   #pragma omp interop init(target:InteropVar) init(target:InteropVar)
 
   //expected-error@+1 {{interop variable 'InteropVar' used in multiple action clauses}}
   #pragma omp interop use(InteropVar) use(InteropVar)
 
   //expected-error@+1 {{interop variable 'InteropVar' used in multiple action clauses}}
+  #pragma omp interop destroy(InteropVar) destroy(InteropVar)
+
+  //expected-error@+1 {{interop variable 'InteropVar' used in multiple action clauses}}
   #pragma omp interop init(target:InteropVar) use(InteropVar)
 
+  //expected-error@+1 {{interop variable 'InteropVar' used in multiple action clauses}}
+  #pragma omp interop init(target:InteropVar) destroy(InteropVar)
+
+  //expected-error@+1 {{interop variable 'InteropVar' used in multiple action clauses}}
+  #pragma omp interop use(InteropVar) destroy(InteropVar)
+
   //expected-error@+1 {{directive '#pragma omp interop' cannot contain more than one 'device' clause}}
   #pragma omp interop init(target:InteropVar) device(0) device(1)
 
   //expected-error@+1 {{argument to 'device' clause must be a non-negative integer value}}
   #pragma omp interop init(target:InteropVar) device(-4)
 
   //expected-error@+1 {{directive '#pragma omp interop' cannot contain more than one 'nowait' clause}}
   #pragma omp interop nowait init(target:InteropVar) nowait
 }
 #endif
 #ifdef WITHOUTDEF
 void foo() {
   int InteropVar;
   //expected-error@+1 {{'omp_interop_t' type not found; include <omp.h>}}
   #pragma omp interop init(prefer_type(1,"sycl",3),target:InteropVar) nowait
   //expected-error@+1 {{'omp_interop_t' type not found; include <omp.h>}}
   #pragma omp interop use(InteropVar) nowait
+  //expected-error@+1 {{'omp_interop_t' type not found; include <omp.h>}}
+  #pragma omp interop destroy(InteropVar) nowait
 }
 #endif

clang/tools/libclang/CIndex.cpp

 void OMPClauseEnqueue::VisitOMPInitClause(const OMPInitClause *C) {
   VisitOMPClauseList(C);
 }
 
 void OMPClauseEnqueue::VisitOMPUseClause(const OMPUseClause *C) {
   Visitor->AddStmt(C->getInteropVar());
 }
 
-void OMPClauseEnqueue::VisitOMPDestroyClause(const OMPDestroyClause *) {}
+void OMPClauseEnqueue::VisitOMPDestroyClause(const OMPDestroyClause *C) {
+  if (C->getInteropVar())
+    Visitor->AddStmt(C->getInteropVar());
+}
 
 void OMPClauseEnqueue::VisitOMPUnifiedAddressClause(
     const OMPUnifiedAddressClause *) {}
 
 void OMPClauseEnqueue::VisitOMPUnifiedSharedMemoryClause(
     const OMPUnifiedSharedMemoryClause *) {}
 
 void OMPClauseEnqueue::VisitOMPReverseOffloadClause(

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

def OMP_EndWorkshare : Directive<"end workshare"> {
   let allowedClauses = [
     VersionedClause<OMPC_NoWait>
   ];
 }
 def OMP_interop : Directive<"interop"> {
   let allowedClauses = [
     VersionedClause<OMPC_Device>,
     VersionedClause<OMPC_Depend>,
+    VersionedClause<OMPC_Destroy>,
     VersionedClause<OMPC_Init>,
     VersionedClause<OMPC_NoWait>,
     VersionedClause<OMPC_Use>,
   ];
 }
 def OMP_Unknown : Directive<"unknown"> {
   let isDefault = true;
 }