[OPENMP51]Initial support for the use clause

[mikerice]

Summary

Added basic parsing/sema/serialization support for the 'use' clause.

[ABataev]

LG

clang/include/clang/AST/OpenMPClause.h

const_prefs_range prefs() const {
     return const_prefs_range(Prefs.begin(), Prefs.end());
   }
 
   static bool classof(const OMPClause *T) {
     return T->getClauseKind() == llvm::omp::OMPC_init;
   }
 };
 
+/// This represents the 'use' clause in '#pragma omp ...' directives.
+///
+/// \code
+/// #pragma omp interop use(obj)
+/// \endcode
+class OMPUseClause 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 'use' clause with and 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.
+  OMPUseClause(Expr *InteropVar, SourceLocation StartLoc,
+               SourceLocation LParenLoc, SourceLocation VarLoc,
+               SourceLocation EndLoc)
+      : OMPClause(llvm::omp::OMPC_use, StartLoc, EndLoc), LParenLoc(LParenLoc),
+        VarLoc(VarLoc), InteropVar(InteropVar) {}
+
+  /// Build an empty clause.
+  OMPUseClause()
+      : OMPClause(llvm::omp::OMPC_use, 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<Expr>(InteropVar); }
+
+  child_range children() { return child_range(&InteropVar, &InteropVar + 1); }
+
+  const_child_range children() const {
+    return const_child_range(&InteropVar, &InteropVar + 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_use;
+  }
+};
+
 /// This represents 'destroy' clause in the '#pragma omp depobj'
 /// directive.
 ///
 /// \code
 /// #pragma omp depobj(a) destroy
 /// \endcode
 /// In this example directive '#pragma omp depobj' has 'destroy' clause.
 class OMPDestroyClause final : public OMPClause {

clang/include/clang/AST/RecursiveASTVisitor.h

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

clang/include/clang/Sema/Sema.h

public:
   /// Called on well-formed 'init' clause.
   OMPClause *ActOnOpenMPInitClause(Expr *InteropVar, ArrayRef<Expr *> PrefExprs,
                                    bool IsTarget, bool IsTargetSync,
                                    SourceLocation StartLoc,
                                    SourceLocation LParenLoc,
                                    SourceLocation VarLoc,
                                    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,
                                       SourceLocation EndLoc);
   /// Called on well-formed 'threads' clause.
   OMPClause *ActOnOpenMPThreadsClause(SourceLocation StartLoc,
                                       SourceLocation EndLoc);
   /// Called on well-formed 'simd' clause.
   OMPClause *ActOnOpenMPSIMDClause(SourceLocation StartLoc,

clang/lib/AST/OpenMPClause.cpp

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

clang/lib/AST/StmtProfile.cpp

 void OMPClauseProfiler::VisitOMPSIMDClause(const OMPSIMDClause *) {}
 
 void OMPClauseProfiler::VisitOMPNogroupClause(const OMPNogroupClause *) {}
 
 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 *) {}
 
 template<typename T>
 void OMPClauseProfiler::VisitOMPClauseList(T *Node) {
   for (auto *E : Node->varlists()) {
     if (E)
       Profiler->VisitStmt(E);
   }

clang/lib/Parse/ParseOpenMP.cpp

case OMPC_sizes:
     }
 
     Clause = ParseOpenMPSizesClause();
     break;
   case OMPC_uses_allocators:
     Clause = ParseOpenMPUsesAllocatorClause(DKind);
     break;
   case OMPC_init:
+  case OMPC_use:
     Clause = ParseOpenMPInteropClause(CKind, WrongDirective);
     break;
   case OMPC_device_type:
   case OMPC_unknown:
     skipUntilPragmaOpenMPEnd(DKind);
     break;
   case OMPC_threadprivate:
   case OMPC_uniform:
OMPClause *Parser::ParseOpenMPInteropClause(OpenMPClauseKind Kind,
   if (ParseOnly || !InteropVarExpr.isUsable() ||
       (Kind == OMPC_init && !IsTarget && !IsTargetSync))
     return nullptr;
 
   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);
 
   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

 }
 
 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 'use' and 'destroy' here.
