[OPENMP51]Initial parsing/sema for append_args clause for 'declare variant'

[mikerice]

Summary

Adds initial parsing and sema for the 'append_args' clause.

Note that an AST clause is not created as it instead adds its values
to the OMPDeclareVariantAttr.

[aaron.ballman]

I'm not super familiar with OpenMP code, but are changes needed for AST serialization as well (so that PCH, modules, etc continue to work properly)?

clang/include/clang/Basic/DiagnosticParseKinds.td

1363

I'm hoping this diagnostic makes more sense in situ because I'm not certain what it's telling me. append-op is not a term of art we've used elsewhere, is there a better term we could use or will this be familiar to OpenMP users?

clang/lib/Parse/ParseOpenMP.cpp

1451

Do we need to do any error recovery here for the parser to get back to a known-perhaps-good state?

1501

Because we already know the token is an identifier, we don't need to go back to the preprocessor for this (and that particular interface involves memory allocations because it uses std::string). I think you can do: Tok.getIdentifierInfo()->isStr("target") instead.

1544

Same suggestion here as in the previous function.

1557–1558

Maybe add some comments here about why this is correct and not diagnosed?

1573–1574

Does this need to be a while loop because OpenMP is weird about SkipUntil?

clang/lib/Sema/SemaOpenMP.cpp

7015–7017

7018–7020

Why is this valid? (Functions without prototypes do specify their return type information btw, so it's very weird that we convert this to return void when ginning up a prototype).

7022–7023

I'd like an assertion that PTy is nonnull.

7029

If the lookup fails, silently using a void pointer type is okay?

[mikerice]

Thanks for the review! As far as serialization goes, yes we need it, and the OpenMP tests test this is the ast print and codegen tests. This patch doesn't need anything special since it is just adding another field to the attribute which is serialized correctly with tablegen code afaik.

clang/include/clang/Basic/DiagnosticParseKinds.td

1363

That is from the syntax in the spec: https://www.openmp.org/spec-html/5.1/openmpsu29.html#x46-450002.3.5. Open to suggestions but I don't know what would be better.

clang/lib/Parse/ParseOpenMP.cpp

1451

You mean get back to a good state inside the directive? It seems we mostly just skip out of the OpenMP directives when there is an error like this does.

1573–1574

I think this one is okay. It will stop at the r_paren and consume it here. The caller will skip the tokens until the end of the directive.

clang/lib/Sema/SemaOpenMP.cpp

7018–7020

You're right the return type is wrong here. Thinking about this more though, I don't think we really need to handle the unprototyped case. When append_args are used the variant must be prototyped and contain the extra omp_interop_t parameters. That means we'd be matching a prototyped function with an unprototyped function where we treat it as (void). That would handle only cases where the variant had only interop parameters... seems not useful. I'll instead give an error for the unprototyped case.

[mikerice]

Addressed review comments.

[aaron.ballman]

In D111854#3073851, @mikerice wrote:

Thanks for the review! As far as serialization goes, yes we need it, and the OpenMP tests test this is the ast print and codegen tests. This patch doesn't need anything special since it is just adding another field to the attribute which is serialized correctly with tablegen code afaik.

Hmmm, I took a look through the serialization code that includes OMP.inc and I don't see anything to suggest that this addition causes a change to the AST version. So the situation I'm worried about is where new Clang generates a PCH file with this feature and then hands it to an older Clang without this feature. If you think we have sufficient test coverage for this sort of thing, then okay. But if you think there's not sufficient test coverage, this might be worth a follow-up patch to improve test coverage in general.

The rest of my comments are mostly nits because I'm not really an expert in OpenMP. :-)

clang/include/clang/Basic/DiagnosticParseKinds.td

1363

We usually try to only use grammar terms when they make sensible English prose by removing the hyphens, so I'm thinking of something along the lines of:

unexpected operation specified in 'append_args' clause, expected 'interop'

clang/include/clang/Basic/DiagnosticSemaKinds.td

10752

10754

clang/lib/Parse/ParseOpenMP.cpp

1451

Oh yeah, I see, this skips later, sorry for the noise.

clang/lib/Sema/SemaOpenMP.cpp

7018–7020

+1 -- unprototyped functions have been deprecated for longer than some WG14 committee members have been alive; I think it's a feature to not support them in new offerings.

[ABataev]

clang/include/clang/Parse/Parser.h

3209

parseOpenMPAppendArgs

clang/lib/Parse/ParseOpenMP.cpp

1493

Better to introduce an enum here and return it as a result. Or return Optional<OMPDeclareVariantAttr::InteropType>

clang/test/OpenMP/declare_variant_clauses_messages.cpp

17–87

Add (a) test(s) for varargs functions. Also, what about templates, member functions, static member functions, virtual functions, pure virtual functions?

[mikerice]

clang/test/OpenMP/declare_variant_clauses_messages.cpp

17–87

Added positive and negative tests for templates, member functions, and static member functions. Virtual functions are not allowed for declare variant so I didn't add anything for those. Added a diagnostic for varargs with append_args since it is not clear how that would work or what it means.

[mikerice]

Addressed comments.

[ABataev]

clang/lib/Parse/ParseOpenMP.cpp

1496–1497

Can you worjk with OMPDeclareVariantAttr::InteropType type var instead of using these vars?

clang/test/OpenMP/declare_variant_clauses_messages.cpp

17–87

Can you add tests that (pure) virtual functions are correctly rejected (if don't have ones)?

[mikerice]

Added tests for virtual and pure virtual functions.

[mikerice]

clang/lib/Parse/ParseOpenMP.cpp

1496–1497

Could do that, but it seems to make the code uglier. Instead of

if (IsTarget)
  Diag
isTarget = true;

We'd get:

if (IT == OMPDeclareVariantAttr::Target ||          
    IT == OMPDeclareVariantAttr::Target_TargetSync)
  Diag
if (IT == OMPDeclareVariantAttr::TargetSync)
  IT = OMPDeclareVariantAttr::Target_TargetSync;
else    
  IT = OMPDeclareVariantAttr::Target;

And again for the targetsync case.

Plus there is no unset value in OMPDeclareVariantAttr::Interop type so we'd need to add one (complicating other code) or initialize it with (OMPDeclareVariantAttr::InteropType)-1 or something.

[ABataev]

LG

clang/include/clang/Basic/Attr.td

def OMPDeclareVariant : InheritableAttr {
   let SemaHandler = 0;
   let HasCustomParsing = 1;
   let InheritEvenIfAlreadyPresent = 1;
   let Documentation = [OMPDeclareVariantDocs];
   let Args = [
     ExprArgument<"VariantFuncRef">,
     OMPTraitInfoArgument<"TraitInfos">,
     VariadicExprArgument<"AdjustArgsNothing">,
-    VariadicExprArgument<"AdjustArgsNeedDevicePtr">
+    VariadicExprArgument<"AdjustArgsNeedDevicePtr">,
+    VariadicEnumArgument<"AppendArgs", "InteropType",
+                     ["target", "targetsync", "target,targetsync"],
+                     ["Target", "TargetSync", "Target_TargetSync"]>
   ];
   let AdditionalMembers = [{
     OMPTraitInfo &getTraitInfo() { return *traitInfos; }
     void printPrettyPragma(raw_ostream & OS, const PrintingPolicy &Policy)
         const;
   }];
 }
 

clang/include/clang/Basic/DiagnosticParseKinds.td

 def err_omp_declare_target_multiple : Error<
   "%0 appears multiple times in clauses on the same declare target directive">;
 def err_omp_expected_clause: Error<
   "expected at least one clause on '#pragma omp %0' directive">;
 def err_omp_mapper_illegal_identifier : Error<
   "illegal OpenMP user-defined mapper identifier">;
 def err_omp_mapper_expected_declarator : Error<
   "expected declarator on 'omp declare mapper' directive">;
+def err_omp_unexpected_append_op : Error<
+  "unexpected operation specified in 'append_args' clause, expected 'interop'">;
 def err_omp_declare_variant_wrong_clause : Error<
-  "expected %select{'match'|'match' or 'adjust_args'}0 clause on "
-  "'omp declare variant' directive">;
+  "expected %select{'match'|'match', 'adjust_args', or 'append_args'}0 clause "
+  "on 'omp declare variant' directive">;
 def err_omp_declare_variant_duplicate_nested_trait : Error<
   "nested OpenMP context selector contains duplicated trait '%0'"
   " in selector '%1' and set '%2' with different score">;
 def err_omp_declare_variant_nested_user_condition : Error<
   "nested user conditions in OpenMP context selector not supported (yet)">;
 def warn_omp_declare_variant_string_literal_or_identifier
     : Warning<"expected identifier or string literal describing a context "
               "%select{set|selector|property}0; "

clang/include/clang/Basic/DiagnosticSemaKinds.td

def err_omp_declare_variant_doesnt_support : Error<
   "'#pragma omp declare variant' does not "
   "support %select{function templates|virtual functions|"
   "deduced return types|constructors|destructors|deleted functions|"
   "defaulted functions|constexpr functions|consteval function}0">;
 def err_omp_declare_variant_diff : Error<
   "function with '#pragma omp declare variant' has a different %select{calling convention"
   "|return type|constexpr specification|inline specification|storage class|"
   "linkage}0">;
+def err_omp_declare_variant_prototype_required : Error<
+  "function with '#pragma omp declare variant' must have a prototype when "
+  "'append_args' is used">;
+def err_omp_interop_type_not_found : Error<
+  "'omp_interop_t' must be defined when 'append_args' clause is used; include <omp.h>">;
 def err_omp_declare_variant_incompat_types : Error<
-  "variant in '#pragma omp declare variant' with type %0 is incompatible with type %1"
-  >;
+  "variant in '#pragma omp declare variant' with type %0 is incompatible with"
+  " type %1%select{| with appended arguments}2">;
 def warn_omp_declare_variant_marked_as_declare_variant : Warning<
   "variant function in '#pragma omp declare variant' is itself marked as '#pragma omp declare variant'"
   >, InGroup<SourceUsesOpenMP>;
 def note_omp_marked_declare_variant_here : Note<"marked as 'declare variant' here">;
 def err_omp_one_defaultmap_each_category: Error<
   "at most one defaultmap clause for each variable-category can appear on the directive">;
 def err_omp_lastprivate_conditional_non_scalar : Error<
   "expected list item of scalar type in 'lastprivate' clause with 'conditional' modifier"
def err_omp_unroll_full_variable_trip_count : Error<
   "loop to be fully unrolled must have a constant trip count">;
 def note_omp_directive_here : Note<"'%0' directive found here">;
 def err_omp_instantiation_not_supported
     : Error<"instantiation of '%0' not supported yet">;
 def err_omp_adjust_arg_multiple_clauses : Error<
   "'adjust_arg' argument %0 used in multiple clauses">;
 def err_omp_clause_requires_dispatch_construct : Error<
   "'%0' clause requires 'dispatch' context selector">;
+def err_omp_append_args_with_varargs : Error<
+  "'append_args' is not allowed with varargs functions">;
 } // 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/Parse/Parser.h

private:
 
   /// Parses an OpenMP context selector set.
   void parseOMPContextSelectorSet(OMPTraitSet &TISet,
                                   llvm::StringMap<SourceLocation> &SeenSets);
 
   /// Parses OpenMP context selectors.
   bool parseOMPContextSelectors(SourceLocation Loc, OMPTraitInfo &TI);
 
+  /// Parse an 'append_args' clause for '#pragma omp declare variant'.
+  bool parseOpenMPAppendArgs(
+      SmallVectorImpl<OMPDeclareVariantAttr::InteropType> &InterOpTypes);
+
   /// Parse a `match` clause for an '#pragma omp declare variant'. Return true
   /// if there was an error.
   bool parseOMPDeclareVariantMatchClause(SourceLocation Loc, OMPTraitInfo &TI,
                                          OMPTraitInfo *ParentTI);
 
   /// Parse clauses for '#pragma omp declare variant'.
   void ParseOMPDeclareVariantClauses(DeclGroupPtrTy Ptr, CachedTokens &Toks,
                                      SourceLocation Loc);

clang/include/clang/Sema/Sema.h

public:
 
   /// Checks '\#pragma omp declare variant' variant function and original
   /// functions after parsing of the associated method/function.
   /// \param DG Function declaration to which declare variant directive is
   /// applied to.
   /// \param VariantRef Expression that references the variant function, which
   /// must be used instead of the original one, specified in \p DG.
   /// \param TI The trait info object representing the match clause.
+  /// \param NumAppendArgs The number of omp_interop_t arguments to account for
+  /// in checking.
   /// \returns None, if the function/variant function are not compatible with
   /// the pragma, pair of original function/variant ref expression otherwise.
   Optional<std::pair<FunctionDecl *, Expr *>>
   checkOpenMPDeclareVariantFunction(DeclGroupPtrTy DG, Expr *VariantRef,
-                                    OMPTraitInfo &TI, SourceRange SR);
+                                    OMPTraitInfo &TI, unsigned NumAppendArgs,
+                                    SourceRange SR);
 
   /// Called on well-formed '\#pragma omp declare variant' after parsing of
   /// the associated method/function.
   /// \param FD Function declaration to which declare variant directive is
   /// applied to.
   /// \param VariantRef Expression that references the variant function, which
   /// must be used instead of the original one, specified in \p DG.
   /// \param TI The context traits associated with the function variant.
