AMDGPU: Enable assumptions in AMDGPULibCalls

[arsenm]

699685b7185bfe196a6ae24df6daa9f68c79148e

llvm/lib/Target/AMDGPU/AMDGPULibCalls.cpp

 //===- AMDGPULibCalls.cpp -------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 /// \file
 /// This file does AMD library function optimizations.
 //
 //===----------------------------------------------------------------------===//
 
 #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"
 #include "llvm/IR/PatternMatch.h"
 #include "llvm/InitializePasses.h"
 #include <cmath>
 
 #define DEBUG_TYPE "amdgpu-simplifylib"

 #define MATH_E       numbers::e
 #define MATH_SQRT2   numbers::sqrt2
 #define MATH_SQRT1_2 numbers::inv_sqrt2
 
 namespace llvm {
 
 class AMDGPULibCalls {
 private:
+  const TargetLibraryInfo *TLInfo = nullptr;
+  AssumptionCache *AC = nullptr;
+  DominatorTree *DT = nullptr;
 
   typedef llvm::AMDGPULibFunc FuncInfo;
 
   bool UnsafeFPMath = false;
 
   // -fuse-native.
   bool AllNative = false;
 
static void replaceCall(FPMathOperator *I, Value *With) {
     replaceCall(cast<Instruction>(I), With);
   }
 
 public:
   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
   bool useNative(CallInst *CI);
 };
 
 } // end llvm namespace
 

 }
 
 bool AMDGPULibCalls::canIncreasePrecisionOfConstantFold(
     const FPMathOperator *FPOp) const {
   // TODO: Refine to approxFunc or contract
   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 {
   return AllNative || llvm::is_contained(UseNative, F);
 }
 
 void AMDGPULibCalls::initNativeFuncs() {
   AllNative = useNativeFunc("all") ||
case AMDGPULibFunc::EI_LDEXP: {
           CI->getModule(), Intrinsic::ldexp,
           {CI->getType(), CI->getArgOperand(1)->getType()}));
       return true;
     }
     case AMDGPULibFunc::EI_POW: {
       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;
       }
 
       return fold_pow(FPOp, B, FInfo);
     }
     case AMDGPULibFunc::EI_POWR:
     case AMDGPULibFunc::EI_POWN:
       return fold_pow(FPOp, B, FInfo);
bool AMDGPULibCalls::evaluateCall(CallInst *aCI, const FuncInfo &FInfo) {
   replaceCall(aCI, nval0);
   return true;
 }
 
 PreservedAnalyses AMDGPUSimplifyLibCallsPass::run(Function &F,
                                                   FunctionAnalysisManager &AM) {
   AMDGPULibCalls Simplifier;
   Simplifier.initNativeFuncs();
-  Simplifier.initFunction(F);
+  Simplifier.initFunction(F, AM);
 
   bool Changed = false;
 
   LLVM_DEBUG(dbgs() << "AMDIC: process function ";
              F.printAsOperand(dbgs(), false, F.getParent()); dbgs() << '\n';);
 
   for (auto &BB : F) {
     for (BasicBlock::iterator I = BB.begin(), E = BB.end(); I != E;) {

 
 PreservedAnalyses AMDGPUUseNativeCallsPass::run(Function &F,
                                                 FunctionAnalysisManager &AM) {
   if (UseNative.empty())
     return PreservedAnalyses::all();
 
   AMDGPULibCalls Simplifier;
   Simplifier.initNativeFuncs();
-  Simplifier.initFunction(F);
+  Simplifier.initFunction(F, AM);
 
   bool Changed = false;
   for (auto &BB : F) {
     for (BasicBlock::iterator I = BB.begin(), E = BB.end(); I != E;) {
       // Ignore non-calls.
       CallInst *CI = dyn_cast<CallInst>(I);
       ++I;
       if (CI && Simplifier.useNative(CI))
         Changed = true;
     }
   }
   return Changed ? PreservedAnalyses::none() : PreservedAnalyses::all();
 }

llvm/test/CodeGen/AMDGPU/amdgpu-simplify-libcall-pow.ll

;
   ret float %pow
 }
 
 define float @test_pow_f32_x_assumed_oge_0(float %x, float %y) {
 ; CHECK-LABEL: define float @test_pow_f32_x_assumed_oge_0
 ; 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
   call void @llvm.assume(i1 %x.oge.zero)
   %pow = tail call float @_Z3powff(float %x, float %y)
   ret float %pow
 }
 
 define float @test_pow_f32_x_assumed_ogt_0(float %x, float %y) {
 ; CHECK-LABEL: define float @test_pow_f32_x_assumed_ogt_0
 ; 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
   call void @llvm.assume(i1 %x.oge.zero)
   %pow = tail call float @_Z3powff(float %x, float %y)
   ret float %pow
 }
 
 define float @test_pow_f32_x_assumed_uge_0(float %x, float %y) {
 ; CHECK-LABEL: define float @test_pow_f32_x_assumed_uge_0
 ; 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
   call void @llvm.assume(i1 %x.uge.zero)
   %pow = tail call float @_Z3powff(float %x, float %y)
   ret float %pow
 }
 
 define float @test_pow_f32_x_assumed_ugt_0(float %x, float %y) {
 ; CHECK-LABEL: define float @test_pow_f32_x_assumed_ugt_0
 ; 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
   call void @llvm.assume(i1 %x.ugt.zero)
   %pow = tail call float @_Z3powff(float %x, float %y)
   ret float %pow
 }