Revert "[AMDGPU][Attributor] Infer inreg attribute in AMDGPUAttributor (llvm#146720)"

This reverts commit 84ab301 because it breaks
several AMDGPU test bots.

Author: shiltian

llvm/lib/Target/AMDGPU/AMDGPUAttributor.cpp

@@ -13,7 +13,6 @@
 #include "AMDGPU.h"
 #include "GCNSubtarget.h"
 #include "Utils/AMDGPUBaseInfo.h"
-#include "llvm/Analysis/TargetTransformInfo.h"
 #include "llvm/IR/IntrinsicsAMDGPU.h"
 #include "llvm/IR/IntrinsicsR600.h"
 #include "llvm/Target/TargetMachine.h"
@@ -1297,116 +1296,6 @@ struct AAAMDGPUNoAGPR
 
 const char AAAMDGPUNoAGPR::ID = 0;
 
-struct AAAMDGPUUniform : public StateWrapper<BooleanState, AbstractAttribute> {
-  using Base = StateWrapper<BooleanState, AbstractAttribute>;
-  AAAMDGPUUniform(const IRPosition &IRP, Attributor &A) : Base(IRP) {}
-
-  /// Create an abstract attribute view for the position \p IRP.
-  static AAAMDGPUUniform &createForPosition(const IRPosition &IRP,
-                                            Attributor &A);
-
-  /// See AbstractAttribute::getName()
-  StringRef getName() const override { return "AAAMDGPUUniform"; }
-
-  const std::string getAsStr(Attributor *A) const override {
-    return getAssumed() ? "uniform" : "divergent";
-  }
-
-  void trackStatistics() const override {}
-
-  /// See AbstractAttribute::getIdAddr()
-  const char *getIdAddr() const override { return &ID; }
-
-  /// This function should return true if the type of the \p AA is
-  /// AAAMDGPUUniform
-  static bool classof(const AbstractAttribute *AA) {
-    return (AA->getIdAddr() == &ID);
-  }
-
-  /// Unique ID (due to the unique address)
-  static const char ID;
-};
-
-const char AAAMDGPUUniform::ID = 0;
-
-/// This AA is to infer the inreg attribute for a function argument.
-struct AAAMDGPUUniformArgument : public AAAMDGPUUniform {
-  AAAMDGPUUniformArgument(const IRPosition &IRP, Attributor &A)
-      : AAAMDGPUUniform(IRP, A) {}
-
-  void initialize(Attributor &A) override {
-    Argument *Arg = getAssociatedArgument();
-    CallingConv::ID CC = Arg->getParent()->getCallingConv();
-    if (Arg->hasAttribute(Attribute::InReg)) {
-      indicateOptimisticFixpoint();
-      return;
-    }
-
-    if (AMDGPU::isEntryFunctionCC(CC)) {
-      // We only use isArgPassedInSGPR on kernel entry function argument, so
-      // even if we will use SPGR for non-uniform i1 argument passing, it will
-      // not affect this.
-      if (AMDGPU::isArgPassedInSGPR(Arg))
-        indicateOptimisticFixpoint();
-      else
-        indicatePessimisticFixpoint();
-    }
-  }
-
-  ChangeStatus updateImpl(Attributor &A) override {
-    unsigned ArgNo = getAssociatedArgument()->getArgNo();
-
-    auto isUniform = [&](AbstractCallSite ACS) -> bool {
-      CallBase *CB = ACS.getInstruction();
-      Value *V = CB->getArgOperand(ArgNo);
-      if (isa<Constant>(V))
-        return true;
-      if (auto *Arg = dyn_cast<Argument>(V)) {
-        auto *AA = A.getOrCreateAAFor<AAAMDGPUUniform>(
-            IRPosition::argument(*Arg), this, DepClassTy::REQUIRED);
-        return AA && AA->isValidState();
-      }
-      const TargetTransformInfo *TTI =
-          A.getInfoCache().getAnalysisResultForFunction<TargetIRAnalysis>(
-              *CB->getFunction());
-      return TTI->isAlwaysUniform(V);
-    };
-
-    bool UsedAssumedInformation = true;
-    if (!A.checkForAllCallSites(isUniform, *this, /*RequireAllCallSites=*/true,
-                                UsedAssumedInformation))
-      return indicatePessimisticFixpoint();
-
-    if (!UsedAssumedInformation)
-      return indicateOptimisticFixpoint();
-
-    return ChangeStatus::UNCHANGED;
-  }
-
-  ChangeStatus manifest(Attributor &A) override {
-    Argument *Arg = getAssociatedArgument();
-    // If the argument already has inreg attribute, we will not do anything
-    // about it.
-    if (Arg->hasAttribute(Attribute::InReg))
-      return ChangeStatus::UNCHANGED;
-    if (AMDGPU::isEntryFunctionCC(Arg->getParent()->getCallingConv()))
-      return ChangeStatus::UNCHANGED;
-    LLVMContext &Ctx = Arg->getContext();
-    return A.manifestAttrs(getIRPosition(),
-                           {Attribute::get(Ctx, Attribute::InReg)});
-  }
-};
-
-AAAMDGPUUniform &AAAMDGPUUniform::createForPosition(const IRPosition &IRP,
-                                                    Attributor &A) {
-  switch (IRP.getPositionKind()) {
-  case IRPosition::IRP_ARGUMENT:
-    return *new (A.Allocator) AAAMDGPUUniformArgument(IRP, A);
-  default:
-    llvm_unreachable("not a valid position for AAAMDGPUUniform");
-  }
-}
-
 /// Performs the final check and updates the 'amdgpu-waves-per-eu' attribute
 /// based on the finalized 'amdgpu-flat-work-group-size' attribute.
 /// Both attributes start with narrow ranges that expand during iteration.
