[OpenMP] Introduce the disable_selector_propagation variant selecto…

…r trait

Nested `omp [begin|end] declare variant` inherit the selectors from
surrounding `omp (begin|end) declare variant` constructs. To stop such
propagation the user can add the `disable_selector_propagation` to the
`extension` set in the `implementation` selector.

Reviewed By: tianshilei1992

Differential Revision: https://reviews.llvm.org/D95765

clang/include/clang/Basic/AttrDocs.td

@@ -4007,8 +4007,9 @@ Clang provides the following context selector extensions, used via
     match_all
     match_any
     match_none
-    disable_implicit_base
     allow_templates
+    disable_implicit_base
+    disable_selector_propagation
 
 The match extensions change when the *entire* context selector is considered a
 match for an OpenMP context. The default is ``all``, with ``none`` no trait in the
@@ -4025,7 +4026,8 @@ The allow extensions change when the ``begin declare variant`` effect is
 applied to a definition. If ``allow_templates`` is given, template function
 definitions are considered as specializations of existing or assumed template
 declarations with the same name. The template parameters for the base functions
-are used to instantiate the specialization.
+are used to instantiate the specialization. If ``disable_selector_propagation``
+is given, the context selector is not propagated to nested ones.
 
   }];
 }

clang/lib/Parse/ParseOpenMP.cpp

@@ -948,6 +948,10 @@ static bool checkExtensionProperty(Parser &P, SourceLocation Loc,
       TraitProperty::implementation_extension_disable_implicit_base)
     return true;
 
+  if (TIProperty.Kind ==
+      TraitProperty::implementation_extension_disable_selector_propagation)
+    return true;
+
   if (TIProperty.Kind ==
       TraitProperty::implementation_extension_allow_templates)
     return true;
@@ -1460,7 +1464,11 @@ bool Parser::parseOMPDeclareVariantMatchClause(SourceLocation Loc,
     return false;
 
   // Merge the parent/outer trait info into the one we just parsed and diagnose
-  // problems.
+  // problems. Can be disabled by the disable_selector_propagation extension.
+  if (ParentTI->isExtensionActive(
+          llvm::omp::TraitProperty::
+              implementation_extension_disable_selector_propagation))
+    return false;
   // TODO: Keep some source location in the TI to provide better diagnostics.
   // TODO: Perform some kind of equivalence check on the condition and score
   //       expressions.

clang/test/OpenMP/begin_declare_variant_nested_propagation.c

@@ -1,5 +1,4 @@
 // RUN: %clang_cc1 -triple=x86_64-pc-win32 -verify -fopenmp -x c -std=c99 -fms-extensions -Wno-pragma-pack %s
-// expected-no-diagnostics
 
 #pragma omp begin declare variant match(user={condition(1)}, device={kind(cpu)}, implementation={extension(match_any)})
 #pragma omp begin declare variant match(device = {kind(cpu, fpga)})
@@ -12,3 +11,18 @@
  this is never reached
 #pragma omp end declare variant
 #pragma omp end declare variant
+
+#pragma omp begin declare variant match(implementation={extension(disable_implicit_base, disable_selector_propagation)})
+
+ void without_implicit_base() {}
+
+#pragma omp begin declare variant match(implementation = {vendor(llvm)})
+ void with_implicit_base() {}
+#pragma omp end declare variant
+
+#pragma omp end declare variant
+
+ void test() {
+   without_implicit_base(); // expected-warning{{implicit declaration of function 'without_implicit_base' is invalid in C99}}
+   with_implicit_base();
+ }

clang/test/OpenMP/declare_variant_messages.c

@@ -170,6 +170,14 @@ void caller() {
 int conflicting_nested_score(void);
 #pragma omp end declare variant
 
+#pragma omp begin declare variant match(implementation = {vendor(score(1) \
+                                                                 : llvm),extension(disable_selector_propagation)})
+#pragma omp declare variant(foo) match(implementation = {vendor(score(2) \
+                                                                : llvm)})
+int conflicting_nested_score_no_prop(void);
+#pragma omp end declare variant
+
+
 // FIXME: We should build the conjuction of different conditions, see also the score fixme above.
 #pragma omp begin declare variant match(user = {condition(1)})
 #pragma omp declare variant(foo) match(user = {condition(1)}) // expected-error {{nested user conditions in OpenMP context selector not supported (yet)}}

llvm/include/llvm/Frontend/OpenMP/OMPKinds.def

@@ -1057,6 +1057,7 @@ __OMP_TRAIT_PROPERTY(implementation, extension, match_any)
 __OMP_TRAIT_PROPERTY(implementation, extension, match_none)
 __OMP_TRAIT_PROPERTY(implementation, extension, disable_implicit_base)
 __OMP_TRAIT_PROPERTY(implementation, extension, allow_templates)
+__OMP_TRAIT_PROPERTY(implementation, extension, disable_selector_propagation)
 
 __OMP_TRAIT_SET(user)