[llvm] 699685b - AMDGPU: Enable assumptions in AMDGPULibCalls

[Matt Arsenault via llvm-commits]

Author: Matt Arsenault
Date: 2023-09-01T08:22:16-04:00
New Revision: 699685b7185bfe196a6ae24df6daa9f68c79148e

URL: https://github.com/llvm/llvm-project/commit/699685b7185bfe196a6ae24df6daa9f68c79148e
DIFF: https://github.com/llvm/llvm-project/commit/699685b7185bfe196a6ae24df6daa9f68c79148e.diff

LOG: AMDGPU: Enable assumptions in AMDGPULibCalls

https://reviews.llvm.org/D159006

Added: 
    

Modified: 
    llvm/lib/Target/AMDGPU/AMDGPULibCalls.cpp
    llvm/test/CodeGen/AMDGPU/amdgpu-simplify-libcall-pow.ll

Removed: 
    


################################################################################
diff  --git a/llvm/lib/Target/AMDGPU/AMDGPULibCalls.cpp b/llvm/lib/Target/AMDGPU/AMDGPULibCalls.cpp
index f5e9b09ccaf77f..edc1077de601e2 100644
--- a/llvm/lib/Target/AMDGPU/AMDGPULibCalls.cpp
+++ b/llvm/lib/Target/AMDGPU/AMDGPULibCalls.cpp
@@ -14,7 +14,10 @@
 #include "AMDGPU.h"
 #include "AMDGPULibFunc.h"
 #include "GCNSubtarget.h"