+  /// \param AdjustArgsNothing The list of 'nothing' arguments.
+  /// \param AdjustArgsNeedDevicePtr The list of 'need_device_ptr' arguments.
+  /// \param AppendArgs The list of 'append_args' arguments.
+  /// \param AdjustArgsLoc The Location of an 'adjust_args' clause.
+  /// \param AppendArgsLoc The Location of an 'append_args' clause.
+  /// \param SR The SourceRange of the 'declare variant' directive.
   void ActOnOpenMPDeclareVariantDirective(
       FunctionDecl *FD, Expr *VariantRef, OMPTraitInfo &TI,
       ArrayRef<Expr *> AdjustArgsNothing,
-      ArrayRef<Expr *> AdjustArgsNeedDevicePtr, SourceRange SR);
+      ArrayRef<Expr *> AdjustArgsNeedDevicePtr,
+      ArrayRef<OMPDeclareVariantAttr::InteropType> AppendArgs,
+      SourceLocation AdjustArgsLoc, SourceLocation AppendArgsLoc,
+      SourceRange SR);
 
   OMPClause *ActOnOpenMPSingleExprClause(OpenMPClauseKind Kind,
                                          Expr *Expr,
                                          SourceLocation StartLoc,
                                          SourceLocation LParenLoc,
                                          SourceLocation EndLoc);
   /// Called on well-formed 'allocator' clause.
   OMPClause *ActOnOpenMPAllocatorClause(Expr *Allocator,

clang/lib/AST/AttrImpl.cpp

if (adjustArgsNothing_size()) {
     PrintExprs(adjustArgsNothing_begin(), adjustArgsNothing_end());
     OS << ")";
   }
   if (adjustArgsNeedDevicePtr_size()) {
     OS << " adjust_args(need_device_ptr:";
     PrintExprs(adjustArgsNeedDevicePtr_begin(), adjustArgsNeedDevicePtr_end());
     OS << ")";
   }
+
+  auto PrintInteropTypes = [&OS](InteropType *Begin, InteropType *End) {
+    for (InteropType *I = Begin; I != End; ++I) {
+      if (I != Begin)
+        OS << ", ";
+      OS << "interop(";
+      OS << ConvertInteropTypeToStr(*I);
+      OS << ")";
+    }
+  };
+  if (appendArgs_size()) {
+    OS << " append_args(";
+    PrintInteropTypes(appendArgs_begin(), appendArgs_end());
+    OS << ")";
+  }
 }
 
 #include "clang/AST/AttrImpl.inc"

