[AMDGPU] Add simplification/combines for llvm.amdgcn.fmul.legacy

[arsenm]

llvm/lib/Target/AMDGPU/AMDGPUInstCombineIntrinsic.cpp

166

Does the sign matter?

166–176

Do we not have something for this in PatternMatch?

830

Clarify if the sign of zero matters?

844–845

Should check this case first since it's cheaper

844–845

Actually, should we have a more general isKnownFiniteNonZero that happens to check constants?

[foad]

Add some matchers to PatternMatch and use them.

[foad]

llvm/lib/Target/AMDGPU/AMDGPUInstCombineIntrinsic.cpp

844–845

Perhaps. ValueTracking has isKnownNonZero which doesn't work on floats, but could be made to. It also has CannotBeOrderedLessThanZero.

isKnownFiniteNonZero seems rather specific to me. I realise it's probably more efficient than separate calls to isKnownNeverNaN, isKnownNeverInfinity and isKnownNonZero, but without a lot of refactoring I think there's a serious risk of having dozens of different entrypoints.

As another data point, SelectionDAG has separate isKnownNeverZero and isKnownNeverZeroFloat functions.

Anyway... I decided to duck all of this and just have it work on constants, for now.

[foad]

It might make sense to rebase this on D89038.

[foad]

Rebase on D89038.

[foad]

Ping.

[arsenm]

llvm/lib/Target/AMDGPU/AMDGPUInstCombineIntrinsic.cpp

844–845

Should add todo to generalize. I was also thinking all the isKnown* functions should return a bitmask, kind of like the inverse of the class intrinsic

llvm/include/llvm/IR/PatternMatch.h

 };
 /// Match a finite FP constant, i.e. not infinity or NaN.
 /// For vectors, this includes constants with undefined elements.
 inline cstfp_pred_ty<is_finite> m_Finite() {
   return cstfp_pred_ty<is_finite>();
 }
 inline apf_pred_ty<is_finite> m_Finite(const APFloat *&V) { return V; }
 
+struct is_finitenonzero {
+  bool isValue(const APFloat &C) { return C.isFiniteNonZero(); }
+};
+/// Match a finite non-zero FP constant.
+/// For vectors, this includes constants with undefined elements.
+inline cstfp_pred_ty<is_finitenonzero> m_FiniteNonZero() {
+  return cstfp_pred_ty<is_finitenonzero>();
+}
+inline apf_pred_ty<is_finitenonzero> m_FiniteNonZero(const APFloat *&V) {
+  return V;
+}
+
 struct is_any_zero_fp {
   bool isValue(const APFloat &C) { return C.isZero(); }
 };
 /// Match a floating-point negative zero or positive zero.
 /// For vectors, this includes constants with undefined elements.
 inline cstfp_pred_ty<is_any_zero_fp> m_AnyZeroFP() {
   return cstfp_pred_ty<is_any_zero_fp>();
 }

llvm/lib/Target/AMDGPU/AMDGPUInstCombineIntrinsic.cpp

