Register and parse a simplified version of '#pragma omp declare variant'

[andwar]

Summary

This patch implements the basic parsing and semantic analysis of
`#pragma omp declare variant`:
  * registers '#pragma omp declare variant' alongside other OpenMP
  pragmas
  * parses the 'variant(variant-func-id)' clause and verifies that
  'variant-func-id' corresponds to a previously declared function
  * template-is as 'variant-func-id' is not supported
  * '#pragma omp declare variant` is not allowed in front of template
  declarations.

Note that this patch will only parse a subset of the required clauses,
e.g. 'variant(variant-func-id)'. Any remaining tokens before
'tok::annot_pragma_openmp_end' are ignored.  As per OpenMP 5 spec, this
form of '#pragma omp declare variant' is incomplete and invalid and will
be rejected with an error once the implementation is complete. In the
meantime, this reduced form is treated as valid.

[ABataev]

include/clang/Basic/Attr.td

3202 ↗

(On Diff #219142)

For the first patch we don't need the attribute, just parsing/sema analysis

3220 ↗

(On Diff #219142)

This is definitely wrong, especially if we need to handle templates.

lib/Parse/ParseOpenMP.cpp

778–782

1. All this lookup must be performed in Sema.
2. How do you want to handle templates?
3. Why just do not parse it as an expression? And rely on existing parsing/sema analysis for expressions.

832

/*IsReinject=*/

834

Same here

lib/Sema/SemaOpenMP.cpp

4886

In this patch need to implement just basic checks, no need to create attributes, etc. I would suggest to look at the checks for Target Multiversioning attribite (see D40819)

[andwar]

• Removed declare variant from Attr.td
• Moved the 'vector-var-id' lookup from ParseOpenMP.cpp to SemaOpenMP.cpp
• Parsing 'vector-var-id' as an expression
• Removed the creation of the attribute in ActOnOpenMPDeclareVariantDirective

[andwar]

I've addressed most of the comments except for those related to templates. I'd like to clarify as what is the expected behaviour there before proceeding with implementation.

include/clang/Basic/Attr.td

3220 ↗

(On Diff #219142)

What else would you use? Also, we're not handling template-ids as 'variant-func-id' just yet.

lib/Parse/ParseOpenMP.cpp

778–782

1. That's fine, let me move it there.

2. TL;DR We're not handling templates yet.

3. How about switching to ParseUnqualifiedId instead? That will still require going through LookupParsedName though.

Re 2. What the interaction between templates and #pragma(s) should be? The C++ standard doesn't specify that, but IMHO mixing '#pragma omp declare variant' and templates requires that interaction to be clearly defined.

I know that OpenMP 5 allows 'variant-func-id' to be a template-id, but I couldn't find an example of any attribute that would use C++ template parameters. Also, isn't parsing of attributes and templates _orthogonal_ in clang (i.e. happening at completely different points during parsing)?

In any case, we felt that support for 'template-id' could come later. How do you feel about it?

lib/Sema/SemaOpenMP.cpp

4886

This makes sense, but do you reckon that that should be split into separate functions? I was inspired by the implementation of declare simd. From what I can tell, the only Sema checking for declare simd is happening in ActOnOpenMPDeclareVariantDirective. It feels that doing the same for declare variant would be good for consistency. To limit this method to Sema checks, I will remove the call to CreateImplicit.

[jdoerfert]

I left some minor notes but overall I think we should put this in and improve on it in-tree. @ABataev, would that be OK with you?

lib/Parse/ParseOpenMP.cpp

748

Remove the "vector" parts in the descriptions and variable names below please, it is not "vector" specific.

Nit: I'd remove the note justifying the choice for a member function.

788

I actually doubt the "vec-var-id" has to be an tok::identifier but let's put that discussion on hold for later patches and get it in for the most common case, identifiers.

lib/Sema/SemaOpenMP.cpp

4930

I'm a little unsure about the template instantiation check (have to actually open the standard on that) but I guess being to conservative now and making progress is an acceptable way to go anyway.

[ABataev]

include/clang/Basic/Attr.td

3220 ↗

(On Diff #219142)

But we have to handle templates from the very beginning. This is the thing that would be very hard to support later and we have to think about it in the first patch.
Just parse function identifier as an expression.
Your solution also will break serialization/deserialization since attributes dies not support serilization of the custom fields.

lib/Parse/ParseOpenMP.cpp

778–782

No, don't try to parse function names directly. What about ::fun format? Or std::fun? Your solution does not support it.
I have basic implementation that handles all these cases. Let me commit it, because we need it to support other context selectors. It is very similar to your solution but handles all the problems. We just don't have time to wait, need to support other context selectors.

788

This is definitely wrong.

[andwar]

lib/Parse/ParseOpenMP.cpp

778–782

That's true - my approach doesn't support ::fun or std::fun. The idea is to fill in the gaps as we progress later.

@ABataev, If you have a more generic implementation then it makes a lot of sense to go with that instead. Please, feel free to re-use this patch if that helps.

include/clang/Basic/DiagnosticParseKinds.td

 def err_omp_unexpected_clause : Error<
   "unexpected OpenMP clause '%0' in directive '#pragma omp %1'">;
 def err_omp_immediate_directive : Error<
   "'#pragma omp %0' %select{|with '%2' clause }1cannot be an immediate substatement">;
 def err_omp_expected_identifier_for_critical : Error<
   "expected identifier specifying the name of the 'omp critical' directive">;
 def err_omp_expected_reduction_identifier : Error<
   "expected identifier or one of the following operators: '+', '-', '*', '&', '|', '^', '&&', or '||'">;
-def err_omp_decl_in_declare_simd : Error<
-  "function declaration is expected after 'declare simd' directive">;
+def err_omp_decl_after_declare_directive : Error<
+  "function declaration is expected after 'declare %select{simd|variant}0' directive">;
 def err_omp_unknown_map_type : Error<
   "incorrect map type, expected one of 'to', 'from', 'tofrom', 'alloc', 'release', or 'delete'">;
 def err_omp_unknown_map_type_modifier : Error<
   "incorrect map type modifier, expected 'always', 'close', or 'mapper'">;
 def err_omp_map_type_missing : Error<
   "missing map type">;
 def err_omp_map_type_modifier_missing : Error<
   "missing map type modifier">;
 def err_omp_declare_simd_inbranch_notinbranch : Error<
   "unexpected '%0' clause, '%1' is specified already">;
 def err_expected_end_declare_target : Error<
   "expected '#pragma omp end declare target'">;
 def err_omp_declare_target_unexpected_clause: Error<
   "unexpected '%0' clause, only %select{'to' or 'link'|'to', 'link' or 'device_type'}1 clauses expected">;
 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 warn_omp_more_one_device_type_clause : Warning<
   "more than one 'device_type' clause is specified">,
   InGroup<OpenMPClauses>;
+def err_omp_expected_unqualified_declare_variant_id : Error<
+  "expected unqualified-id representing 'vector-variant-id'">;
 
 // Pragma loop support.
 def err_pragma_loop_missing_argument : Error<
   "missing argument; expected %select{an integer value|"
   "'enable'%select{|, 'full'}1%select{|, 'assume_safety'}2 or 'disable'}0">;
 def err_pragma_loop_invalid_option : Error<
   "%select{invalid|missing}0 option%select{ %1|}0; expected vectorize, "
   "vectorize_width, interleave, interleave_count, unroll, unroll_count, "

include/clang/Basic/DiagnosticSemaKinds.td

 def note_omp_nested_teams_construct_here : Note<
   "nested teams construct here">;
 def note_omp_nested_statement_here : Note<
   "%select{statement|directive}0 outside teams construct here">;
 def err_omp_single_copyprivate_with_nowait : Error<
   "the 'copyprivate' clause must not be used with the 'nowait' clause">;
 def note_omp_nowait_clause_here : Note<
   "'nowait' clause is here">;
-def err_omp_single_decl_in_declare_simd : Error<
-  "single declaration is expected after 'declare simd' directive">;
+def err_omp_single_decl_after_declare_directive : Error<
+  "single declaration is expected after 'declare %select{simd|variant}0' directive">;
 def err_omp_function_expected : Error<
-  "'#pragma omp declare simd' can only be applied to functions">;
+  "'#pragma omp declare %select{simd|variant}0' can only be applied to functions">;
 def err_omp_wrong_cancel_region : Error<
   "one of 'for', 'parallel', 'sections' or 'taskgroup' is expected">;
 def err_omp_parent_cancel_region_nowait : Error<
   "parent region for 'omp %select{cancellation point|cancel}0' construct cannot be nowait">;
 def err_omp_parent_cancel_region_ordered : Error<
   "parent region for 'omp %select{cancellation point|cancel}0' construct cannot be ordered">;
 def err_omp_reduction_wrong_type : Error<"reduction type cannot be %select{qualified with 'const', 'volatile' or 'restrict'|a function|a reference|an array}0 type">;
 def err_omp_wrong_var_in_declare_reduction : Error<"only %select{'omp_priv' or 'omp_orig'|'omp_in' or 'omp_out'}0 variables are allowed in %select{initializer|combiner}0 expression">;

 def err_omp_device_type_mismatch : Error<
   "'device_type(%0)' does not match previously specified 'device_type(%1)' for the same declaration">;
 def err_omp_wrong_device_function_call : Error<
   "function with 'device_type(%0)' is not available on %select{device|host}1">;
 def note_omp_marked_device_type_here : Note<"marked as 'device_type(%0)' here">;
 def warn_omp_declare_target_after_first_use : Warning<
   "declaration marked as declare target after first use, it may lead to incorrect results">,
   InGroup<OpenMPTarget>;
+def err_omp_declare_variant_template_decl : Error<
+  "'#pragma omp declare variant' can only be used to decorate instantiated templates">;
+def err_omp_expected_declared_func_ident : Error<
+  "no declaration for '%0', only declared functions can be used as <vector-variant-id>">;
 } // 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">;

include/clang/Basic/OpenMPKinds.def

 OPENMP_DIRECTIVE_EXT(declare_reduction, "declare reduction")
 OPENMP_DIRECTIVE_EXT(declare_mapper, "declare mapper")
 OPENMP_DIRECTIVE_EXT(declare_simd, "declare simd")
 OPENMP_DIRECTIVE(taskloop)
 OPENMP_DIRECTIVE_EXT(taskloop_simd, "taskloop simd")
 OPENMP_DIRECTIVE(distribute)
 OPENMP_DIRECTIVE_EXT(declare_target, "declare target")
 OPENMP_DIRECTIVE_EXT(end_declare_target, "end declare target")
+OPENMP_DIRECTIVE_EXT(declare_variant, "declare variant")
 OPENMP_DIRECTIVE_EXT(distribute_parallel_for, "distribute parallel for")
 OPENMP_DIRECTIVE_EXT(distribute_parallel_for_simd, "distribute parallel for simd")
 OPENMP_DIRECTIVE_EXT(distribute_simd, "distribute simd")
 OPENMP_DIRECTIVE_EXT(target_parallel_for_simd, "target parallel for simd")
 OPENMP_DIRECTIVE_EXT(target_simd, "target simd")
 OPENMP_DIRECTIVE_EXT(teams_distribute, "teams distribute")
 OPENMP_DIRECTIVE_EXT(teams_distribute_simd, "teams distribute simd")
 OPENMP_DIRECTIVE_EXT(teams_distribute_parallel_for_simd, "teams distribute parallel for simd")

include/clang/Parse/Parser.h

bool ParseUnqualifiedIdOperator(CXXScopeSpec &SS, bool EnteringContext,
                                   UnqualifiedId &Result);
 
   //===--------------------------------------------------------------------===//
   // OpenMP: Directives and clauses.
   /// Parse clauses for '#pragma omp declare simd'.
   DeclGroupPtrTy ParseOMPDeclareSimdClauses(DeclGroupPtrTy Ptr,
                                             CachedTokens &Toks,
                                             SourceLocation Loc);
+  /// Parse clauses for '#pragma omp declare variant'.
+  DeclGroupPtrTy ParseOMPDeclareVariantClauses(DeclGroupPtrTy Ptr,
+                                               CachedTokens &Toks,
+                                               SourceLocation Loc);
+  bool parseDeclareVariantClauses(UnqualifiedId &VectorVariantId);
   /// Parse clauses for '#pragma omp declare target'.
   DeclGroupPtrTy ParseOMPDeclareTargetClauses();
   /// Parse '#pragma omp end declare target'.
   void ParseOMPEndDeclareTargetDirective(OpenMPDirectiveKind DKind,
                                          SourceLocation Loc);
   /// Parses declarative OpenMP directives.
   DeclGroupPtrTy ParseOpenMPDeclarativeDirectiveWithExtDecl(
       AccessSpecifier &AS, ParsedAttributesWithRange &Attrs,

include/clang/Sema/Sema.h

public:
   /// Called on well-formed '\#pragma omp declare simd' after parsing of
   /// the associated method/function.
   DeclGroupPtrTy ActOnOpenMPDeclareSimdDirective(
       DeclGroupPtrTy DG, OMPDeclareSimdDeclAttr::BranchStateTy BS,
       Expr *Simdlen, ArrayRef<Expr *> Uniforms, ArrayRef<Expr *> Aligneds,
       ArrayRef<Expr *> Alignments, ArrayRef<Expr *> Linears,
       ArrayRef<unsigned> LinModifiers, ArrayRef<Expr *> Steps, SourceRange SR);
 
+  /// Called on well-formed '\#pragma omp declare variant' after parsing of
+  /// the associated method/function.
+  DeclGroupPtrTy ActOnOpenMPDeclareVariantDirective(
+      DeclGroupPtrTy DG, UnqualifiedId &VectorVariantId, SourceRange SR);
+
   OMPClause *ActOnOpenMPSingleExprClause(OpenMPClauseKind Kind,
                                          Expr *Expr,
                                          SourceLocation StartLoc,
                                          SourceLocation LParenLoc,
                                          SourceLocation EndLoc);
   /// Called on well-formed 'allocator' clause.
   OMPClause *ActOnOpenMPAllocatorClause(Expr *Allocator,
                                         SourceLocation StartLoc,

lib/Basic/OpenMPKinds.cpp

 #define OPENMP_ALLOCATE_CLAUSE(Name)                                           \
   case OMPC_##Name:                                                            \
     return true;
 #include "clang/Basic/OpenMPKinds.def"
     default:
       break;
     }
     break;
+  case OMPD_declare_variant:
   case OMPD_declare_target:
   case OMPD_end_declare_target:
   case OMPD_unknown:
   case OMPD_threadprivate:
   case OMPD_section:
   case OMPD_master:
   case OMPD_taskyield:
   case OMPD_barrier:
void clang::getOpenMPCaptureRegions(
   case OMPD_barrier:
   case OMPD_taskwait:
   case OMPD_cancellation_point:
   case OMPD_cancel:
   case OMPD_flush:
   case OMPD_declare_reduction:
   case OMPD_declare_mapper:
   case OMPD_declare_simd:
+  case OMPD_declare_variant:
   case OMPD_declare_target:
   case OMPD_end_declare_target:
   case OMPD_requires:
     llvm_unreachable("OpenMP Directive is not allowed");
   case OMPD_unknown:
     llvm_unreachable("Unknown OpenMP directive");
   }
 }

lib/CodeGen/CGOpenMPRuntime.cpp

case OMPD_target_teams_distribute_parallel_for:
           cast<OMPTargetTeamsDistributeParallelForDirective>(E));
       break;
     case OMPD_target_teams_distribute_parallel_for_simd:
       CodeGenFunction::
           EmitOMPTargetTeamsDistributeParallelForSimdDeviceFunction(
               CGM, ParentName,
               cast<OMPTargetTeamsDistributeParallelForSimdDirective>(E));
       break;
+    case OMPD_declare_variant:
     case OMPD_parallel:
     case OMPD_for:
     case OMPD_parallel_for:
     case OMPD_parallel_sections:
     case OMPD_for_simd:
     case OMPD_parallel_for_simd:
     case OMPD_cancel:
     case OMPD_cancellation_point:
auto &&ThenGen = [this, &D, Device, &InputInfo,
     case OMPD_target_exit_data:
       RTLFn = HasNowait ? OMPRTL__tgt_target_data_end_nowait
                         : OMPRTL__tgt_target_data_end;
       break;
     case OMPD_target_update:
       RTLFn = HasNowait ? OMPRTL__tgt_target_data_update_nowait
                         : OMPRTL__tgt_target_data_update;
       break;
+    case OMPD_declare_variant:
     case OMPD_parallel:
     case OMPD_for:
     case OMPD_parallel_for:
     case OMPD_parallel_sections:
     case OMPD_for_simd:
     case OMPD_parallel_for_simd:
     case OMPD_cancel:
     case OMPD_cancellation_point:

lib/Parse/ParseOpenMP.cpp

enum OpenMPDirectiveKindEx {
   OMPD_end_declare,
   OMPD_enter,
   OMPD_exit,
   OMPD_point,
   OMPD_reduction,
   OMPD_target_enter,
   OMPD_target_exit,
   OMPD_update,
+  OMPD_variant,
   OMPD_distribute_parallel,
   OMPD_teams_distribute_parallel,
   OMPD_target_teams_distribute_parallel,
   OMPD_mapper,
 };
 
 class DeclDirectiveListParserHelper final {
   SmallVector<Expr *, 4> Identifiers;
return llvm::StringSwitch<unsigned>(S)
       .Case("declare", OMPD_declare)
       .Case("end", OMPD_end)
       .Case("enter", OMPD_enter)
       .Case("exit", OMPD_exit)
       .Case("point", OMPD_point)
       .Case("reduction", OMPD_reduction)
       .Case("update", OMPD_update)
       .Case("mapper", OMPD_mapper)
+      .Case("variant", OMPD_variant)
       .Default(OMPD_unknown);
 }
 
 static OpenMPDirectiveKind parseOpenMPDirectiveKind(Parser &P) {
   // Array of foldings: F[i][0] F[i][1] ===> F[i][2].
   // E.g.: OMPD_for OMPD_simd ===> OMPD_for_simd
   // TODO: add other combined directives in topological order.
   static const unsigned F[][3] = {
       {OMPD_cancellation, OMPD_point, OMPD_cancellation_point},
       {OMPD_declare, OMPD_reduction, OMPD_declare_reduction},
       {OMPD_declare, OMPD_mapper, OMPD_declare_mapper},
       {OMPD_declare, OMPD_simd, OMPD_declare_simd},
+      {OMPD_declare, OMPD_variant, OMPD_declare_variant},
       {OMPD_declare, OMPD_target, OMPD_declare_target},
       {OMPD_distribute, OMPD_parallel, OMPD_distribute_parallel},
       {OMPD_distribute_parallel, OMPD_for, OMPD_distribute_parallel_for},
       {OMPD_distribute_parallel_for, OMPD_simd,
        OMPD_distribute_parallel_for_simd},
       {OMPD_distribute, OMPD_simd, OMPD_distribute_simd},
       {OMPD_end, OMPD_declare, OMPD_end_declare},
       {OMPD_end_declare, OMPD_target, OMPD_end_declare_target},
if (OMPDeclareSimdDeclAttr::ConvertStrToBranchStateTy(ClauseName, Out)) {
         break;
     }
     // Skip ',' if any.
     if (Tok.is(tok::comma))
       P.ConsumeToken();
   }
   return IsError;
 }
 
+/// Parses clauses for 'declare variant' directive.
+///   (vec-var-id) match(context-selector-specification)
+///    context-selector-specification:
+///    TODO Add support for matching context selector
+///
+/// Returns 'true' if there were syntax errors, 'false' otherwise.
+/// Note that similar method for '#pragma omp simd' is _not_ a member of the
+/// Parser -  it's a static function local to this file instead. However, this
+/// method accesses the internals of the Parser, so it makes more sense to
+/// make it a member.
+bool Parser::parseDeclareVariantClauses(UnqualifiedId &VectorVariantId) {
+  const Token &Tok = getCurToken();
+
+  // Parse (variant-func-id)
+  BalancedDelimiterTracker VecVarLeftParen(*this, tok::l_paren);
+  if (!Tok.is(tok::l_paren)) {
+    Diag(Tok, diag::err_expected_lparen_after) << "#pragma omp declare variant";
+    return true;
+  }
+  VecVarLeftParen.consumeOpen();
+
+  if (Tok.isNot(tok::identifier)) {
+    Diag(Tok, diag::err_omp_expected_unqualified_declare_variant_id);
+    SkipUntil(tok::r_paren, StopAtSemi);
+    return true;
+  }
+
+  CXXScopeSpec SS;
+  ParseUnqualifiedId(SS, /*EnteringContext*/ false,
+                     /*AllowDestructorName*/ false,
+                     /*AllowConstructorName*/ false,
+                     /*AllowDeductionGuide*/ false, nullptr, nullptr,
+                     VectorVariantId);
+
+  if (VecVarLeftParen.consumeClose())
+    return true;
+
+  return false;
+}
+
 /// Parse clauses for '#pragma omp declare simd'.
 Parser::DeclGroupPtrTy
 Parser::ParseOMPDeclareSimdClauses(Parser::DeclGroupPtrTy Ptr,
                                    CachedTokens &Toks, SourceLocation Loc) {
   PP.EnterToken(Tok, /*IsReinject*/ true);
   PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true,
                       /*IsReinject*/ true);
   // Consume the previously pushed token.
Parser::ParseOMPDeclareSimdClauses(Parser::DeclGroupPtrTy Ptr,
   SourceLocation EndLoc = ConsumeAnnotationToken();
   if (IsError)
     return Ptr;
   return Actions.ActOnOpenMPDeclareSimdDirective(
       Ptr, BS, Simdlen.get(), Uniforms, Aligneds, Alignments, Linears,
       LinModifiers, Steps, SourceRange(Loc, EndLoc));
 }
 
+/// Parse clauses for '#pragma omp declare variant'
+Parser::DeclGroupPtrTy
+Parser::ParseOMPDeclareVariantClauses(Parser::DeclGroupPtrTy Ptr,
+                                      CachedTokens &Toks, SourceLocation Loc) {
+  PP.EnterToken(Tok, /*IsReinject=*/true);
+  PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true,
+                      /*IsReinject=*/true);
+  // Consume the previously pushed token.
+  ConsumeAnyToken(/*ConsumeCodeCompletionTok=*/true);
+
+  FNContextRAII FnContext(*this, Ptr);
+  UnqualifiedId VectorVariantId;
+  bool IsError = parseDeclareVariantClauses(VectorVariantId);
+  // Need to check for extra tokens.
+  if (Tok.isNot(tok::annot_pragma_openmp_end)) {
+    Diag(Tok, diag::warn_omp_extra_tokens_at_eol)
+        << getOpenMPDirectiveName(OMPD_declare_variant);
+    while (Tok.isNot(tok::annot_pragma_openmp_end))
+      ConsumeAnyToken();
+  }
+  // Skip the last annot_pragma_openmp_end.
+  SourceLocation EndLoc = ConsumeAnnotationToken();
+  if (IsError)
+    return Ptr;
+  return Actions.ActOnOpenMPDeclareVariantDirective(Ptr, VectorVariantId,
+                                                    SourceRange(Loc, EndLoc));
+}
+
 /// Parsing of simple OpenMP clauses like 'default' or 'proc_bind'.
 ///
 ///    default-clause:
 ///         'default' '(' 'none' | 'shared' ')
 ///
 ///    proc_bind-clause:
 ///         'proc_bind' '(' 'master' | 'close' | 'spread' ')
 ///
case OMPD_declare_mapper: {
     ConsumeToken();
     if (DeclGroupPtrTy Res = ParseOpenMPDeclareMapperDirective(AS)) {
       // Skip the last annot_pragma_openmp_end.
       ConsumeAnnotationToken();
       return Res;
     }
     break;
   }
-  case OMPD_declare_simd: {
+  case OMPD_declare_simd:
+    LLVM_FALLTHROUGH;
+  case OMPD_declare_variant: {
+    // The syntax is:
+    // { #pragma omp declare simd }
+    // <function-declaration-or-definition>
+    // and:
+    // { #pragma omp declare variant }
+    // <function-declaration-or-definition>
+    //
     // The syntax is:
     // { #pragma omp declare simd }
     // <function-declaration-or-definition>
     //
     ConsumeToken();
     CachedTokens Toks;
     while(Tok.isNot(tok::annot_pragma_openmp_end)) {
       Toks.push_back(Tok);
if (Tok.is(tok::annot_pragma_openmp)) {
         ParsingDeclSpec PDS(*this);
         Ptr = ParseExternalDeclaration(Attrs, &PDS);
       } else {
         Ptr =
             ParseCXXClassMemberDeclarationWithPragmas(AS, Attrs, TagType, Tag);
       }
     }
     if (!Ptr) {
-      Diag(Loc, diag::err_omp_decl_in_declare_simd);
+      unsigned directive = (OMPD_declare_simd == DKind) ? 0 : 1;
+      Diag(Loc, diag::err_omp_decl_after_declare_directive) << directive;
       return DeclGroupPtrTy();
     }
-    return ParseOMPDeclareSimdClauses(Ptr, Toks, Loc);
+    return (OMPD_declare_simd == DKind)
+               ? ParseOMPDeclareSimdClauses(Ptr, Toks, Loc)
+               : ParseOMPDeclareVariantClauses(Ptr, Toks, Loc);
   }
   case OMPD_declare_target: {
     SourceLocation DTLoc = ConsumeAnyToken();
     if (Tok.isNot(tok::annot_pragma_openmp_end)) {
       return ParseOMPDeclareTargetClauses();
     }
 
     // Skip the last annot_pragma_openmp_end.
Directive = Actions.ActOnOpenMPExecutableDirective(
         EndLoc);
 
     // Exit scope.
     Actions.EndOpenMPDSABlock(Directive.get());
     OMPDirectiveScope.Exit();
     break;
   }
   case OMPD_declare_simd:
+  case OMPD_declare_variant:
   case OMPD_declare_target:
   case OMPD_end_declare_target:
   case OMPD_requires:
     Diag(Tok, diag::err_omp_unexpected_directive)
         << 1 << getOpenMPDirectiveName(DKind);
     SkipUntil(tok::annot_pragma_openmp_end);
     break;
   case OMPD_unknown:

lib/Sema/SemaOpenMP.cpp

void Sema::ActOnOpenMPRegionStart(OpenMPDirectiveKind DKind, Scope *CurScope) {
   case OMPD_barrier:
   case OMPD_taskwait:
   case OMPD_cancellation_point:
   case OMPD_cancel:
   case OMPD_flush:
   case OMPD_declare_reduction:
   case OMPD_declare_mapper:
   case OMPD_declare_simd:
+  case OMPD_declare_variant:
   case OMPD_declare_target:
   case OMPD_end_declare_target:
   case OMPD_requires:
     llvm_unreachable("OpenMP Directive is not allowed");
   case OMPD_unknown:
     llvm_unreachable("Unknown OpenMP directive");
   }
 }
case OMPD_target_teams_distribute_simd:
     break;
   case OMPD_declare_target:
   case OMPD_end_declare_target:
   case OMPD_threadprivate:
   case OMPD_allocate:
   case OMPD_declare_reduction:
   case OMPD_declare_mapper:
   case OMPD_declare_simd:
+  case OMPD_declare_variant:
   case OMPD_requires:
     llvm_unreachable("OpenMP Directive is not allowed");
   case OMPD_unknown:
     llvm_unreachable("Unknown OpenMP directive");
   }
 
   ErrorFound = Res.isInvalid() || ErrorFound;
 
Sema::DeclGroupPtrTy Sema::ActOnOpenMPDeclareSimdDirective(
     ArrayRef<unsigned> LinModifiers, ArrayRef<Expr *> Steps, SourceRange SR) {
   assert(Aligneds.size() == Alignments.size());
   assert(Linears.size() == LinModifiers.size());
   assert(Linears.size() == Steps.size());
   if (!DG || DG.get().isNull())
     return DeclGroupPtrTy();
 
   if (!DG.get().isSingleDecl()) {
-    Diag(SR.getBegin(), diag::err_omp_single_decl_in_declare_simd);
+    Diag(SR.getBegin(), diag::err_omp_single_decl_after_declare_directive)
+        << /*declare simd*/ 0;
     return DG;
   }
   Decl *ADecl = DG.get().getSingleDecl();
   if (auto *FTD = dyn_cast<FunctionTemplateDecl>(ADecl))
     ADecl = FTD->getTemplatedDecl();
 
   auto *FD = dyn_cast<FunctionDecl>(ADecl);
   if (!FD) {
-    Diag(ADecl->getLocation(), diag::err_omp_function_expected);
+    Diag(ADecl->getLocation(), diag::err_omp_function_expected)
+        << /*declare simd*/ 0;
     return DeclGroupPtrTy();
   }
 
   // OpenMP [2.8.2, declare simd construct, Description]
   // The parameter of the simdlen clause must be a constant positive integer
   // expression.
   ExprResult SL;
   if (Simdlen)
auto *NewAttr = OMPDeclareSimdDeclAttr::CreateImplicit(
       const_cast<Expr **>(NewAligns.data()), NewAligns.size(),
       const_cast<Expr **>(Linears.data()), Linears.size(),
       const_cast<unsigned *>(LinModifiers.data()), LinModifiers.size(),
       NewSteps.data(), NewSteps.size(), SR);
   ADecl->addAttr(NewAttr);
   return ConvertDeclToDeclGroup(ADecl);
 }
 
+Sema::DeclGroupPtrTy Sema::ActOnOpenMPDeclareVariantDirective(
+    DeclGroupPtrTy DG, UnqualifiedId &VectorVariantId, SourceRange SR) {
+  assert(!DG.get().isNull() && "Missing function declaration after pragma");
+
+  // '#pragma omp declare variant' is only allowed for template instantiations.
+  // It's meaning for template declarations would be ambigous.
+  Decl *D = *DG.get().begin();
+  if (D->isTemplateDecl()) {
+    Diag(SR.getBegin(), diag::err_omp_declare_variant_template_decl);
+    return DG;
+  }
+
+  if (!DG.get().isSingleDecl()) {
+    Diag(SR.getBegin(), diag::err_omp_single_decl_after_declare_directive)
+        << /*declare variant*/ 1;
+    return DG;
+  }
+
+  Decl *ADecl = DG.get().getSingleDecl();
+  if (auto *FTD = dyn_cast<FunctionTemplateDecl>(ADecl))
+    ADecl = FTD->getTemplatedDecl();
+
+  auto *FD = dyn_cast<FunctionDecl>(ADecl);
+  if (!FD) {
+    Diag(ADecl->getLocation(), diag::err_omp_function_expected)
+        << /*declare variant*/ 1;
+    return DeclGroupPtrTy();
+  }
+
+  // Look up for the declaration of the variant.
+  StringRef FuncName = VectorVariantId.Identifier->getName();
+  DeclarationName VecVarDN(VectorVariantId.Identifier);
+  NamedDecl *VecVarND = LookupSingleName(getCurScope(), VecVarDN, SR.getBegin(),
+                                         Sema::LookupOrdinaryName);
+
+  // If the declaration of the variant is found, add the
+  // attribute. Otherwise, raise an error.
+  if (nullptr == VecVarND)
+    Diag(VectorVariantId.getBeginLoc(),
+         diag::err_omp_expected_declared_func_ident)
+        << VectorVariantId.Identifier->getName();
+
+  return ConvertDeclToDeclGroup(ADecl);
+}
+
 StmtResult Sema::ActOnOpenMPParallelDirective(ArrayRef<OMPClause *> Clauses,
                                               Stmt *AStmt,
                                               SourceLocation StartLoc,
                                               SourceLocation EndLoc) {
   if (!AStmt)
     return StmtError();
 
   auto *CS = cast<CapturedStmt>(AStmt);
case OMPC_if:
     case OMPD_taskyield:
     case OMPD_barrier:
     case OMPD_taskwait:
     case OMPD_cancellation_point:
     case OMPD_flush:
     case OMPD_declare_reduction:
     case OMPD_declare_mapper:
     case OMPD_declare_simd:
+    case OMPD_declare_variant:
     case OMPD_declare_target:
     case OMPD_end_declare_target:
     case OMPD_teams:
     case OMPD_simd:
     case OMPD_for:
     case OMPD_for_simd:
     case OMPD_sections:
     case OMPD_section:
case OMPC_num_threads:
     case OMPD_taskyield:
     case OMPD_barrier:
     case OMPD_taskwait:
     case OMPD_cancellation_point:
     case OMPD_flush:
     case OMPD_declare_reduction:
     case OMPD_declare_mapper:
     case OMPD_declare_simd:
+    case OMPD_declare_variant:
     case OMPD_declare_target:
     case OMPD_end_declare_target:
     case OMPD_teams:
     case OMPD_simd:
     case OMPD_for:
     case OMPD_for_simd:
     case OMPD_sections:
     case OMPD_section:
case OMPC_num_teams:
     case OMPD_taskyield:
     case OMPD_barrier:
     case OMPD_taskwait:
     case OMPD_cancellation_point:
     case OMPD_flush:
     case OMPD_declare_reduction:
     case OMPD_declare_mapper:
     case OMPD_declare_simd:
+    case OMPD_declare_variant:
     case OMPD_declare_target:
     case OMPD_end_declare_target:
     case OMPD_simd:
     case OMPD_for:
     case OMPD_for_simd:
     case OMPD_sections:
     case OMPD_section:
     case OMPD_single:
case OMPC_thread_limit:
     case OMPD_taskyield:
     case OMPD_barrier:
     case OMPD_taskwait:
     case OMPD_cancellation_point:
     case OMPD_flush:
     case OMPD_declare_reduction:
     case OMPD_declare_mapper:
     case OMPD_declare_simd:
+    case OMPD_declare_variant:
     case OMPD_declare_target:
     case OMPD_end_declare_target:
     case OMPD_simd:
     case OMPD_for:
     case OMPD_for_simd:
     case OMPD_sections:
     case OMPD_section:
     case OMPD_single:
case OMPC_schedule:
     case OMPD_taskyield:
     case OMPD_barrier:
     case OMPD_taskwait:
     case OMPD_cancellation_point:
     case OMPD_flush:
     case OMPD_declare_reduction:
     case OMPD_declare_mapper:
     case OMPD_declare_simd:
+    case OMPD_declare_variant:
     case OMPD_declare_target:
     case OMPD_end_declare_target:
     case OMPD_simd:
     case OMPD_sections:
     case OMPD_section:
     case OMPD_single:
     case OMPD_master:
     case OMPD_critical:
case OMPC_dist_schedule:
     case OMPD_taskyield:
     case OMPD_barrier:
     case OMPD_taskwait:
     case OMPD_cancellation_point:
     case OMPD_flush:
     case OMPD_declare_reduction:
     case OMPD_declare_mapper:
     case OMPD_declare_simd:
+    case OMPD_declare_variant:
     case OMPD_declare_target:
     case OMPD_end_declare_target:
     case OMPD_simd:
     case OMPD_for:
     case OMPD_for_simd:
     case OMPD_sections:
     case OMPD_section:
     case OMPD_single:
case OMPC_device:
     case OMPD_taskyield:
     case OMPD_barrier:
     case OMPD_taskwait:
     case OMPD_cancellation_point:
     case OMPD_flush:
     case OMPD_declare_reduction:
     case OMPD_declare_mapper:
     case OMPD_declare_simd:
+    case OMPD_declare_variant:
     case OMPD_declare_target:
     case OMPD_end_declare_target:
     case OMPD_simd:
     case OMPD_for:
     case OMPD_for_simd:
     case OMPD_sections:
     case OMPD_section:
     case OMPD_single:

test/OpenMP/declare_variant_messages.cpp

+// RUN: %clang_cc1 -triple=x86_64-pc-win32 -verify -fopenmp -x c++ -std=c++11 -fms-extensions -Wno-pragma-pack %s
+
+// RUN: %clang_cc1 -triple=x86_64-pc-win32 -verify -fopenmp-simd -x c++ -std=c++11 -fms-extensions -Wno-pragma-pack %s
+
+// The dummy vector variant
+void vector_foo();
+
+//=============================================================================
+// Basic errors
+//=============================================================================
+// This is (and should be) perfectly fine for the parser, although semantically
+// not valid OpenMP 5.
+#pragma omp declare variant(vector_foo)
+void foo();
+
+// expected-error@+1 {{expected an OpenMP directive}}
+#pragma omp declare
+
+// expected-error@+2 {{'#pragma omp declare variant' can only be applied to functions}}
+#pragma omp declare variant(vector_foo)
+int a;
+// expected-error@+2 {{'#pragma omp declare variant' can only be applied to functions}}
+#pragma omp declare variant (vector_foo)
+#pragma omp threadprivate(a)
+int var;
+#pragma omp threadprivate(var)
+
+// expected-error@+3 {{expected an OpenMP directive}}
+// expected-error@+1 {{function declaration is expected after 'declare variant' directive}}
+#pragma omp declare variant
+#pragma omp declare
+
+// expected-error@+1 {{single declaration is expected after 'declare variant' directive}}
+#pragma omp declare variant(vector_foo)
+int b, c;
+
+//=============================================================================
+// Syntax/semantic error: everything excluding linear/aligned/uniform
+//=============================================================================
+// expected-error@+1 {{expected an OpenMP directive}}
+#pragma omp variant
+// expected-error@+1 {{expected '(' after '#pragma omp declare variant'}}
+#pragma omp declare variant
+// expected-warning@+2 {{extra tokens at the end of '#pragma omp declare variant' are ignored}}
+// expected-error@+1 {{expected '(' after '#pragma omp declare variant'}}
+#pragma omp declare variant )
+// expected-error@+1 {{expected unqualified-id representing 'vector-variant-id'}}
+#pragma omp declare variant()
+// expected-error@+1 {{no declaration for 'undeclared_func', only declared functions can be used as <vector-variant-id>}}
+#pragma omp declare variant(undeclared_func)
+// expected-error@+2 {{expected ')'}}
+// expected-note@+1 {{to match this '('}}
+#pragma omp declare variant(vector_foo
+void foo();
+
+//=============================================================================
+// Templates
+//=============================================================================
+// expected-error@+1 {{'#pragma omp declare variant' can only be used to decorate instantiated templates}}
+#pragma omp declare variant(vector_foo)
+template <class C>
+void h(C *hp, C *hp2, C *hq, C *lin) {
+  b = 0;
+}
+
+#pragma omp declare variant(vector_foo)
+template <>
+void h(int *hp, int *hp2, int *hq, int *lin) {
+  h((float *)hp, (float *)hp2, (float *)hq, (float *)lin);
+}
+
+//=============================================================================
+// 'declare variant' embedded in namespaces
+//=============================================================================
+namespace N {
+  // expected-error@+1 {{function declaration is expected after 'declare variant' directive}}
+  #pragma omp declare variant
+}
+// expected-error@+1 {{function declaration is expected after 'declare variant' directive}}
+#pragma omp declare variant
+// Now verify that the parser recovered fine from the previous error and identifies another one correctly
+// expected-error@+1 {{function declaration is expected after 'declare variant' directive}}
+#pragma omp declare variant