+#include "llvm/Analysis/AssumptionCache.h"
+#include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/Analysis/ValueTracking.h"
+#include "llvm/IR/Dominators.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/IntrinsicsAMDGPU.h"
@@ -46,6 +49,9 @@ namespace llvm {
 
 class AMDGPULibCalls {
 private:
+  const TargetLibraryInfo *TLInfo = nullptr;
+  AssumptionCache *AC = nullptr;
+  DominatorTree *DT = nullptr;
 
   typedef llvm::AMDGPULibFunc FuncInfo;
 
@@ -135,7 +141,7 @@ class AMDGPULibCalls {
 
   bool fold(CallInst *CI);
 
-  void initFunction(const Function &F);
+  void initFunction(Function &F, FunctionAnalysisManager &FAM);
   void initNativeFuncs();
 
   // Replace a normal math function call with that native version
@@ -420,8 +426,11 @@ bool AMDGPULibCalls::canIncreasePrecisionOfConstantFold(
   return isUnsafeMath(FPOp);
 }
 
-void AMDGPULibCalls::initFunction(const Function &F) {
+void AMDGPULibCalls::initFunction(Function &F, FunctionAnalysisManager &FAM) {
   UnsafeFPMath = F.getFnAttribute("unsafe-fp-math").getValueAsBool();
+  AC = &FAM.getResult<AssumptionAnalysis>(F);
+  TLInfo = &FAM.getResult<TargetLibraryAnalysis>(F);
+  DT = FAM.getCachedResult<DominatorTreeAnalysis>(F);
 }
 
 bool AMDGPULibCalls::useNativeFunc(const StringRef F) const {
@@ -699,12 +708,14 @@ bool AMDGPULibCalls::fold(CallInst *CI) {
       Module *M = Callee->getParent();
       AMDGPULibFunc PowrInfo(AMDGPULibFunc::EI_POWR, FInfo);
       FunctionCallee PowrFunc = getFunction(M, PowrInfo);
+      CallInst *Call = cast<CallInst>(FPOp);
 
       // pow(x, y) -> powr(x, y) for x >= -0.0
-      // TODO: Pass all arguments to cannotBeOrderedLessThanZero
-      if (PowrFunc && cannotBeOrderedLessThanZero(FPOp->getOperand(0),
-                                                  M->getDataLayout())) {
-        cast<CallInst>(FPOp)->setCalledFunction(PowrFunc);
+      // TODO: Account for flags on current call
+      if (PowrFunc &&
+          cannotBeOrderedLessThanZero(FPOp->getOperand(0), M->getDataLayout(),
+                                      TLInfo, 0, AC, Call, DT)) {
+        Call->setCalledFunction(PowrFunc);
         return fold_pow(FPOp, B, PowrInfo) || true;
       }
 
@@ -1601,7 +1612,7 @@ PreservedAnalyses AMDGPUSimplifyLibCallsPass::run(Function &F,
                                                   FunctionAnalysisManager &AM) {
   AMDGPULibCalls Simplifier;
   Simplifier.initNativeFuncs();
-  Simplifier.initFunction(F);
+  Simplifier.initFunction(F, AM);
 
   bool Changed = false;
 
@@ -1630,7 +1641,7 @@ PreservedAnalyses AMDGPUUseNativeCallsPass::run(Function &F,
 
   AMDGPULibCalls Simplifier;
   Simplifier.initNativeFuncs();
-  Simplifier.initFunction(F);
+  Simplifier.initFunction(F, AM);
 
   bool Changed = false;
   for (auto &BB : F) {

diff  --git a/llvm/test/CodeGen/AMDGPU/amdgpu-simplify-libcall-pow.ll b/llvm/test/CodeGen/AMDGPU/amdgpu-simplify-libcall-pow.ll
index 733417484eff2c..6b72ba56fd20b9 100644
--- a/llvm/test/CodeGen/AMDGPU/amdgpu-simplify-libcall-pow.ll
+++ b/llvm/test/CodeGen/AMDGPU/amdgpu-simplify-libcall-pow.ll
@@ -1610,7 +1610,7 @@ define float @test_pow_f32_x_assumed_oge_0(float %x, float %y) {
 ; CHECK-SAME: (float [[X:%.*]], float [[Y:%.*]]) {
 ; CHECK-NEXT:    [[X_OGE_ZERO:%.*]] = fcmp oge float [[X]], 0.000000e+00
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[X_OGE_ZERO]])
-; CHECK-NEXT:    [[POW:%.*]] = tail call float @_Z3powff(float [[X]], float [[Y]])
+; CHECK-NEXT:    [[POW:%.*]] = tail call float @_Z4powrff(float [[X]], float [[Y]])
 ; CHECK-NEXT:    ret float [[POW]]
 ;
   %x.oge.zero = fcmp oge float %x, 0.0
@@ -1624,7 +1624,7 @@ define float @test_pow_f32_x_assumed_ogt_0(float %x, float %y) {
 ; CHECK-SAME: (float [[X:%.*]], float [[Y:%.*]]) {
 ; CHECK-NEXT:    [[X_OGE_ZERO:%.*]] = fcmp ogt float [[X]], 0.000000e+00
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[X_OGE_ZERO]])
-; CHECK-NEXT:    [[POW:%.*]] = tail call float @_Z3powff(float [[X]], float [[Y]])
+; CHECK-NEXT:    [[POW:%.*]] = tail call float @_Z4powrff(float [[X]], float [[Y]])
 ; CHECK-NEXT:    ret float [[POW]]
 ;
   %x.oge.zero = fcmp ogt float %x, 0.0
@@ -1638,7 +1638,7 @@ define float @test_pow_f32_x_assumed_uge_0(float %x, float %y) {
 ; CHECK-SAME: (float [[X:%.*]], float [[Y:%.*]]) {
 ; CHECK-NEXT:    [[X_UGE_ZERO:%.*]] = fcmp uge float [[X]], 0.000000e+00
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[X_UGE_ZERO]])
-; CHECK-NEXT:    [[POW:%.*]] = tail call float @_Z3powff(float [[X]], float [[Y]])
+; CHECK-NEXT:    [[POW:%.*]] = tail call float @_Z4powrff(float [[X]], float [[Y]])
 ; CHECK-NEXT:    ret float [[POW]]
 ;
   %x.uge.zero = fcmp uge float %x, 0.0
@@ -1652,7 +1652,7 @@ define float @test_pow_f32_x_assumed_ugt_0(float %x, float %y) {
 ; CHECK-SAME: (float [[X:%.*]], float [[Y:%.*]]) {
 ; CHECK-NEXT:    [[X_UGT_ZERO:%.*]] = fcmp ugt float [[X]], 0.000000e+00
 ; CHECK-NEXT:    call void @llvm.assume(i1 [[X_UGT_ZERO]])
-; CHECK-NEXT:    [[POW:%.*]] = tail call float @_Z3powff(float [[X]], float [[Y]])
+; CHECK-NEXT:    [[POW:%.*]] = tail call float @_Z4powrff(float [[X]], float [[Y]])
 ; CHECK-NEXT:    ret float [[POW]]
 ;
   %x.ugt.zero = fcmp ugt float %x, 0.0