[OpenMP] Diagnose bad 'omp declare variant' that references itself

[mikerice]

Summary

When an a variant is specified that is the same as the base function the compiler will end up crashing in CodeGen. Give an error instead.

[ABataev]

LG

[jdoerfert]

Why is this supposed to be a user error? I don't remember the standard disallowing this and I can see use cases for this.

[mikerice]

What's the use case? I wasn't aware of any. We saw it from someone who did it accidently and caused the compiler to crash in codegen.

[jdoerfert]

In D119979#3330343, @mikerice wrote:

What's the use case? I wasn't aware of any. We saw it from someone who did it accidently and caused the compiler to crash in codegen.

If you have N overloads/variants and you want to pick the original in a certain condition. It might be easier to specify the condition as match clause with a high score rather than avoid other match clauses to apply then. Put differently, if you disallow this you cannot have a "catch all" variant with a low score, e.g., one that issues a compile or runtime failure if picked.
Even if we don't use this now, we still need to stick somewhat to the standard or open an issue there if we think the behavior should be forbidden.

clang/include/clang/Basic/DiagnosticSemaKinds.td

 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%select{| with appended arguments}2">;
+def err_omp_declare_variant_same_base_function : Error<
+  "variant in '#pragma omp declare variant' is the same as the base function">;
 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"

clang/lib/Sema/SemaOpenMP.cpp

Sema::checkOpenMPDeclareVariantFunction(Sema::DeclGroupPtrTy DG,
   }
   auto *NewFD = dyn_cast_or_null<FunctionDecl>(DRE->getDecl());
   if (!NewFD) {
     Diag(VariantRef->getExprLoc(), diag::err_omp_function_expected)
         << VariantId << VariantRef->getSourceRange();
     return None;
   }
 
+  if (FD->getCanonicalDecl() == NewFD->getCanonicalDecl()) {
+    Diag(VariantRef->getExprLoc(),
+         diag::err_omp_declare_variant_same_base_function)
+        << VariantRef->getSourceRange();
+    return None;
+  }
+
   // Check if function types are compatible in C.
   if (!LangOpts.CPlusPlus) {
     QualType NewType =
         Context.mergeFunctionTypes(AdjustedFnType, NewFD->getType());
     if (NewType.isNull()) {
       Diag(VariantRef->getExprLoc(),
            diag::err_omp_declare_variant_incompat_types)
           << NewFD->getType() << FD->getType() << (NumAppendArgs ? 1 : 0)

clang/test/OpenMP/declare_variant_messages.c

 int diff_proto1(double);
 
 int after_use_variant(void);
 int after_use(void);
 int bar(void) {
   return after_use();
 }
 
+// expected-error@+1 {{variant in '#pragma omp declare variant' is the same as the base function}}
+#pragma omp declare variant (self) \
+  match(construct={dispatch}, device={arch(arm)})
+void self(int n);
+
+void self_test(int n, int d_no) {
+  #pragma omp dispatch device(d_no) nowait
+  self(n);
+}
 
 #pragma omp declare variant(after_use_variant) match(xxx={}) // expected-warning {{'xxx' is not a valid context set in a `declare variant`; set ignored}} expected-warning {{'#pragma omp declare variant' cannot be applied for function after first usage; the original function might be used}} expected-note {{context set options are: 'construct' 'device' 'implementation' 'user'}} expected-note {{the ignored set spans until here}}
 int after_use(void);
 #pragma omp declare variant(after_use_variant) 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}}
 int defined(void) { return 0; }
 int defined1(void) { return 0; }
 
 #pragma omp declare variant(after_use_variant) match(xxx={}) // expected-warning {{'xxx' is not a valid context set in a `declare variant`; set ignored}} expected-warning {{'#pragma omp declare variant' cannot be applied to the function that was defined already; the original function might be used}} expected-note {{context set options are: 'construct' 'device' 'implementation' 'user'}} expected-note {{the ignored set spans until here}}