@@ -1493,7 +1382,7 @@ static bool runImpl(Module &M, AnalysisGetter &AG, TargetMachine &TM,
        &AAAMDMaxNumWorkgroups::ID, &AAAMDWavesPerEU::ID, &AAAMDGPUNoAGPR::ID,
        &AACallEdges::ID, &AAPointerInfo::ID, &AAPotentialConstantValues::ID,
        &AAUnderlyingObjects::ID, &AANoAliasAddrSpace::ID, &AAAddressSpace::ID,
-       &AAIndirectCallInfo::ID, &AAAMDGPUUniform::ID});
+       &AAIndirectCallInfo::ID});
 
   AttributorConfig AC(CGUpdater);
   AC.IsClosedWorldModule = Options.IsClosedWorld;
@@ -1546,11 +1435,6 @@ static bool runImpl(Module &M, AnalysisGetter &AG, TargetMachine &TM,
         A.getOrCreateAAFor<AAAddressSpace>(IRPosition::value(*Ptr));
         A.getOrCreateAAFor<AANoAliasAddrSpace>(IRPosition::value(*Ptr));
       }
-
-      if (!AMDGPU::isEntryFunctionCC(F->getCallingConv())) {
-        for (auto &Arg : F->args())
-          A.getOrCreateAAFor<AAAMDGPUUniform>(IRPosition::argument(Arg));
-      }
     }
   }
 

llvm/test/CodeGen/AMDGPU/aa-inreg-inference.ll

@@ -480,7 +480,7 @@ bb.2.end:
 
 define internal void @callee_no_alias_addr_space_select(ptr %ptr1, ptr %ptr2, ptr %ptr3, i1 %cond1, i1 %cond2, i32 %val) #0 {
 ; CHECK-LABEL: define internal void @callee_no_alias_addr_space_select(
-; CHECK-SAME: ptr [[PTR1:%.*]], ptr [[PTR2:%.*]], ptr [[PTR3:%.*]], i1 inreg [[COND1:%.*]], i1 inreg [[COND2:%.*]], i32 inreg [[VAL:%.*]]) #[[ATTR1:[0-9]+]] {
+; CHECK-SAME: ptr [[PTR1:%.*]], ptr [[PTR2:%.*]], ptr [[PTR3:%.*]], i1 [[COND1:%.*]], i1 [[COND2:%.*]], i32 [[VAL:%.*]]) #[[ATTR1:[0-9]+]] {
 ; CHECK-NEXT:    [[PTR4:%.*]] = select i1 [[COND1]], ptr addrspacecast (ptr addrspace(1) @gptr to ptr), ptr addrspacecast (ptr addrspace(4) @gptr2 to ptr)
 ; CHECK-NEXT:    [[PTR5:%.*]] = select i1 [[COND2]], ptr [[PTR4]], ptr addrspacecast (ptr addrspace(3) @gptr3 to ptr)
 ; CHECK-NEXT:    store i32 [[VAL]], ptr [[PTR5]], align 4, !noalias.addrspace [[META1:![0-9]+]]
@@ -516,7 +516,7 @@ define internal void @callee_no_alias_addr_space_select(ptr %ptr1, ptr %ptr2, pt
 
 define internal void @callee_alias_addr_space_branch(ptr %ptr1, ptr %ptr2, ptr %ptr3, i1 %cond1, i1 %cond2, i32 %val) #0 {
 ; CHECK-LABEL: define internal void @callee_alias_addr_space_branch(
-; CHECK-SAME: ptr [[PTR1:%.*]], ptr [[PTR2:%.*]], ptr [[PTR3:%.*]], i1 inreg [[COND1:%.*]], i1 inreg [[COND2:%.*]], i32 inreg [[VAL:%.*]]) #[[ATTR1]] {
+; CHECK-SAME: ptr [[PTR1:%.*]], ptr [[PTR2:%.*]], ptr [[PTR3:%.*]], i1 [[COND1:%.*]], i1 [[COND2:%.*]], i32 [[VAL:%.*]]) #[[ATTR1]] {
 ; CHECK-NEXT:    br i1 [[COND1]], label %[[BB_1_TRUE:.*]], label %[[BB_1_FALSE:.*]]
 ; CHECK:       [[BB_1_TRUE]]:
 ; CHECK-NEXT:    br label %[[BB_1_END:.*]]