Allow target to handle required features for TARGET_BUILTINs.

[tra]

Summary

In some cases figuring out whether particular target builtin
should be enabled is a bit more complicated than current
implementation allow. This patch allows the target to override
what it considers for required feature to be enabled/disabled.

This will be used in the upcoming patch which needs to have some
NVPTX builtins enabled for a range of GPUs depending on detected
CUDA version.

[jlebar]

clang/include/clang/Basic/TargetInfo.h

933

It's not totally obvious to me, can we explain why it's a tristate?

[tra]

Updated description of hasRequiredFeature.
Set FirstMissing if target returns 'false' so diags still work.

[tra]

clang/include/clang/Basic/TargetInfo.h

933

We need to distinguish between "target does not need to do anything special about the feature" (no value) and "target does have an opinion, which may be true or false.". I'll update the comment.

[tra]

I've figured out a manageable way to enforce constraints without this change.

clang/include/clang/Basic/TargetInfo.h

virtual bool handleTargetFeatures(std::vector<std::string> &Features,
     return true;
   }
 
   /// \brief Determine whether the given target has the given feature.
   virtual bool hasFeature(StringRef Feature) const {
     return false;
   }
 
-  /// \brief Identify whether this taret supports multiversioning of functions,
-  /// which requires support for cpu_supports and cpu_is functionality.
+  /// \brief Determine if ReqFeature is enabled given the features populated in
+  /// FeatureMap. Targets may override this to provide custom handling of
+  /// required features. Function returns None when the feature does not need
+  /// special handling by the target, or true/false to indicate whether the
+  /// feature is enabled.
+  virtual Optional<bool>
+  hasRequiredFeature(const llvm::StringMap<bool> FeatureMap,
+                     const StringRef ReqFeature) const {
+    return None;
+  }
+
+  /// \brief Identify whether this taret supports multiversioning of
+  /// functions, which requires support for cpu_supports and cpu_is
+  /// functionality.
   virtual bool supportsMultiVersioning() const { return false; }
 
   // \brief Validate the contents of the __builtin_cpu_supports(const char*)
   // argument.
   virtual bool validateCpuSupports(StringRef Name) const { return false; }
 
   // \brief Return the target-specific priority for features/cpus/vendors so
   // that they can be properly sorted for checking.

clang/lib/CodeGen/CodeGenFunction.cpp

static bool hasRequiredFeatures(const SmallVectorImpl<StringRef> &ReqFeatures,
   // If we have at least one of the features in the feature list return
   // true, otherwise return false.
   return std::all_of(
       ReqFeatures.begin(), ReqFeatures.end(), [&](StringRef Feature) {
         SmallVector<StringRef, 1> OrFeatures;
         Feature.split(OrFeatures, "|");
         return std::any_of(OrFeatures.begin(), OrFeatures.end(),
                            [&](StringRef Feature) {
+                             // Check if the target wants to handle the feature.
+                             if (Optional<bool> HasFeature =
+                                     CGM.getTarget().hasRequiredFeature(
+                                         CallerFeatureMap, Feature)) {
+                               if (*HasFeature == false)
+                                 FirstMissing = Feature.str();
+                               return *HasFeature;
+                             }
+                             // Otherwise just look for the feature
+                             // presence/absence in the CallerFeatureMap.
                              if (!CallerFeatureMap.lookup(Feature)) {
                                FirstMissing = Feature.str();
                                return false;
                              }
                              return true;
                            });
       });
 }