-  if (!hasClauses(Clauses, OMPC_init, OMPC_nowait)) {
+  // TODO: also add 'destroy' here.
+  if (!hasClauses(Clauses, OMPC_init, OMPC_use, 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
   // interop-type is present or the interop-var was initialized with
   // the targetsync interop-type.
 
   // If there is any 'init' clause diagnose if there is no 'init' clause with
   // interop-type of 'targetsync'. Cases involving other directives cannot be
   // diagnosed.
   const OMPDependClause *DependClause = nullptr;
+  bool HasInitClause = false;
   bool IsTargetSync = false;
   for (const OMPClause *C : Clauses) {
     if (IsTargetSync)
       break;
-    if (const auto *InitClause = dyn_cast<OMPInitClause>(C))
-      IsTargetSync = InitClause->getIsTargetSync();
-    else if (const auto *DC = dyn_cast<OMPDependClause>(C))
+    if (const auto *InitClause = dyn_cast<OMPInitClause>(C)) {
+      HasInitClause = true;
+      if (InitClause->getIsTargetSync())
+        IsTargetSync = true;
+    } else if (const auto *DC = dyn_cast<OMPDependClause>(C)) {
       DependClause = DC;
     }
-  if (DependClause && !IsTargetSync) {
+  }
+  if (DependClause && HasInitClause && !IsTargetSync) {
     Diag(DependClause->getBeginLoc(), diag::err_omp_interop_bad_depend_clause);
     return StmtError();
   }
 
   // OpenMP 5.1 [2.15.1, interop Construct, Restrictions]
   // Each interop-var may be specified for at most one action-clause of each
   // interop construct.
   llvm::SmallPtrSet<const VarDecl *, 4> InteropVars;
   for (const OMPClause *C : Clauses) {
     OpenMPClauseKind ClauseKind = C->getClauseKind();
     const DeclRefExpr *DRE = nullptr;
     SourceLocation VarLoc;
 
     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());
     }
-    // TODO: 'use' and 'destroy' clauses to be added here.
+    // 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();
for (const Expr *E : PrefExprs) {
     return nullptr;
   }
 
   return OMPInitClause::Create(Context, InteropVar, PrefExprs, IsTarget,
                                IsTargetSync, StartLoc, LParenLoc, VarLoc,
                                EndLoc);
 }
 
+OMPClause *Sema::ActOnOpenMPUseClause(Expr *InteropVar, SourceLocation StartLoc,
+                                      SourceLocation LParenLoc,
+                                      SourceLocation VarLoc,
+                                      SourceLocation EndLoc) {
+
+  if (!isValidInteropVariable(*this, InteropVar, VarLoc, OMPC_use))
+    return nullptr;
+
+  return new (Context)
+      OMPUseClause(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

OMPClause *RebuildOMPInitClause(Expr *InteropVar, ArrayRef<Expr *> PrefExprs,
                                   SourceLocation LParenLoc,
                                   SourceLocation VarLoc,
                                   SourceLocation EndLoc) {
     return getSema().ActOnOpenMPInitClause(InteropVar, PrefExprs, IsTarget,
                                            IsTargetSync, StartLoc, LParenLoc,
                                            VarLoc, EndLoc);
   }
 
+  /// Build a new OpenMP 'use' clause.
+  ///
+  /// By default, performs semantic analysis to build the new OpenMP clause.
+  /// 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);
+  }
+
   /// 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);
   }
for (Expr *E : llvm::drop_begin(C->varlists())) {
     PrefExprs.push_back(ER.get());
   }
   return getDerived().RebuildOMPInitClause(
       IVR.get(), PrefExprs, C->getIsTarget(), C->getIsTargetSync(),
       C->getBeginLoc(), C->getLParenLoc(), C->getVarLoc(), C->getEndLoc());
 }
 
 template <typename Derived>
+OMPClause *TreeTransform<Derived>::TransformOMPUseClause(OMPUseClause *C) {
+  ExprResult ER = getDerived().TransformExpr(C->getInteropVar());
+  if (ER.isInvalid())
+    return nullptr;
+  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;
 }
 
 template <typename Derived>
 OMPClause *TreeTransform<Derived>::TransformOMPUnifiedAddressClause(

clang/lib/Serialization/ASTReader.cpp

case llvm::omp::OMPC_exclusive:
     C = OMPExclusiveClause::CreateEmpty(Context, Record.readInt());
     break;
   case llvm::omp::OMPC_order:
     C = new (Context) OMPOrderClause();
     break;
   case llvm::omp::OMPC_init:
     C = OMPInitClause::CreateEmpty(Context, Record.readInt());
     break;
+  case llvm::omp::OMPC_use:
+    C = new (Context) OMPUseClause();
+    break;
   case llvm::omp::OMPC_destroy:
     C = new (Context) OMPDestroyClause();
     break;
   case llvm::omp::OMPC_detach:
     C = new (Context) OMPDetachClause();
     break;
   case llvm::omp::OMPC_uses_allocators:
     C = OMPUsesAllocatorsClause::CreateEmpty(Context, Record.readInt());
for (unsigned I = 0; I != NumVars; ++I)
     Vars.push_back(Record.readSubExpr());
   C->setVarRefs(Vars);
   C->setIsTarget(Record.readBool());
   C->setIsTargetSync(Record.readBool());
   C->setLParenLoc(Record.readSourceLocation());
   C->setVarLoc(Record.readSourceLocation());
 }
 
+void OMPClauseReader::VisitOMPUseClause(OMPUseClause *C) {
+  C->setInteropVar(Record.readSubExpr());
+  C->setLParenLoc(Record.readSourceLocation());
+  C->setVarLoc(Record.readSourceLocation());
+}
+
 void OMPClauseReader::VisitOMPDestroyClause(OMPDestroyClause *) {}
 
 void OMPClauseReader::VisitOMPUnifiedAddressClause(OMPUnifiedAddressClause *) {}
 
 void OMPClauseReader::VisitOMPUnifiedSharedMemoryClause(
     OMPUnifiedSharedMemoryClause *) {}
 
 void OMPClauseReader::VisitOMPReverseOffloadClause(OMPReverseOffloadClause *) {}

clang/lib/Serialization/ASTWriter.cpp

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

clang/test/OpenMP/interop_ast_print.cpp

void foo1(int *ap, int dev) {
   omp_interop_t &IRef = I;
 
   //PRINT: #pragma omp interop init(target : I)
   //DUMP: OMPInteropDirective
   //DUMP: OMPInitClause
   //DUMP: DeclRefExpr{{.*}}'omp_interop_t'{{.*}}Var{{.*}}'I'
   #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 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)
+
+  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)
   //DUMP: OMPInteropDirective
   //DUMP: OMPDeviceClause
   //DUMP: DeclRefExpr{{.*}}'dev' 'int'
   //DUMP: OMPDependClause
   //DUMP: DeclRefExpr{{.*}}'ap' 'int *'
   //DUMP: OMPInitClause
   //DUMP: DeclRefExpr{{.*}}'omp_interop_t'{{.*}}Var{{.*}}'I'
   #pragma omp interop device(dev) depend(inout:ap) init(targetsync:I)
 
+  //PRINT: #pragma omp interop device(dev) depend(inout : ap) use(I)
+  //DUMP: OMPInteropDirective
+  //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 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 init(target : I) init(targetsync : J)
   //DUMP: OMPInteropDirective
   //DUMP: OMPInitClause
   //DUMP: DeclRefExpr{{.*}}'omp_interop_t'{{.*}}Var{{.*}}'I'
   //DUMP: OMPInitClause
   //DUMP: DeclRefExpr{{.*}}'omp_interop_t'{{.*}}Var{{.*}}'J'
   #pragma omp interop init(target:I) init(targetsync:J)
 
+  //PRINT: #pragma omp interop init(target : I) use(J)
+  //DUMP: OMPInteropDirective
+  //DUMP: OMPInitClause
+  //DUMP: DeclRefExpr{{.*}}'omp_interop_t'{{.*}}Var{{.*}}'I'
+  //DUMP: OMPUseClause
+  //DUMP: DeclRefExpr{{.*}}'omp_interop_t'{{.*}}Var{{.*}}'J'
+  #pragma omp interop init(target:I) use(J)
+
+  //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)
 }
 
 //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) {
   //DUMP: ParmVarDecl{{.*}}t 'T'
   //DUMP: OMPInteropDirective
   //DUMP: OMPInitClause
   //DUMP: DeclRefExpr{{.*}}ParmVar{{.*}}'t' 'T'
   //DUMP: IntegerLiteral{{.*}}'int' 4
   //DUMP: StringLiteral{{.*}}"level_one"
   #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)