clang/lib/Basic/OpenMPKinds.cpp

#include "clang/Basic/OpenMPKinds.def"
   case OMPC_novariants:
   case OMPC_nocontext:
   case OMPC_detach:
   case OMPC_inclusive:
   case OMPC_exclusive:
   case OMPC_uses_allocators:
   case OMPC_affinity:
   case OMPC_when:
+  case OMPC_append_args:
     break;
   default:
     break;
   }
   llvm_unreachable("Invalid OpenMP simple clause kind");
 }
 
 const char *clang::getOpenMPSimpleClauseTypeName(OpenMPClauseKind Kind,
#include "clang/Basic/OpenMPKinds.def"
   case OMPC_detach:
   case OMPC_novariants:
   case OMPC_nocontext:
   case OMPC_inclusive:
   case OMPC_exclusive:
   case OMPC_uses_allocators:
   case OMPC_affinity:
   case OMPC_when:
+  case OMPC_append_args:
     break;
   default:
     break;
   }
   llvm_unreachable("Invalid OpenMP simple clause kind");
 }
 
 bool clang::isOpenMPLoopDirective(OpenMPDirectiveKind DKind) {

clang/lib/CodeGen/CGStmtOpenMP.cpp

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

clang/lib/Parse/ParseOpenMP.cpp

if (!AssociatedFunction.isUsable()) {
     return;
   }
 
   OMPTraitInfo *ParentTI = Actions.getOMPTraitInfoForSurroundingScope();
   ASTContext &ASTCtx = Actions.getASTContext();
   OMPTraitInfo &TI = ASTCtx.getNewOMPTraitInfo();
   SmallVector<Expr *, 6> AdjustNothing;
   SmallVector<Expr *, 6> AdjustNeedDevicePtr;
+  SmallVector<OMPDeclareVariantAttr::InteropType, 3> AppendArgs;
+  SourceLocation AdjustArgsLoc, AppendArgsLoc;
 
   // At least one clause is required.
   if (Tok.is(tok::annot_pragma_openmp_end)) {
     Diag(Tok.getLocation(), diag::err_omp_declare_variant_wrong_clause)
         << (getLangOpts().OpenMP < 51 ? 0 : 1);
   }
 
   bool IsError = false;
   while (Tok.isNot(tok::annot_pragma_openmp_end)) {
     OpenMPClauseKind CKind = Tok.isAnnotation()
                                  ? OMPC_unknown
                                  : getOpenMPClauseKind(PP.getSpelling(Tok));
     if (!isAllowedClauseForDirective(OMPD_declare_variant, CKind,
                                      getLangOpts().OpenMP)) {
       Diag(Tok.getLocation(), diag::err_omp_declare_variant_wrong_clause)
           << (getLangOpts().OpenMP < 51 ? 0 : 1);
       IsError = true;
     }
     if (!IsError) {
       switch (CKind) {
       case OMPC_match:
         IsError = parseOMPDeclareVariantMatchClause(Loc, TI, ParentTI);
         break;
       case OMPC_adjust_args: {
+        AdjustArgsLoc = Tok.getLocation();
         ConsumeToken();
         Parser::OpenMPVarListDataTy Data;
         SmallVector<Expr *> Vars;
         IsError = ParseOpenMPVarList(OMPD_declare_variant, OMPC_adjust_args,
                                      Vars, Data);
         if (!IsError)
           llvm::append_range(Data.ExtraModifier == OMPC_ADJUST_ARGS_nothing
                                  ? AdjustNothing
                                  : AdjustNeedDevicePtr,
                              Vars);
         break;
       }
+      case OMPC_append_args:
+        if (!AppendArgs.empty()) {
+          Diag(AppendArgsLoc, diag::err_omp_more_one_clause)
+              << getOpenMPDirectiveName(OMPD_declare_variant)
+              << getOpenMPClauseName(CKind) << 0;
+          IsError = true;
+        }
+        if (!IsError) {
+          AppendArgsLoc = Tok.getLocation();
+          ConsumeToken();
+          IsError = parseOpenMPAppendArgs(AppendArgs);
+        }
+        break;
       default:
         llvm_unreachable("Unexpected clause for declare variant.");
       }
     }
     if (IsError) {
       while (!SkipUntil(tok::annot_pragma_openmp_end, StopBeforeMatch))
         ;
       // Skip the last annot_pragma_openmp_end.
       (void)ConsumeAnnotationToken();
       return;
     }
     // Skip ',' if any.
     if (Tok.is(tok::comma))
       ConsumeToken();
   }
 
   Optional<std::pair<FunctionDecl *, Expr *>> DeclVarData =
       Actions.checkOpenMPDeclareVariantFunction(
-          Ptr, AssociatedFunction.get(), TI,
+          Ptr, AssociatedFunction.get(), TI, AppendArgs.size(),
           SourceRange(Loc, Tok.getLocation()));
 
   if (DeclVarData && !TI.Sets.empty())
     Actions.ActOnOpenMPDeclareVariantDirective(
         DeclVarData->first, DeclVarData->second, TI, AdjustNothing,
-        AdjustNeedDevicePtr, SourceRange(Loc, Tok.getLocation()));
+        AdjustNeedDevicePtr, AppendArgs, AdjustArgsLoc, AppendArgsLoc,
+        SourceRange(Loc, Tok.getLocation()));
 
   // Skip the last annot_pragma_openmp_end.
   (void)ConsumeAnnotationToken();
 }
 