simplifyAMDGCNImageIntrinsic(const GCNSubtarget *ST,
 
   CallInst *NewCall = IC.Builder.CreateCall(I, Args);
   NewCall->takeName(&II);
   NewCall->copyMetadata(II);
   NewCall->copyFastMathFlags(&II);
   return IC.replaceInstUsesWith(II, NewCall);
 }
 
 Optional<Instruction *>
 GCNTTIImpl::instCombineIntrinsic(InstCombiner &IC, IntrinsicInst &II) const {
   Intrinsic::ID IID = II.getIntrinsicID();
   switch (IID) {
   case Intrinsic::amdgcn_rcp: {
     Value *Src = II.getArgOperand(0);
 
     // TODO: Move to ConstantFolding/InstSimplify?
     if (isa<UndefValue>(Src)) {
       Type *Ty = II.getType();
       auto *QNaN = ConstantFP::get(Ty, APFloat::getQNaN(Ty->getFltSemantics()));
       return IC.replaceInstUsesWith(II, QNaN);
     }
 
     if (II.isStrictFP())
       break;
 
     if (const ConstantFP *C = dyn_cast<ConstantFP>(Src)) {
       const APFloat &ArgVal = C->getValueAPF();
case Intrinsic::amdgcn_ldexp: {
     // ldexp(x, 0) -> x
     // ldexp(x, undef) -> x
     if (isa<UndefValue>(Op1) || match(Op1, PatternMatch::m_ZeroInt())) {
       return IC.replaceInstUsesWith(II, Op0);
     }
 
     break;
   }
+  case Intrinsic::amdgcn_fmul_legacy: {
+    Value *Op0 = II.getArgOperand(0);
+    Value *Op1 = II.getArgOperand(1);
+
+    // The legacy behaviour is that multiplying +/-0.0 by anything, even NaN or
+    // infinity, gives +0.0.
+    // TODO: Move to InstSimplify?
+    if (match(Op0, PatternMatch::m_AnyZeroFP()) ||
+        match(Op1, PatternMatch::m_AnyZeroFP()))
+      return IC.replaceInstUsesWith(II, ConstantFP::getNullValue(II.getType()));
+
+    // If we can prove we don't have one of the special cases then we can use a
+    // normal fmul instruction instead.
+    auto *TLI = &IC.getTargetLibraryInfo();
+    bool CanSimplifyToMul = false;
+    // TODO: Create and use isKnownFiniteNonZero instead of just matching
+    // constants here.
+    if (match(Op0, PatternMatch::m_FiniteNonZero()) ||
+        match(Op1, PatternMatch::m_FiniteNonZero())) {
+      // One operand is not zero or infinity or NaN.
+      CanSimplifyToMul = true;
+    } else if (isKnownNeverInfinity(Op0, TLI) && isKnownNeverNaN(Op0, TLI) &&
+               isKnownNeverInfinity(Op1, TLI) && isKnownNeverNaN(Op1, TLI)) {
+      // Neither operand is infinity or NaN.
+      CanSimplifyToMul = true;
+    }
+    if (CanSimplifyToMul) {
+      auto *FMul = IC.Builder.CreateFMulFMF(Op0, Op1, &II);
+      FMul->takeName(&II);
+      return IC.replaceInstUsesWith(II, FMul);
+    }
+    break;
+  }
   default: {
     if (const AMDGPU::ImageDimIntrinsicInfo *ImageDimIntr =
             AMDGPU::getImageDimIntrinsicInfo(II.getIntrinsicID())) {
       return simplifyAMDGCNImageIntrinsic(ST, ImageDimIntr, II, IC);
     }
   }
   }
   return None;

llvm/test/Transforms/InstCombine/AMDGPU/fmul_legacy.ll

+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
+; RUN: opt < %s -mtriple=amdgcn-amd-amdhsa -instcombine -S | FileCheck %s
+
+; Simplify to +0.0.
+define float @test_zero(float %x) {
+; CHECK-LABEL: @test_zero(
+; CHECK-NEXT:    ret float 0.000000e+00
+;
+  %call = call float @llvm.amdgcn.fmul.legacy(float %x, float 0.0)
+  ret float %call
+}
+
+; Simplify to +0.0.
+define float @test_negzero(float %y) {
+; CHECK-LABEL: @test_negzero(
+; CHECK-NEXT:    ret float 0.000000e+00
+;
+  %call = call float @llvm.amdgcn.fmul.legacy(float -0.0, float %y)
+  ret float %call
+}
+
+; Combine to fmul because the constant is finite and non-zero.
+define float @test_const(float %x) {
+; CHECK-LABEL: @test_const(
+; CHECK-NEXT:    [[CALL:%.*]] = fmul float [[X:%.*]], 9.950000e+01
+; CHECK-NEXT:    ret float [[CALL]]
+;
+  %call = call float @llvm.amdgcn.fmul.legacy(float %x, float 99.5)
+  ret float %call
+}
+
+; Combine to fmul because neither argument can be infinity or NaN.
+define float @test_finite(i32 %x, i32 %y) {
+; CHECK-LABEL: @test_finite(
+; CHECK-NEXT:    [[XF:%.*]] = sitofp i32 [[X:%.*]] to float
+; CHECK-NEXT:    [[YF:%.*]] = sitofp i32 [[Y:%.*]] to float
+; CHECK-NEXT:    [[CALL:%.*]] = fmul float [[XF]], [[YF]]
+; CHECK-NEXT:    ret float [[CALL]]
+;
+  %xf = sitofp i32 %x to float
+  %yf = sitofp i32 %y to float
+  %call = call float @llvm.amdgcn.fmul.legacy(float %xf, float %yf)
+  ret float %call
+}
+
+declare float @llvm.amdgcn.fmul.legacy(float, float)