+
   //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)
 }
 
 void bar()
 {
   fooTemp<3>();
   omp_interop_t Ivar;
   barTemp(Ivar);
 }
 
 #endif // HEADER

clang/test/OpenMP/interop_messages.cpp

 // RUN: %clang_cc1 -verify -fopenmp -std=c++11 -o - -DWITHDEF %s
 // RUN: %clang_cc1 -verify -fopenmp -std=c++11 -o - -DWITHOUTDEF %s
 
 #ifdef WITHDEF
 typedef void *omp_interop_t;
 
 void foo(int *Ap) {
   omp_interop_t InteropVar;
   omp_interop_t Another;
 
   //expected-error@+1 {{expected interop type: 'target' and/or 'targetsync'}}
   #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@+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 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)
+
   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)
+
   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 {{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 init(target:InteropVar) use(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
 }
 #endif

clang/tools/libclang/CIndex.cpp

 void OMPClauseEnqueue::VisitOMPSIMDClause(const OMPSIMDClause *) {}
 
 void OMPClauseEnqueue::VisitOMPNogroupClause(const OMPNogroupClause *) {}
 
 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::VisitOMPUnifiedAddressClause(
     const OMPUnifiedAddressClause *) {}
 
 void OMPClauseEnqueue::VisitOMPUnifiedSharedMemoryClause(
     const OMPUnifiedSharedMemoryClause *) {}
 

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

 CHECK_SIMPLE_CLAUSE(Unknown, OMPC_unknown)
 CHECK_SIMPLE_CLAUSE(Untied, OMPC_untied)
 CHECK_SIMPLE_CLAUSE(UseDevicePtr, OMPC_use_device_ptr)
 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_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_Order : Clause<"order"> {
   let enumClauseValue = "OrderKind";
   let allowedClauseValues = [
     OMP_ORDER_concurrent
   ];
 }
 def OMPC_Init : Clause<"init"> {
   let clangClass = "OMPInitClause";
 }
+def OMPC_Use : Clause<"use"> {
+  let clangClass = "OMPUseClause";
+}
 def OMPC_Destroy : Clause<"destroy"> {
   let clangClass = "OMPDestroyClause";
 }
 def OMPC_Detach : Clause<"detach"> {
   let clangClass = "OMPDetachClause";
 }
 def OMPC_Inclusive : Clause<"inclusive"> {
   let clangClass = "OMPInclusiveClause";
def OMP_EndWorkshare : Directive<"end workshare"> {
   ];
 }
 def OMP_interop : Directive<"interop"> {
   let allowedClauses = [
     VersionedClause<OMPC_Device>,
     VersionedClause<OMPC_Depend>,
     VersionedClause<OMPC_Init>,
     VersionedClause<OMPC_NoWait>,
+    VersionedClause<OMPC_Use>,
   ];
 }
 def OMP_Unknown : Directive<"unknown"> {
   let isDefault = true;
 }