+/// Parse a list of interop-types. These are 'target' and 'targetsync'. Both
+/// are allowed but duplication of either is not meaningful.
+static Optional<OMPDeclareVariantAttr::InteropType>
+parseInteropTypeList(Parser &P) {
+  const Token &Tok = P.getCurToken();
+  bool HasError = false;
+  bool IsTarget = false;
+  bool IsTargetSync = false;
+
+  while (Tok.is(tok::identifier)) {
+    if (Tok.getIdentifierInfo()->isStr("target")) {
+      // OpenMP 5.1 [2.15.1, interop Construct, Restrictions]
+      // Each interop-type may be specified on an action-clause at most
+      // once.
+      if (IsTarget)
+        P.Diag(Tok, diag::warn_omp_more_one_interop_type) << "target";
+      IsTarget = true;
+    } else if (Tok.getIdentifierInfo()->isStr("targetsync")) {
+      if (IsTargetSync)
+        P.Diag(Tok, diag::warn_omp_more_one_interop_type) << "targetsync";
+      IsTargetSync = true;
+    } else {
+      HasError = true;
+      P.Diag(Tok, diag::err_omp_expected_interop_type);
+    }
+    P.ConsumeToken();
+
+    if (!Tok.is(tok::comma))
+      break;
+    P.ConsumeToken();
+  }
+  if (HasError)
+    return None;
+
+  if (!IsTarget && !IsTargetSync) {
+    P.Diag(Tok, diag::err_omp_expected_interop_type);
+    return None;
+  }
+
+  // As of OpenMP 5.1,there are two interop-types, "target" and
+  // "targetsync". Either or both are allowed for a single interop.
+  if (IsTarget && IsTargetSync)
+    return OMPDeclareVariantAttr::Target_TargetSync;
+  if (IsTarget)
+    return OMPDeclareVariantAttr::Target;
+  return OMPDeclareVariantAttr::TargetSync;
+}
+
+bool Parser::parseOpenMPAppendArgs(
+    SmallVectorImpl<OMPDeclareVariantAttr::InteropType> &InterOpTypes) {
+  bool HasError = false;
+  // Parse '('.
+  BalancedDelimiterTracker T(*this, tok::l_paren, tok::annot_pragma_openmp_end);
+  if (T.expectAndConsume(diag::err_expected_lparen_after,
+                         getOpenMPClauseName(OMPC_append_args).data()))
+    return true;
+
+  // Parse the list of append-ops, each is;
+  // interop(interop-type[,interop-type]...)
+  while (Tok.is(tok::identifier) && Tok.getIdentifierInfo()->isStr("interop")) {
+    ConsumeToken();
+    BalancedDelimiterTracker IT(*this, tok::l_paren,
+                                tok::annot_pragma_openmp_end);
+    if (IT.expectAndConsume(diag::err_expected_lparen_after, "interop"))
+      return true;
+
+    // Parse the interop-types.
+    if (Optional<OMPDeclareVariantAttr::InteropType> IType =
+            parseInteropTypeList(*this))
+      InterOpTypes.push_back(IType.getValue());
+    else
+      HasError = true;
+
+    IT.consumeClose();
+    if (Tok.is(tok::comma))
+      ConsumeToken();
+  }
+  if (!HasError && InterOpTypes.empty()) {
+    HasError = true;
+    Diag(Tok.getLocation(), diag::err_omp_unexpected_append_op);
+    SkipUntil(tok::comma, tok::r_paren, tok::annot_pragma_openmp_end,
+              StopBeforeMatch);
+  }
+  HasError = T.consumeClose() || HasError;
+  return HasError;
+}
+
 bool Parser::parseOMPDeclareVariantMatchClause(SourceLocation Loc,
                                                OMPTraitInfo &TI,
                                                OMPTraitInfo *ParentTI) {
   // Parse 'match'.
   OpenMPClauseKind CKind = Tok.isAnnotation()
                                ? OMPC_unknown
                                : getOpenMPClauseKind(PP.getSpelling(Tok));
   if (CKind != OMPC_match) {
if (Kind == OMPC_init) {
     if (!Prefs.empty()) {
       if (Tok.is(tok::comma))
         ConsumeToken();
       else
         Diag(Tok, diag::err_omp_expected_punc_after_interop_mod);
     }
 
     // Parse the interop-types.
-    bool HasError = false;
-    while (Tok.is(tok::identifier)) {
-      if (PP.getSpelling(Tok) == "target") {
-        // OpenMP 5.1 [2.15.1, interop Construct, Restrictions]
-        // Each interop-type may be specified on an action-clause at most
-        // once.
-        if (IsTarget)
-          Diag(Tok, diag::warn_omp_more_one_interop_type) << "target";
-        IsTarget = true;
-      } else if (PP.getSpelling(Tok) == "targetsync") {
-        if (IsTargetSync)
-          Diag(Tok, diag::warn_omp_more_one_interop_type) << "targetsync";
-        IsTargetSync = true;
-      } else {
-        HasError = true;
-        Diag(Tok, diag::err_omp_expected_interop_type);
-      }
-      ConsumeToken();
-
-      if (!Tok.is(tok::comma))
-        break;
-      ConsumeToken();
+    if (Optional<OMPDeclareVariantAttr::InteropType> IType =
+            parseInteropTypeList(*this)) {
+      IsTarget = IType != OMPDeclareVariantAttr::TargetSync;
+      IsTargetSync = IType != OMPDeclareVariantAttr::Target;
+      if (Tok.isNot(tok::colon))
+        Diag(Tok, diag::warn_pragma_expected_colon) << "interop types";
     }
-    if (!HasError && !IsTarget && !IsTargetSync)
-      Diag(Tok, diag::err_omp_expected_interop_type);
-
     if (Tok.is(tok::colon))
       ConsumeToken();
-    else if (IsTarget || IsTargetSync)
-      Diag(Tok, diag::warn_pragma_expected_colon) << "interop types";
   }
 
   // Parse the variable.
   SourceLocation VarLoc = Tok.getLocation();
   ExprResult InteropVarExpr =
       Actions.CorrectDelayedTyposInExpr(ParseAssignmentExpression());
   if (!InteropVarExpr.isUsable()) {
     SkipUntil(tok::comma, tok::r_paren, tok::annot_pragma_openmp_end,

clang/lib/Sema/SemaOpenMP.cpp

auto *VariantFuncRef = DeclRefExpr::Create(
       /* RefersToEnclosingVariableOrCapture */ false,
       /* NameLoc */ FD->getLocation(), FD->getType(),
       ExprValueKind::VK_PRValue);
 
   OMPDeclareVariantScope &DVScope = OMPDeclareVariantScopes.back();
   auto *OMPDeclareVariantA = OMPDeclareVariantAttr::CreateImplicit(
       Context, VariantFuncRef, DVScope.TI,
       /*NothingArgs=*/nullptr, /*NothingArgsSize=*/0,
-      /*NeedDevicePtrArgs=*/nullptr, /*NeedDevicePtrArgsSize=*/0);
+      /*NeedDevicePtrArgs=*/nullptr, /*NeedDevicePtrArgsSize=*/0,
+      /*AppendArgs=*/nullptr, /*AppendArgsSize=*/0);
   for (FunctionDecl *BaseFD : Bases)
     BaseFD->addAttr(OMPDeclareVariantA);
 }
 
 ExprResult Sema::ActOnOpenMPCall(ExprResult Call, Scope *Scope,
                                  SourceLocation LParenLoc,
                                  MultiExprArg ArgExprs,
                                  SourceLocation RParenLoc, Expr *ExecConfig) {
ExprResult Sema::ActOnOpenMPCall(ExprResult Call, Scope *Scope,
   if (!NewCall.isUsable())
     return Call;
   return PseudoObjectExpr::Create(Context, CE, {NewCall.get()}, 0);
 }
 
 Optional<std::pair<FunctionDecl *, Expr *>>
 Sema::checkOpenMPDeclareVariantFunction(Sema::DeclGroupPtrTy DG,
                                         Expr *VariantRef, OMPTraitInfo &TI,
+                                        unsigned NumAppendArgs,
                                         SourceRange SR) {
   if (!DG || DG.get().isNull())
     return None;
 
   const int VariantId = 1;
   // Must be applied only to single decl.
   if (!DG.get().isSingleDecl()) {
     Diag(SR.getBegin(), diag::err_omp_single_decl_in_declare_simd_variant)
if (IsScore) {
            diag::err_omp_declare_variant_user_condition_not_constant)
           << E;
     }
     return true;
   };
   if (TI.anyScoreOrCondition(HandleNonConstantScoresAndConditions))
     return None;
 
+  QualType AdjustedFnType = FD->getType();
+  if (NumAppendArgs) {
+    if (isa<FunctionNoProtoType>(FD->getType())) {
+      Diag(FD->getLocation(), diag::err_omp_declare_variant_prototype_required)
+          << SR;
+      return None;
+    }
+    // Adjust the function type to account for an extra omp_interop_t for each
+    // specified in the append_args clause.
+    const TypeDecl *TD = nullptr;
+    LookupResult Result(*this, &Context.Idents.get("omp_interop_t"),
+                        SR.getBegin(), Sema::LookupOrdinaryName);
+    if (LookupName(Result, getCurScope())) {
+      NamedDecl *ND = Result.getFoundDecl();
+      TD = dyn_cast_or_null<TypeDecl>(ND);
+    }
+    if (!TD) {
+      Diag(SR.getBegin(), diag::err_omp_interop_type_not_found) << SR;
+      return None;
+    }
+    QualType InteropType = QualType(TD->getTypeForDecl(), 0);
+    auto *PTy = cast<FunctionProtoType>(FD->getType());
+    if (PTy->isVariadic()) {
+      Diag(FD->getLocation(), diag::err_omp_append_args_with_varargs) << SR;
+      return None;
+    }
+    llvm::SmallVector<QualType, 8> Params;
+    Params.append(PTy->param_type_begin(), PTy->param_type_end());
+    Params.insert(Params.end(), NumAppendArgs, InteropType);
+    AdjustedFnType = Context.getFunctionType(PTy->getReturnType(), Params,
+                                             PTy->getExtProtoInfo());
+  }
+
   // Convert VariantRef expression to the type of the original function to
   // resolve possible conflicts.
   ExprResult VariantRefCast = VariantRef;
   if (LangOpts.CPlusPlus) {
     QualType FnPtrType;
     auto *Method = dyn_cast<CXXMethodDecl>(FD);
     if (Method && !Method->isStatic()) {
       const Type *ClassType =
           Context.getTypeDeclType(Method->getParent()).getTypePtr();
-      FnPtrType = Context.getMemberPointerType(FD->getType(), ClassType);
+      FnPtrType = Context.getMemberPointerType(AdjustedFnType, ClassType);
       ExprResult ER;
       {
         // Build adrr_of unary op to correctly handle type checks for member
         // functions.
         Sema::TentativeAnalysisScope Trap(*this);
         ER = CreateBuiltinUnaryOp(VariantRef->getBeginLoc(), UO_AddrOf,
                                   VariantRef);
       }
       if (!ER.isUsable()) {
         Diag(VariantRef->getExprLoc(), diag::err_omp_function_expected)
             << VariantId << VariantRef->getSourceRange();
         return None;
       }
       VariantRef = ER.get();
     } else {
-      FnPtrType = Context.getPointerType(FD->getType());
+      FnPtrType = Context.getPointerType(AdjustedFnType);
     }
     QualType VarianPtrType = Context.getPointerType(VariantRef->getType());
     if (VarianPtrType.getUnqualifiedType() != FnPtrType.getUnqualifiedType()) {
       ImplicitConversionSequence ICS = TryImplicitConversion(
           VariantRef, FnPtrType.getUnqualifiedType(),
           /*SuppressUserConversions=*/false, AllowedExplicit::None,
           /*InOverloadResolution=*/false,
           /*CStyle=*/false,
           /*AllowObjCWritebackConversion=*/false);
       if (ICS.isFailure()) {
         Diag(VariantRef->getExprLoc(),
              diag::err_omp_declare_variant_incompat_types)
             << VariantRef->getType()
             << ((Method && !Method->isStatic()) ? FnPtrType : FD->getType())
-            << VariantRef->getSourceRange();
+            << (NumAppendArgs ? 1 : 0) << VariantRef->getSourceRange();
         return None;
       }
       VariantRefCast = PerformImplicitConversion(
           VariantRef, FnPtrType.getUnqualifiedType(), AA_Converting);
       if (!VariantRefCast.isUsable())
         return None;
     }
     // Drop previously built artificial addr_of unary op for member functions.
if (!NewFD) {
     Diag(VariantRef->getExprLoc(), diag::err_omp_function_expected)
         << VariantId << VariantRef->getSourceRange();
     return None;
   }
 
   // Check if function types are compatible in C.
   if (!LangOpts.CPlusPlus) {
     QualType NewType =
-        Context.mergeFunctionTypes(FD->getType(), NewFD->getType());
+        Context.mergeFunctionTypes(AdjustedFnType, NewFD->getType());
     if (NewType.isNull()) {
       Diag(VariantRef->getExprLoc(),
            diag::err_omp_declare_variant_incompat_types)
-          << NewFD->getType() << FD->getType() << VariantRef->getSourceRange();
+          << NewFD->getType() << FD->getType() << (NumAppendArgs ? 1 : 0)
+          << VariantRef->getSourceRange();
       return None;
     }
     if (NewType->isFunctionProtoType()) {
       if (FD->getType()->isFunctionNoProtoType())
         setPrototype(*this, FD, NewFD, NewType);
       else if (NewFD->getType()->isFunctionNoProtoType())
         setPrototype(*this, NewFD, FD, NewType);
     }
if (areMultiversionVariantFunctionsCompatible(
           /*CLinkageMayDiffer=*/true))
     return None;
   return std::make_pair(FD, cast<Expr>(DRE));
 }
 
 void Sema::ActOnOpenMPDeclareVariantDirective(
     FunctionDecl *FD, Expr *VariantRef, OMPTraitInfo &TI,
     ArrayRef<Expr *> AdjustArgsNothing,
-    ArrayRef<Expr *> AdjustArgsNeedDevicePtr, SourceRange SR) {
+    ArrayRef<Expr *> AdjustArgsNeedDevicePtr,
+    ArrayRef<OMPDeclareVariantAttr::InteropType> AppendArgs,
+    SourceLocation AdjustArgsLoc, SourceLocation AppendArgsLoc,
+    SourceRange SR) {
 
   // OpenMP 5.1 [2.3.5, declare variant directive, Restrictions]
   // An adjust_args clause or append_args clause can only be specified if the
   // dispatch selector of the construct selector set appears in the match
   // clause.
 
   SmallVector<Expr *, 8> AllAdjustArgs;
   llvm::append_range(AllAdjustArgs, AdjustArgsNothing);
   llvm::append_range(AllAdjustArgs, AdjustArgsNeedDevicePtr);
 
-  if (!AllAdjustArgs.empty()) {
+  if (!AllAdjustArgs.empty() || !AppendArgs.empty()) {
     VariantMatchInfo VMI;
     TI.getAsVariantMatchInfo(Context, VMI);
     if (!llvm::is_contained(
             VMI.ConstructTraits,
             llvm::omp::TraitProperty::construct_dispatch_dispatch)) {
-      Diag(AllAdjustArgs[0]->getExprLoc(),
-           diag::err_omp_clause_requires_dispatch_construct)
+      if (!AllAdjustArgs.empty())
+        Diag(AdjustArgsLoc, diag::err_omp_clause_requires_dispatch_construct)
             << getOpenMPClauseName(OMPC_adjust_args);
+      if (!AppendArgs.empty())
+        Diag(AppendArgsLoc, diag::err_omp_clause_requires_dispatch_construct)
+            << getOpenMPClauseName(OMPC_append_args);
       return;
     }
   }
 
   // OpenMP 5.1 [2.3.5, declare variant directive, Restrictions]
   // Each argument can only appear in a single adjust_args clause for each
   // declare variant directive.
   llvm::SmallPtrSet<const VarDecl *, 4> AdjustVars;
for (Expr *E : AllAdjustArgs) {
     Diag(E->getExprLoc(), diag::err_omp_param_or_this_in_clause) << FD << 0;
     return;
   }
 
   auto *NewAttr = OMPDeclareVariantAttr::CreateImplicit(
       Context, VariantRef, &TI, const_cast<Expr **>(AdjustArgsNothing.data()),
       AdjustArgsNothing.size(),
       const_cast<Expr **>(AdjustArgsNeedDevicePtr.data()),
-      AdjustArgsNeedDevicePtr.size(), SR);
+      AdjustArgsNeedDevicePtr.size(),
+      const_cast<OMPDeclareVariantAttr::InteropType *>(AppendArgs.data()),
+      AppendArgs.size(), SR);
   FD->addAttr(NewAttr);
 }
 
 StmtResult Sema::ActOnOpenMPParallelDirective(ArrayRef<OMPClause *> Clauses,
                                               Stmt *AStmt,
                                               SourceLocation StartLoc,
                                               SourceLocation EndLoc) {
   if (!AStmt)

clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

if (TI.anyScoreOrCondition(SubstScoreOrConditionExpr))
     return;
 
   Expr *E = VariantFuncRef.get();
 
   // Check function/variant ref for `omp declare variant` but not for `omp
   // begin declare variant` (which use implicit attributes).
   Optional<std::pair<FunctionDecl *, Expr *>> DeclVarData =
       S.checkOpenMPDeclareVariantFunction(S.ConvertDeclToDeclGroup(New), E, TI,
+                                          Attr.appendArgs_size(),
                                           Attr.getRange());
 
   if (!DeclVarData)
     return;
 
   E = DeclVarData.getValue().second;
   FD = DeclVarData.getValue().first;
 
if (auto *VariantFD = dyn_cast<FunctionDecl>(VariantDRE->getDecl())) {
                                 /* NameLoc */ SubstFD->getLocation(),
                                 SubstFD->getType(), ExprValueKind::VK_PRValue);
       }
     }
   }
 
   SmallVector<Expr *, 8> NothingExprs;
   SmallVector<Expr *, 8> NeedDevicePtrExprs;
+  SmallVector<OMPDeclareVariantAttr::InteropType, 8> AppendArgs;
+
   for (Expr *E : Attr.adjustArgsNothing()) {
     ExprResult ER = Subst(E);
     if (ER.isInvalid())
       continue;
     NothingExprs.push_back(ER.get());
   }
   for (Expr *E : Attr.adjustArgsNeedDevicePtr()) {
     ExprResult ER = Subst(E);
     if (ER.isInvalid())
       continue;
     NeedDevicePtrExprs.push_back(ER.get());
   }
-  S.ActOnOpenMPDeclareVariantDirective(FD, E, TI, NothingExprs,
-                                       NeedDevicePtrExprs, Attr.getRange());
+  for (auto A : Attr.appendArgs())
+    AppendArgs.push_back(A);
+
+  S.ActOnOpenMPDeclareVariantDirective(
+      FD, E, TI, NothingExprs, NeedDevicePtrExprs, AppendArgs, SourceLocation(),
+      SourceLocation(), Attr.getRange());
 }
 
 static void instantiateDependentAMDGPUFlatWorkGroupSizeAttr(
     Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
     const AMDGPUFlatWorkGroupSizeAttr &Attr, Decl *New) {
   // Both min and max expression are constant expressions.
   EnterExpressionEvaluationContext Unevaluated(
       S, Sema::ExpressionEvaluationContext::ConstantEvaluated);

clang/test/OpenMP/declare_variant_clauses_ast_print.cpp

 {
   float *A;
   float *B;
 
   //#pragma omp dispatch
   Foo(A, B);
 }
 
+typedef void *omp_interop_t;
+
+void bar_v1(float* F1, float *F2, omp_interop_t);
+void bar_v2(float* F1, float *F2, omp_interop_t, omp_interop_t);
+
+//PRINT: #pragma omp declare variant(bar_v1) match(construct={dispatch}) append_args(interop(target,targetsync))
+//DUMP: FunctionDecl{{.*}}bar1 'void (float *, float *)'
+//DUMP: OMPDeclareVariantAttr{{.*}}construct={dispatch} Target_TargetSync
+//DUMP: DeclRefExpr{{.*}}bar_v1
+#pragma omp declare variant(bar_v1) match(construct={dispatch}) \
+                                    append_args(interop(target,targetsync))
+void bar1(float *FF1, float *FF2) { return; }
+
+//PRINT: #pragma omp declare variant(bar_v1) match(construct={dispatch}) append_args(interop(targetsync))
+//DUMP: FunctionDecl{{.*}}bar2 'void (float *, float *)'
+//DUMP: OMPDeclareVariantAttr{{.*}}construct={dispatch} TargetSync
+//DUMP: DeclRefExpr{{.*}}bar_v1
+#pragma omp declare variant(bar_v1) match(construct={dispatch}) \
+                                    append_args(interop(targetsync))
+void bar2(float *FF1, float *FF2) { return; }
+
+//PRINT: #pragma omp declare variant(bar_v1) match(construct={dispatch}) append_args(interop(target))
+//DUMP: FunctionDecl{{.*}}bar3 'void (float *, float *)'
+//DUMP: OMPDeclareVariantAttr{{.*}}construct={dispatch} Target
+//DUMP: DeclRefExpr{{.*}}bar_v1
+#pragma omp declare variant(bar_v1) match(construct={dispatch}) \
+                                    append_args(interop(target))
+void bar3(float *FF1, float *FF2) { return; }
+
+//PRINT: #pragma omp declare variant(bar_v2) match(construct={dispatch}) append_args(interop(target), interop(targetsync))
+//DUMP: FunctionDecl{{.*}}bar4 'void (float *, float *)'
+//DUMP: OMPDeclareVariantAttr{{.*}}construct={dispatch} Target TargetSync
+//DUMP: DeclRefExpr{{.*}}bar_v2
+#pragma omp declare variant(bar_v2) match(construct={dispatch}) \
+                       append_args(interop(target), interop(targetsync))
+void bar4(float *FF1, float *FF2) { return; }
+
+//PRINT: #pragma omp declare variant(bar_v2) match(construct={dispatch}) append_args(interop(targetsync), interop(target))
+//DUMP: FunctionDecl{{.*}}bar5 'void (float *, float *)'
+//DUMP: OMPDeclareVariantAttr{{.*}}construct={dispatch} TargetSync Target
+//DUMP: DeclRefExpr{{.*}}bar_v2
+#pragma omp declare variant(bar_v2) match(construct={dispatch}) \
+                       append_args(interop(targetsync), interop(target))
+void bar5(float *FF1, float *FF2) { return; }
+
+//PRINT: class A {
+//DUMP: CXXRecordDecl{{.*}}class A definition
+class A {
+public:
+  void memberfoo_v1(float *A, float *B, int *I, omp_interop_t IOp);
+  //PRINT: #pragma omp declare variant(memberfoo_v1) match(construct={dispatch}) append_args(interop(target))
+  //DUMP: CXXMethodDecl{{.*}}memberbar 'void (float *, float *, int *)'
+  //DUMP: OMPDeclareVariantAttr{{.*}}Implicit construct={dispatch} Target
+  //DUMP: DeclRefExpr{{.*}}'memberfoo_v1' 'void (float *, float *, int *, omp_interop_t)'
+  #pragma omp declare variant(memberfoo_v1) match(construct={dispatch}) \
+    append_args(interop(target))
+  void memberbar(float *A, float *B, int *I) { return; }
+
+  static void smemberfoo_v1(float *A, float *B, int *I, omp_interop_t IOp);
+  //PRINT: #pragma omp declare variant(smemberfoo_v1) match(construct={dispatch}) append_args(interop(target))
+  //DUMP: CXXMethodDecl{{.*}}smemberbar 'void (float *, float *, int *)' static
+  //DUMP: OMPDeclareVariantAttr{{.*}}Implicit construct={dispatch} Target
+  //DUMP: DeclRefExpr{{.*}}'smemberfoo_v1' 'void (float *, float *, int *, omp_interop_t)'
+  #pragma omp declare variant(smemberfoo_v1) match(construct={dispatch}) \
+    append_args(interop(target))
+  static void smemberbar(float *A, float *B, int *I) { return; }
+};
+
+template <typename T> void templatefoo_v1(const T& t, omp_interop_t I);
+template <typename T> void templatebar(const T& t) {}
+
+//PRINT: #pragma omp declare variant(templatefoo_v1<int>) match(construct={dispatch}) append_args(interop(target))
+//DUMP: FunctionDecl{{.*}}templatebar 'void (const int &)'
+//DUMP: OMPDeclareVariantAttr{{.*}}Implicit construct={dispatch} Target
+//DUMP: DeclRefExpr{{.*}}'templatefoo_v1' 'void (const int &, omp_interop_t)'
+#pragma omp declare variant(templatefoo_v1<int>) match(construct={dispatch}) \
+  append_args(interop(target))
+void templatebar(const int &t) {}
 #endif // HEADER

clang/test/OpenMP/declare_variant_clauses_messages.cpp

 // RUN: %clang_cc1 -verify -fopenmp -fopenmp-version=51 -DOMP51 -std=c++11 -o - %s
-
+// RUN: %clang_cc1 -verify -fopenmp -fopenmp-version=51 -DOMP51 -std=c++11 \
+// RUN:  -DNO_INTEROP_T_DEF -o - %s
 // RUN: %clang_cc1 -verify -fopenmp -fopenmp-version=50 -DOMP50 -std=c++11 -o - %s
+// RUN: %clang_cc1 -verify -fopenmp -fopenmp-version=51 -DOMP51 -DC -x c -o - %s
+
+#ifdef NO_INTEROP_T_DEF
+void foo_v1(float *, void *);
+// expected-error@+1 {{'omp_interop_t' must be defined when 'append_args' clause is used; include <omp.h>}}
+#pragma omp declare variant(foo_v1) append_args(interop(target)) \
+  match(construct={dispatch})
+void foo_v1(float *);
+#else
+typedef void *omp_interop_t;
 
 int Other;
 
+#ifdef OMP51
+#ifdef __cplusplus
+class A {
+public:
+  void memberfoo_v0(float *A, float *B, int *I);
+  void memberfoo_v1(float *A, float *B, int *I, omp_interop_t IOp);
+
+  // expected-error@+1 {{variant in '#pragma omp declare variant' with type 'void (A::*)(float *, float *, int *)' is incompatible with type 'void (A::*)(float *, float *, int *, omp_interop_t)' with appended arguments}}
+  #pragma omp declare variant(memberfoo_v0) match(construct={dispatch}) \
+                        append_args(interop(target))
+
+  // expected-error@+1 {{variant in '#pragma omp declare variant' with type 'void (A::*)(float *, float *, int *, omp_interop_t)' is incompatible with type 'void (A::*)(float *, float *, int *, omp_interop_t, omp_interop_t)' with appended arguments}}
+  #pragma omp declare variant(memberfoo_v1) match(construct={dispatch}) \
+                        append_args(interop(target),interop(target))
+  void memberbar(float *A, float *B, int *I) { return; }
+
+  static void smemberfoo_v0(float *A, float *B, int *I);
+  static void smemberfoo_v1(float *A, float *B, int *I, omp_interop_t IOp);
+
+  // expected-error@+1 {{variant in '#pragma omp declare variant' with type 'void (float *, float *, int *)' is incompatible with type 'void (float *, float *, int *)' with appended arguments}}
+  #pragma omp declare variant(smemberfoo_v0) match(construct={dispatch}) \
+                        append_args(interop(target))
+
+  // expected-error@+1 {{variant in '#pragma omp declare variant' with type 'void (float *, float *, int *, omp_interop_t)' (aka 'void (float *, float *, int *, void *)') is incompatible with type 'void (float *, float *, int *)' with appended arguments}}
+  #pragma omp declare variant(smemberfoo_v1) match(construct={dispatch}) \
+                        append_args(interop(target),interop(target))
+  static void smemberbar(float *A, float *B, int *I) { return; }
+
+  virtual void vmemberfoo_v0(float *A, float *B, int *I);
+  virtual void vmemberfoo_v1(float *A, float *B, int *I, omp_interop_t IOp);
+
+  // expected-error@+1 {{variant in '#pragma omp declare variant' with type 'void (A::*)(float *, float *, int *)' is incompatible with type 'void (A::*)(float *, float *, int *, omp_interop_t)' with appended arguments}}
+  #pragma omp declare variant(vmemberfoo_v0) match(construct={dispatch}) \
+    append_args(interop(target))
+
+  #pragma omp declare variant(vmemberfoo_v1) match(construct={dispatch}) \
+    append_args(interop(target))
+
+  // expected-error@+1 {{'#pragma omp declare variant' does not support virtual functions}}
+  virtual void vmemberbar(float *A, float *B, int *I) { return; }
+
+  virtual void pvmemberfoo_v0(float *A, float *B, int *I) = 0;
+  virtual void pvmemberfoo_v1(float *A, float *B, int *I, omp_interop_t IOp) = 0;
+
+  // expected-error@+1 {{variant in '#pragma omp declare variant' with type 'void (A::*)(float *, float *, int *)' is incompatible with type 'void (A::*)(float *, float *, int *, omp_interop_t)' with appended arguments}}
+  #pragma omp declare variant(pvmemberfoo_v0) match(construct={dispatch}) \
+    append_args(interop(target))
+
+  #pragma omp declare variant(pvmemberfoo_v1) match(construct={dispatch}) \
+    append_args(interop(target))
+
+  // expected-error@+1 {{'#pragma omp declare variant' does not support virtual functions}}
+  virtual void pvmemberbar(float *A, float *B, int *I) = 0;
+};
+
+template <typename T> void templatefoo_v0(const T& t);
+template <typename T> void templatefoo_v1(const T& t, omp_interop_t I);
+template <typename T> void templatebar(const T& t) {}
+
+// expected-error@+1 {{variant in '#pragma omp declare variant' with type '<overloaded function type>' is incompatible with type 'void (const int &)' with appended arguments}}
+#pragma omp declare variant(templatefoo_v0<int>) match(construct={dispatch}) \
+                        append_args(interop(target))
+
+// expected-error@+1 {{variant in '#pragma omp declare variant' with type '<overloaded function type>' is incompatible with type 'void (const int &)' with appended arguments}}
+#pragma omp declare variant(templatefoo_v1<int>) match(construct={dispatch}) \
+                        append_args(interop(target),interop(target))
+void templatebar(const int &t) {}
+#endif // __cplusplus
+#endif // OMP51
+
 void foo_v1(float *AAA, float *BBB, int *I) { return; }
 void foo_v2(float *AAA, float *BBB, int *I) { return; }
 void foo_v3(float *AAA, float *BBB, int *I) { return; }
+void foo_v4(float *AAA, float *BBB, int *I, omp_interop_t IOp) { return; }
 
 #ifdef OMP51
+void vararg_foo(const char *fmt, omp_interop_t it, ...);
+// expected-error@+3 {{'append_args' is not allowed with varargs functions}}
+#pragma omp declare variant(vararg_foo) match(construct={dispatch}) \
+                                        append_args(interop(target))
+void vararg_bar(const char *fmt, ...) { return; }
+
+// expected-error@+1 {{variant in '#pragma omp declare variant' with type 'void (const char *, omp_interop_t, ...)' (aka 'void (const char *, void *, ...)') is incompatible with type 'void (const char *)' with appended arguments}}
+#pragma omp declare variant(vararg_foo) match(construct={dispatch}) \
+                                        append_args(interop(target))
+void vararg_bar2(const char *fmt) { return; }
+
 // expected-error@+3 {{'adjust_arg' argument 'AAA' used in multiple clauses}}
 #pragma omp declare variant(foo_v1)                          \
    match(construct={dispatch}, device={arch(arm)})           \
    adjust_args(need_device_ptr:AAA,BBB) adjust_args(need_device_ptr:AAA)
 
 // expected-error@+3 {{'adjust_arg' argument 'AAA' used in multiple clauses}}
 #pragma omp declare variant(foo_v1)                          \
    match(construct={dispatch}, device={arch(ppc)}),          \

 
 // expected-error@+2 {{'adjust_args' clause requires 'dispatch' context selector}}
 #pragma omp declare variant(foo_v3)                          \
    adjust_args(nothing:BBB) match(construct={target}, device={arch(arm)})
 
 // expected-error@+2 {{'adjust_args' clause requires 'dispatch' context selector}}
 #pragma omp declare variant(foo_v3)                          \
    adjust_args(nothing:BBB) match(device={arch(ppc)})
+
+// expected-error@+1 {{expected 'match', 'adjust_args', or 'append_args' clause on 'omp declare variant' directive}}
+#pragma omp declare variant(foo_v1)
+
+// expected-error@+1 {{expected 'match', 'adjust_args', or 'append_args' clause on 'omp declare variant' directive}}
+#pragma omp declare variant(foo_v1) other
+
+// expected-error@+2 {{unexpected operation specified in 'append_args' clause, expected 'interop'}}
+#pragma omp declare variant(foo_v1) match(construct={dispatch}) \
+                                    append_args(foobar(target))
+
+// expected-error@+2 {{directive '#pragma omp declare variant' cannot contain more than one 'append_args' clause}}
+#pragma omp declare variant(foo_v1) match(construct={dispatch}) \
+                                    append_args(interop(target)) \
+                                    append_args(interop(targetsync))
+
+// expected-error@+2 {{'append_args' clause requires 'dispatch' context selector}}
+#pragma omp declare variant(foo_v4)                          \
+                    append_args(interop(target)) match(construct={target})
+
+// expected-error@+2 {{'append_args' clause requires 'dispatch' context selector}}
+#pragma omp declare variant(foo_v4)                          \
+                    match(construct={target}) append_args(interop(target))
+
+// expected-warning@+2 {{interop type 'target' cannot be specified more than once}}
+#pragma omp declare variant(foo_v4) match(construct={dispatch}) \
+                                    append_args(interop(target,target))
+
+// expected-warning@+2 {{interop type 'targetsync' cannot be specified more than once}}
+#pragma omp declare variant(foo_v4) match(construct={dispatch}) \
+                                    append_args(interop(targetsync,targetsync))
+
+// expected-error@+2 {{expected interop type: 'target' and/or 'targetsync'}}
+#pragma omp declare variant(foo_v4) match(construct={dispatch}) \
+                                    append_args(interop())
+
+// expected-error@+2 {{expected interop type: 'target' and/or 'targetsync'}}
+#pragma omp declare variant(foo_v4) match(construct={dispatch}) \
+                                    append_args(interop(somethingelse))
+
+// expected-error@+1 {{variant in '#pragma omp declare variant' with type 'void (float *, float *, int *)' is incompatible with type 'void (float *, float *, int *)' with appended arguments}}
+#pragma omp declare variant(foo_v1) match(construct={dispatch}) \
+                                    append_args(interop(target))
+
+// expected-error@+1 {{variant in '#pragma omp declare variant' with type 'void (float *, float *, int *)' is incompatible with type 'void (float *, float *, int *)' with appended arguments}}
+#pragma omp declare variant(foo_v1) match(construct={dispatch}) \
+                                    append_args(interop(target),interop(targetsync))
+
+// expected-error@+1 {{variant in '#pragma omp declare variant' with type 'void (float *, float *, int *, omp_interop_t)' (aka 'void (float *, float *, int *, void *)') is incompatible with type 'void (float *, float *, int *)' with appended arguments}}
+#pragma omp declare variant(foo_v4) match(construct={dispatch}) \
+                                    append_args(interop(target),interop(targetsync))
+
+// expected-error@+1 {{variant in '#pragma omp declare variant' with type 'void (float *, float *, int *, omp_interop_t)' (aka 'void (float *, float *, int *, void *)') is incompatible with type 'void (float *, float *, int *)'}}
+#pragma omp declare variant(foo_v4) match(construct={dispatch})
+
 #endif // OMP51
 #ifdef OMP50
 // expected-error@+2 {{expected 'match' clause on 'omp declare variant' directive}}
 #pragma omp declare variant(foo_v1)                            \
    adjust_args(need_device_ptr:AAA) match(device={arch(arm)})
+// expected-error@+2 {{expected 'match' clause on 'omp declare variant' directive}}
+#pragma omp declare variant(foo_v1)                            \
+   append_args(interop(target)) match(device={arch(arm)})
 #endif // OMP50
 
 void foo(float *AAA, float *BBB, int *I) { return; }
 
+#endif // NO_INTEROP_T_DEF
+
+#ifdef C
+void c_variant(omp_interop_t);
+// expected-error@+3 {{function with '#pragma omp declare variant' must have a prototype when 'append_args' is used}}
+#pragma omp declare variant(foo_v1)                            \
+   append_args(interop(target)) match(construct={dispatch})
+void c_base() {}
+#endif

clang/test/OpenMP/declare_variant_messages.cpp

#pragma omp declare variant(SpecialFuncs::vd) match(implementation = {}) // expected-warning {{expected identifier or string literal describing a context selector; selector skipped}} expected-note {{context selector options are: 'vendor' 'extension' 'unified_address' 'unified_shared_memory' 'reverse_offload' 'dynamic_allocators' 'atomic_default_mem_order'}} expected-note {{the ignored selector spans until here}}
   SpecialFuncs(); // expected-error {{'#pragma omp declare variant' does not support constructors}}
 
 #pragma omp declare variant(SpecialFuncs::vd) match(xxx = {}) // expected-warning {{'xxx' is not a valid context set in a `declare variant`; set ignored}} expected-note {{context set options are: 'construct' 'device' 'implementation' 'user'}} expected-note {{the ignored set spans until here}}
   ~SpecialFuncs(); // expected-error {{'#pragma omp declare variant' does not support destructors}}
 
   void baz();
   void bar();
   void bar(int);
+  virtual void car();
+  virtual void dar() = 0;
+
+#pragma omp declare variant(SpecialFuncs::car) match(construct={dispatch}) // expected-error {{'#pragma omp declare variant' does not support virtual functions}}
+#pragma omp declare variant(SpecialFuncs::dar) match(construct={dispatch}) // expected-error {{'#pragma omp declare variant' does not support virtual functions}}
+
 #pragma omp declare variant(SpecialFuncs::baz) match(implementation = {}) // expected-warning {{expected identifier or string literal describing a context selector; selector skipped}} expected-note {{context selector options are: 'vendor' 'extension' 'unified_address' 'unified_shared_memory' 'reverse_offload' 'dynamic_allocators' 'atomic_default_mem_order'}} expected-note {{the ignored selector spans until here}}
 #pragma omp declare variant(SpecialFuncs::bar) match(xxx = {}) // expected-warning {{'xxx' is not a valid context set in a `declare variant`; set ignored}} expected-note {{context set options are: 'construct' 'device' 'implementation' 'user'}} expected-note {{the ignored set spans until here}}
 
 #pragma omp declare variant(fn_sc_variant1) match(implementation = {}) // expected-error {{variant in '#pragma omp declare variant' with type 'int (*)()' is incompatible with type 'void (SpecialFuncs::*)()'}} expected-warning {{expected identifier or string literal describing a context selector; selector skipped}} expected-note {{context selector options are: 'vendor' 'extension' 'unified_address' 'unified_shared_memory' 'reverse_offload' 'dynamic_allocators' 'atomic_default_mem_order'}} expected-note {{the ignored selector spans until here}}
   void foo1();
   SpecialFuncs& foo(const SpecialFuncs&);
   SpecialFuncs& bar(SpecialFuncs&&);
 

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

 CHECK_SIMPLE_CLAUSE(Write, OMPC_write)
 CHECK_SIMPLE_CLAUSE(Init, OMPC_init)
 CHECK_SIMPLE_CLAUSE(Use, OMPC_use)
 CHECK_SIMPLE_CLAUSE(Novariants, OMPC_novariants)
 CHECK_SIMPLE_CLAUSE(Nocontext, OMPC_nocontext)
 CHECK_SIMPLE_CLAUSE(Filter, OMPC_filter)
 CHECK_SIMPLE_CLAUSE(When, OMPC_when)
 CHECK_SIMPLE_CLAUSE(AdjustArgs, OMPC_adjust_args)
+CHECK_SIMPLE_CLAUSE(AppendArgs, OMPC_append_args)
 
 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_Uniform : Clause<"uniform"> {
   let flangClass = "Name";
   let isValueList = true;
 }
 def OMPC_DeviceType : Clause<"device_type"> {}
 def OMPC_Match : Clause<"match"> {}
 def OMPC_AdjustArgs : Clause<"adjust_args"> { }
+def OMPC_AppendArgs : Clause<"append_args"> { }
 def OMPC_Depobj : Clause<"depobj"> {
   let clangClass = "OMPDepobjClause";
   let isImplicit = true;
 }
 def OMPC_Flush : Clause<"flush"> {
   let clangClass = "OMPFlushClause";
   let isImplicit = true;
 }
let allowedOnceClauses = [
     VersionedClause<OMPC_Allocator>
   ];
 }
 def OMP_DeclareVariant : Directive<"declare variant"> {
   let allowedClauses = [
     VersionedClause<OMPC_Match>
   ];
   let allowedExclusiveClauses = [
-    VersionedClause<OMPC_AdjustArgs, 51>
+    VersionedClause<OMPC_AdjustArgs, 51>,
+    VersionedClause<OMPC_AppendArgs, 51>
   ];
 }
 def OMP_MasterTaskloop : Directive<"master taskloop"> {
   let allowedClauses = [
     VersionedClause<OMPC_If>,
     VersionedClause<OMPC_Shared>,
     VersionedClause<OMPC_Private>,
     VersionedClause<OMPC_FirstPrivate>,