Separate FMV and Extensions

Author: tmatheson-arm

clang/include/clang/AST/ASTContext.h

@@ -3194,9 +3194,6 @@ class ASTContext : public RefCountedBase<ASTContext> {
   /// valid feature names.
   ParsedTargetAttr filterFunctionTargetAttrs(const TargetAttr *TD) const;
 
-  std::vector<std::string>
-  filterFunctionTargetVersionAttrs(const TargetVersionAttr *TV) const;
-
   void getFunctionFeatureMap(llvm::StringMap<bool> &FeatureMap,
                              const FunctionDecl *) const;
   void getFunctionFeatureMap(llvm::StringMap<bool> &FeatureMap,

clang/include/clang/Basic/TargetInfo.h

@@ -1400,11 +1400,6 @@ class TargetInfo : public TransferrableTargetInfo,
     return true;
   }
 
-  /// For given feature return dependent ones.
-  virtual StringRef getFeatureDependencies(StringRef Feature) const {
-    return StringRef();
-  }
-
   struct BranchProtectionInfo {
     LangOptions::SignReturnAddressScopeKind SignReturnAddr;
     LangOptions::SignReturnAddressKeyKind SignKey;

clang/lib/AST/ASTContext.cpp

@@ -87,6 +87,7 @@
 #include "llvm/Support/MD5.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/raw_ostream.h"
+#include "llvm/TargetParser/AArch64TargetParser.h"
 #include "llvm/TargetParser/Triple.h"
 #include <algorithm>
 #include <cassert>
@@ -13664,16 +13665,23 @@ QualType ASTContext::getCorrespondingSignedFixedPointType(QualType Ty) const {
   }
 }
 
+// Given a list of FMV features, add each of their backend features to the list.
+static void
+GetFMVBackendFeaturesFor(const llvm::SmallVector<StringRef, 8> FMVFeatStrings,
+                         std::vector<std::string>& BackendFeats) {
+  for (auto &F : FMVFeatStrings)
+    if (auto FMVExt = llvm::AArch64::parseFMVExtension(F))
+      for (auto F : FMVExt->getImpliedFeatures())
+        BackendFeats.push_back(F.str());
+}
+
 std::vector<std::string> ASTContext::filterFunctionTargetVersionAttrs(
     const TargetVersionAttr *TV) const {
   assert(TV != nullptr);
   llvm::SmallVector<StringRef, 8> Feats;
   std::vector<std::string> ResFeats;
   TV->getFeatures(Feats);
-  for (auto &Feature : Feats)
-    if (Target->validateCpuSupports(Feature.str()))
-      // Use '?' to mark features that came from TargetVersion.
-      ResFeats.push_back("?" + Feature.str());
+  GetFMVBackendFeaturesFor(Feats, ResFeats);
   return ResFeats;
 }
 
@@ -13735,13 +13743,11 @@ void ASTContext::getFunctionFeatureMap(llvm::StringMap<bool> &FeatureMap,
   } else if (const auto *TC = FD->getAttr<TargetClonesAttr>()) {
     std::vector<std::string> Features;
     if (Target->getTriple().isAArch64()) {
-      // TargetClones for AArch64
       llvm::SmallVector<StringRef, 8> Feats;
       TC->getFeatures(Feats, GD.getMultiVersionIndex());
-      for (StringRef Feat : Feats)
-        if (Target->validateCpuSupports(Feat.str()))
-          // Use '?' to mark features that came from AArch64 TargetClones.
-          Features.push_back("?" + Feat.str());
+      GetFMVBackendFeaturesFor(Feats, Features);
+
+      // Combine with the features from the Target, not expanded
       Features.insert(Features.begin(),
                       Target->getTargetOpts().FeaturesAsWritten.begin(),
                       Target->getTargetOpts().FeaturesAsWritten.end());
@@ -13754,11 +13760,14 @@ void ASTContext::getFunctionFeatureMap(llvm::StringMap<bool> &FeatureMap,
     }
     Target->initFeatureMap(FeatureMap, getDiagnostics(), TargetCPU, Features);
   } else if (const auto *TV = FD->getAttr<TargetVersionAttr>()) {
-    std::vector<std::string> Feats = filterFunctionTargetVersionAttrs(TV);
+    llvm::SmallVector<StringRef, 8> Feats;
+    TV->getFeatures(Feats);
+    std::vector<std::string> Features;
+    GetFMVBackendFeaturesFor(Feats, Features);
     Feats.insert(Feats.begin(),
                  Target->getTargetOpts().FeaturesAsWritten.begin(),
                  Target->getTargetOpts().FeaturesAsWritten.end());
-    Target->initFeatureMap(FeatureMap, getDiagnostics(), TargetCPU, Feats);
+    Target->initFeatureMap(FeatureMap, getDiagnostics(), TargetCPU, Features);
   } else {
     FeatureMap = Target->getTargetOpts().FeatureMap;
   }

clang/lib/Basic/Targets/AArch64.cpp

@@ -659,34 +659,30 @@ AArch64TargetInfo::getVScaleRange(const LangOptions &LangOpts) const {
 unsigned AArch64TargetInfo::multiVersionSortPriority(StringRef Name) const {
   if (Name == "default")
     return 0;
-  if (auto Ext = llvm::AArch64::parseArchExtension(Name))
-    return Ext->FmvPriority;
+  if (auto Ext = llvm::AArch64::parseFMVExtension(Name))
+    return Ext->Priority;
   return 0;
 }
 
 unsigned AArch64TargetInfo::multiVersionFeatureCost() const {
   // Take the maximum priority as per feature cost, so more features win.
-  return llvm::AArch64::ExtensionInfo::MaxFMVPriority;
+  constexpr unsigned MaxFMVPriority = 1000;
+  return MaxFMVPriority;
 }
 
 bool AArch64TargetInfo::doesFeatureAffectCodeGen(StringRef Name) const {
-  if (auto Ext = llvm::AArch64::parseArchExtension(Name))
-    return !Ext->DependentFeatures.empty();
+  // FMV extensions which imply no backend features do not affect codegen.
+  if (auto Ext = llvm::AArch64::parseFMVExtension(Name))
+    return !Ext->Features.empty();
   return false;
 }
 
-StringRef AArch64TargetInfo::getFeatureDependencies(StringRef Name) const {
-  if (auto Ext = llvm::AArch64::parseArchExtension(Name))
-    return Ext->DependentFeatures;
-  return StringRef();
-}
-
 bool AArch64TargetInfo::validateCpuSupports(StringRef FeatureStr) const {
   // CPU features might be separated by '+', extract them and check
   llvm::SmallVector<StringRef, 8> Features;
   FeatureStr.split(Features, "+");
   for (auto &Feature : Features)
-    if (!llvm::AArch64::parseArchExtension(Feature.trim()).has_value())
+    if (!llvm::AArch64::parseFMVExtension(Feature.trim()).has_value())
       return false;
   return true;
 }
@@ -1066,31 +1062,62 @@ bool AArch64TargetInfo::initFeatureMap(
     }
   }
 
-  // Process target and dependent features. This is done in two loops collecting
-  // them into UpdatedFeaturesVec: first to add dependent '+'features, second to
-  // add target '+/-'features that can later disable some of features added on
-  // the first loop. Function Multi Versioning features begin with '?'.
-  for (const auto &Feature : FeaturesVec)
-    if (((Feature[0] == '?' || Feature[0] == '+')) &&
-        AArch64TargetInfo::doesFeatureAffectCodeGen(Feature.substr(1))) {
-      StringRef DepFeatures =
-          AArch64TargetInfo::getFeatureDependencies(Feature.substr(1));
-      SmallVector<StringRef, 1> AttrFeatures;
-      DepFeatures.split(AttrFeatures, ",");
-      for (auto F : AttrFeatures)
-        UpdatedFeaturesVec.push_back(F.str());
+  // Special cases which rely on dependency expansion at this stage
+  for(auto F : FeaturesVec) {
+    // Crypto is the only one we don't want passed through
+    if(F == "+crypto") {
+      UpdatedFeaturesVec.emplace_back("+aes");
+      UpdatedFeaturesVec.emplace_back("+sha2");
+    } else {
+      UpdatedFeaturesVec.emplace_back(F);
     }
-  for (const auto &Feature : FeaturesVec)
-    if (Feature[0] != '?') {
-      std::string UpdatedFeature = Feature;
-      if (Feature[0] == '+') {
-        std::optional<llvm::AArch64::ExtensionInfo> Extension =
-          llvm::AArch64::parseArchExtension(Feature.substr(1));
-        if (Extension)
-          UpdatedFeature = Extension->Feature.str();
-      }
-      UpdatedFeaturesVec.push_back(UpdatedFeature);
+
+    if(F == "+sve") {
+      UpdatedFeaturesVec.emplace_back("+sve");
+      UpdatedFeaturesVec.emplace_back("+fullfp16");
+      UpdatedFeaturesVec.emplace_back("+neon");
+      UpdatedFeaturesVec.emplace_back("+fp-armv8");
+    }
+    else if(F == "+sve2") {
+      UpdatedFeaturesVec.emplace_back("+sve");
+      UpdatedFeaturesVec.emplace_back("+fullfp16");
+    }
+    else if(F == "+sve2p1") {
+      UpdatedFeaturesVec.emplace_back("+sve2");
+      UpdatedFeaturesVec.emplace_back("+sve");
+    }
+    else if(F == "+sve2-aes") {
+      UpdatedFeaturesVec.emplace_back("+sve2");
+      UpdatedFeaturesVec.emplace_back("+sve");
     }
+    else if(F == "+sve2-bitperm") {
+      UpdatedFeaturesVec.emplace_back("+sve2");
+      UpdatedFeaturesVec.emplace_back("+sve");
+    }
+    else if(F == "+sve2-sha3") {
+      UpdatedFeaturesVec.emplace_back("+sve2");
+      UpdatedFeaturesVec.emplace_back("+sve");
+    }
+    else if(F == "+sve2-sm4") {
+      UpdatedFeaturesVec.emplace_back("+sve2");
+      UpdatedFeaturesVec.emplace_back("+sve");
+    }
+    else if(F == "+sme") {
+      UpdatedFeaturesVec.emplace_back("+bf16");
+    }
+    else if(F == "+sme2") {
+      UpdatedFeaturesVec.emplace_back("+sme");
+      UpdatedFeaturesVec.emplace_back("+bf16");
+    }
+    else if(F == "+sme-i16i64") {
+      UpdatedFeaturesVec.emplace_back("+sme");
+      UpdatedFeaturesVec.emplace_back("+bf16");
+    }
+    else if(F == "+sme2p1") {
+      UpdatedFeaturesVec.emplace_back("+sme2");
+      UpdatedFeaturesVec.emplace_back("+sme");
+    }
+  }
 
   return TargetInfo::initFeatureMap(Features, Diags, CPU, UpdatedFeaturesVec);
 }

clang/lib/Basic/Targets/AArch64.h

@@ -155,7 +155,6 @@ class LLVM_LIBRARY_VISIBILITY AArch64TargetInfo : public TargetInfo {
   std::optional<std::pair<unsigned, unsigned>>
   getVScaleRange(const LangOptions &LangOpts) const override;
   bool doesFeatureAffectCodeGen(StringRef Name) const override;
-  StringRef getFeatureDependencies(StringRef Name) const override;
   bool validateCpuSupports(StringRef FeatureStr) const override;
   bool hasFeature(StringRef Feature) const override;
   void setFeatureEnabled(llvm::StringMap<bool> &Features, StringRef Name,

clang/lib/CodeGen/CGBuiltin.cpp

@@ -14176,7 +14176,7 @@ Value *CodeGenFunction::EmitAArch64CpuSupports(const CallExpr *E) {
   ArgStr.split(Features, "+");
   for (auto &Feature : Features) {
     Feature = Feature.trim();
-    if (!llvm::AArch64::parseArchExtension(Feature))
+    if (!llvm::AArch64::parseFMVExtension(Feature))
       return Builder.getFalse();
     if (Feature != "default")
       Features.push_back(Feature);

clang/lib/CodeGen/Targets/AArch64.cpp

@@ -962,7 +962,7 @@ void AArch64ABIInfo::appendAttributeMangling(StringRef AttrStr,
 
   llvm::SmallDenseSet<StringRef, 8> UniqueFeats;
   for (auto &Feat : Features)
-    if (auto Ext = llvm::AArch64::parseArchExtension(Feat))
+    if (auto Ext = llvm::AArch64::parseFMVExtension(Feat))
       if (UniqueFeats.insert(Ext->Name).second)
         Out << 'M' << Ext->Name;
 }