[OpenMP] Introduce the `disable_selector_propagation` variant selector trait

[jdoerfert]

Summary

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.

[JonChesterfield]

Yes, OK. I'm a little nervous that variant is evolving into a turing complete sublanguage, but I see the use of opting out of the implicit inheritance.

[tianshilei1992]

LGTM

clang/include/clang/Basic/AttrDocs.td

 Clang provides the following context selector extensions, used via
 ``implementation={extension(EXTENSION)}``:
 
   .. code-block:: none
 
     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
 selector is allowed to be in the OpenMP context, with ``any`` a single trait in
 both the selector and OpenMP context is sufficient. Only a single match
 extension trait is allowed per context selector. Note that match extensions are
 not propagated to nested selectors like the standard defines it for other traits.
 The disable extensions remove default effects of the ``begin declare variant``
 applied to a definition. If ``disable_implicit_base`` is given, we will not
 introduce an implicit base function for a variant if no base function was
 found. The variant is still generated but will never be called, due to the
 absence of a base function and consequently calls to a base function.
 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.
 
   }];
 }
 
 def LeafDocs : Documentation {
   let Category = DocCatVariable;
   let Content = [{
 

clang/lib/Parse/ParseOpenMP.cpp

static bool checkExtensionProperty(Parser &P, SourceLocation Loc,
   if (TIProperty.Kind == TraitProperty::invalid)
     return false;
 
   if (TIProperty.Kind ==
       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;
 
   auto IsMatchExtension = [](OMPTraitProperty &TP) {
     return (TP.Kind ==
                 llvm::omp::TraitProperty::implementation_extension_match_all ||
             TP.Kind ==
                 llvm::omp::TraitProperty::implementation_extension_match_any ||
bool Parser::parseOMPDeclareVariantMatchClause(SourceLocation Loc,
 
   // Parse ')'
   (void)T.consumeClose();
 
   if (!ParentTI)
     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.
   auto StripImplementation = [](const OMPTraitSet &TSet) -> OMPTraitSet {
     if (TSet.Kind != llvm::omp::TraitSet::implementation)
       return TSet;
     OMPTraitSet Set = TSet;
     for (OMPTraitSelector &Selector : Set.Selectors) {

clang/test/OpenMP/begin_declare_variant_nested_propagation.c

 // 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)})
  this is never reached
 #pragma omp end declare variant
 #pragma omp end declare variant
 
 #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)}, implementation={vendor(llvm)})
  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

 // FIXME: If the scores are equivalent we should detect that and allow it.
 #pragma omp begin declare variant match(implementation = {vendor(score(2) \
                                                                  : llvm)})
 #pragma omp declare variant(foo) match(implementation = {vendor(score(2) \
                                                                 : llvm)}) // expected-error@-1 {{nested OpenMP context selector contains duplicated trait 'llvm' in selector 'vendor' and set 'implementation' with different score}}
 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)}}
 int conflicting_nested_condition(void);
 #pragma omp end declare variant

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

 __OMP_TRAIT_PROPERTY(implementation, vendor, unknown)
 
 __OMP_TRAIT_SELECTOR(implementation, extension, true)
 __OMP_TRAIT_PROPERTY(implementation, extension, match_all)
 __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)
 
 __OMP_TRAIT_SELECTOR(user, condition, true)
 
 __OMP_TRAIT_PROPERTY(user, condition, true)
 __OMP_TRAIT_PROPERTY(user, condition, false)
 __OMP_TRAIT_PROPERTY(user, condition, unknown)