AMDGPU: Remove amdgpu-waves-per-eu support in old attribute pass

[arsenm]

Summary

AMDGPUAttributor now handles this attribute with value merging, so
delete the old approach which could only apply this to functions which
did not set it, or cloned the function.

[arsenm]

ping

[kzhuravl]

LGTM, thanks

[arsenm]

Rebase

[arsenm]

7c8958118c6f695b01c98db6984390d2ee4fdb1a

llvm/lib/Target/AMDGPU/AMDGPUPropagateAttributes.cpp

 
 // Target features to propagate.
 static constexpr const FeatureBitset TargetFeatures = {
   AMDGPU::FeatureWavefrontSize16,
   AMDGPU::FeatureWavefrontSize32,
   AMDGPU::FeatureWavefrontSize64
 };
 
-// Attributes to propagate.
-// TODO: Support conservative min/max merging instead of cloning.
-static constexpr const char *AttributeNames[] = {"amdgpu-waves-per-eu"};
-
-static constexpr unsigned NumAttr = std::size(AttributeNames);
-
 class AMDGPUPropagateAttributes {
 
   class FnProperties {
   private:
     explicit FnProperties(const FeatureBitset &&FB) : Features(FB) {}
 
   public:
     explicit FnProperties(const TargetMachine &TM, const Function &F) {
       Features = TM.getSubtargetImpl(F)->getFeatureBits();
-
-      for (unsigned I = 0; I < NumAttr; ++I)
-        if (F.hasFnAttribute(AttributeNames[I]))
-          Attributes[I] = F.getFnAttribute(AttributeNames[I]);
     }
 
     bool operator == (const FnProperties &Other) const {
       if ((Features & TargetFeatures) != (Other.Features & TargetFeatures))
         return false;
-      for (unsigned I = 0; I < NumAttr; ++I)
-        if (Attributes[I] != Other.Attributes[I])
-          return false;
       return true;
     }
 
     FnProperties adjustToCaller(const FnProperties &CallerProps) const {
       FnProperties New((Features & ~TargetFeatures) | CallerProps.Features);
-      for (unsigned I = 0; I < NumAttr; ++I)
-        New.Attributes[I] = CallerProps.Attributes[I];
       return New;
     }
 
     FeatureBitset Features;
-    std::optional<Attribute> Attributes[NumAttr];
   };
 
   class Clone {
   public:
     Clone(const FnProperties &Props, Function *OrigF, Function *NewF) :
       Properties(Props), OrigF(OrigF), NewF(NewF) {}
 
     FnProperties Properties;
class AMDGPUPropagateAttributes {
 
   // Clone function \p F and set \p NewProps on the clone.
   // Cole takes the name of original function.
   Function *cloneWithProperties(Function &F, const FnProperties &NewProps);
 
   // Set new function's features in place.
   void setFeatures(Function &F, const FeatureBitset &NewFeatures);
 
-  // Set new function's attributes in place.
-  void setAttributes(Function &F,
-                     const ArrayRef<std::optional<Attribute>> NewAttrs);
-
   std::string getFeatureString(const FeatureBitset &Features) const;
 
   // Propagate attributes from Roots.
   bool process();
 
 public:
   AMDGPUPropagateAttributes(const TargetMachine *TM, bool AllowClone) :
     TM(TM), AllowClone(AllowClone) {}
for (auto &F : M.functions()) {
         if (!NewF) {
           const FnProperties NewProps = CalleeProps.adjustToCaller(CallerProps);
           if (!AllowClone) {
             // This may set different features on different iterations if
             // there is a contradiction in callers' attributes. In this case
             // we rely on a second pass running on Module, which is allowed
             // to clone.
             setFeatures(F, NewProps.Features);
-            setAttributes(F, NewProps.Attributes);
             NewRoots.insert(&F);
             Changed = true;
             break;
           }
 
           NewF = cloneWithProperties(F, NewProps);
           Clones.push_back(Clone(CallerProps, &F, NewF));
           NewRoots.insert(NewF);

 Function *
 AMDGPUPropagateAttributes::cloneWithProperties(Function &F,
                                                const FnProperties &NewProps) {
   LLVM_DEBUG(dbgs() << "Cloning " << F.getName() << '\n');
 
   ValueToValueMapTy dummy;
   Function *NewF = CloneFunction(&F, dummy);
   setFeatures(*NewF, NewProps.Features);
-  setAttributes(*NewF, NewProps.Attributes);
   NewF->setVisibility(GlobalValue::DefaultVisibility);
   NewF->setLinkage(GlobalValue::InternalLinkage);
 
   // Swap names. If that is the only clone it will retain the name of now
   // dead value. Preserve original name for externally visible functions.
   if (F.hasName() && F.hasLocalLinkage()) {
     std::string NewName = std::string(NewF->getName());
     NewF->takeName(&F);
void AMDGPUPropagateAttributes::setFeatures(Function &F,
   LLVM_DEBUG(dbgs() << "Set features "
                     << getFeatureString(NewFeatures & TargetFeatures)
                     << " on " << F.getName() << '\n');
 
   F.removeFnAttr("target-features");
   F.addFnAttr("target-features", NewFeatureStr);
 }
 
-void AMDGPUPropagateAttributes::setAttributes(
-    Function &F, const ArrayRef<std::optional<Attribute>> NewAttrs) {
-  LLVM_DEBUG(dbgs() << "Set attributes on " << F.getName() << ":\n");
-  for (unsigned I = 0; I < NumAttr; ++I) {
-    F.removeFnAttr(AttributeNames[I]);
-    if (NewAttrs[I]) {
-      LLVM_DEBUG(dbgs() << '\t' << NewAttrs[I]->getAsString() << '\n');
-      F.addFnAttr(*NewAttrs[I]);
-    }
-  }
-}
-
 std::string
 AMDGPUPropagateAttributes::getFeatureString(const FeatureBitset &Features) const
 {
   std::string Ret;
   for (const SubtargetFeatureKV &KV : AMDGPUFeatureKV) {
     if (Features[KV.Value])
       Ret += (StringRef("+") + KV.Key + ",").str();
     else if (TargetFeatures[KV.Value])

llvm/test/CodeGen/AMDGPU/propagate-attributes-clone.ll

 ; OPT-INT:  tail call fastcc void @foo1()
 ; OPT-INT:  tail call fastcc void @1()
 ; OPT:      ret void
 ; OPT: define internal fastcc void @1() unnamed_addr #4
 ; OPT-EXT: define internal fastcc void @foo3.2() unnamed_addr #4
 ; OPT-INT: define internal fastcc void @foo3() unnamed_addr #4
 ; OPT-EXT: define internal fastcc void @foo2.3() unnamed_addr #4
 ; OPT-INT: define internal fastcc void @foo2() unnamed_addr #4
-; OPT: attributes #0 = { {{.*}} "amdgpu-waves-per-eu"="1,1" "target-features"="+wavefrontsize64" }
+; OPT: attributes #0 = { {{.*}} "target-features"="+wavefrontsize64" }
 ; OPT: attributes #1 = { {{.*}} "target-features"="{{.*}},-wavefrontsize16,-wavefrontsize32,+wavefrontsize64{{.*}}" }
-; OPT: attributes #2 = { {{.*}} "amdgpu-waves-per-eu"="2,4" "target-features"="+wavefrontsize32" }
+; OPT: attributes #2 = { {{.*}} "target-features"="+wavefrontsize32" }
 ; OPT: attributes #3 = { {{.*}} "target-features"="+wavefrontsize64" }
-; OPT: attributes #4 = { {{.*}} "amdgpu-waves-per-eu"="2,4" "target-features"="{{.*}},-wavefrontsize16,+wavefrontsize32,-wavefrontsize64{{.*}}" }
+; OPT: attributes #4 = { {{.*}} "target-features"="{{.*}},-wavefrontsize16,+wavefrontsize32,-wavefrontsize64{{.*}}" }
 
 ; LLC: foo3:
 ; LLC: sample asm
 ; LLC: foo2:
 ; LLC: sample asm
 ; LLC: foo1:
 ; LLC: foo4@gotpcrel32@lo+4
 ; LLC: foo4@gotpcrel32@hi+12

 }
 
 define amdgpu_kernel void @kernel3() #3 {
 entry:
   tail call void @foo1()
   ret void
 }
 
-attributes #0 = { nounwind "target-features"="+wavefrontsize32" "amdgpu-waves-per-eu"="2,4" }
-attributes #1 = { noinline nounwind "target-features"="+wavefrontsize64" "amdgpu-waves-per-eu"="1,1" }
+attributes #0 = { nounwind "target-features"="+wavefrontsize32" }
+attributes #1 = { noinline nounwind "target-features"="+wavefrontsize64" }
 attributes #2 = { nounwind "target-features"="+wavefrontsize64" }
 attributes #3 = { nounwind "target-features"="+wavefrontsize64" }
-attributes #4 = { noinline nounwind "target-features"="+wavefrontsize64" "amdgpu-waves-per-eu"="2,4" }
+attributes #4 = { noinline nounwind "target-features"="+wavefrontsize64" }

llvm/test/CodeGen/AMDGPU/propagate-attributes-function-pointer-argument.ll

 ; were actually the function being called.
 ; CHECK-DAG: define private void @g.1() #1
 ; CHECK-DAG: define internal void @g() #2
 define private void @g() #1 {
     ret void
 }
 
 attributes #0 = { noinline }
-attributes #1 = { noinline "amdgpu-waves-per-eu"="1,10" }
+attributes #1 = { noinline "target-features"="+wavefrontsize32" }