[InstSimplify] Match 1.0 and 0.0 for both operands in SimplifyFMAMul

[fhahn]

Summary

Because we do not constant fold multiplications in SimplifyFMAMul,
we match 1.0 and 0.0 for both operands, as multiplying by them
is guaranteed to produce an exact result (if it is allowed to do so).

Note that it is not enough to just swap the operands to ensure a
constant is on the RHS, as we want to also cover the case with
2 constants.

[lebedev.ri]

LG

llvm/lib/Analysis/InstructionSimplify.cpp

4561

I'm wondering if

{
if(isa<Constant>(Op0)) std::swap(Op0, Op1);

would be simpler?

[fhahn]

llvm/lib/Analysis/InstructionSimplify.cpp

4561

I initially also used to swap the operands, but we'd also have to check if it's a 1.1 or 0.0 constant I think, to handle fmul 10.0, 0.0. That's not a problem with SimplifyFMulInst, as constant folding would cover this case.

[reames]

llvm/lib/Analysis/InstructionSimplify.cpp

4561

I believe that fmul is not necessarily commutative (for nan inputs). Given that, swap would be correct for this case, but dangerous in general.

[reames]

llvm/lib/Analysis/InstructionSimplify.cpp

4561

Er, maybe I'm wrong here. At least the accessors in Instruction.h seems to think so.

[lebedev.ri]

I'm fine with this approach.

llvm/lib/Analysis/InstructionSimplify.cpp

4561

I'm pretty sure fadd/fmul are commutative (X * Y == Y * X), but not associative ((X * Y) * Z != (X * Z) * Y).
So accessors are likely wrong. Or many more code is wrong elsewhere.

llvm/lib/Analysis/InstructionSimplify.cpp

static Value *SimplifyFSubInst(Value *Op0, Value *Op1, FastMathFlags FMF,
   return nullptr;
 }
 
 /// Given operands for the multiplication of a FMA, fold the result or return
 /// null. In contrast to SimplifyFMulInst, this function won't return values
 /// requiring rounding.
 static Value *SimplifyFMAFMul(Value *Op0, Value *Op1, FastMathFlags FMF,
                               const SimplifyQuery &Q, unsigned MaxRecurse) {
   // fmul X, 1.0 ==> X
   if (match(Op1, m_FPOne()))
     return Op0;
 
+  // fmul 1.0, X ==> X
+  if (match(Op0, m_FPOne()))
+    return Op1;
+
   // fmul nnan nsz X, 0 ==> 0
   if (FMF.noNaNs() && FMF.noSignedZeros() && match(Op1, m_AnyZeroFP()))
     return ConstantFP::getNullValue(Op0->getType());
 
+  // fmul nnan nsz 0, X ==> 0
+  if (FMF.noNaNs() && FMF.noSignedZeros() && match(Op0, m_AnyZeroFP()))
+    return ConstantFP::getNullValue(Op1->getType());
+
   // sqrt(X) * sqrt(X) --> X, if we can:
   // 1. Remove the intermediate rounding (reassociate).
   // 2. Ignore non-zero negative numbers because sqrt would produce NAN.
   // 3. Ignore -0.0 because sqrt(-0.0) == -0.0, but -0.0 * -0.0 == 0.0.
   Value *X;
   if (Op0 == Op1 && match(Op0, m_Intrinsic<Intrinsic::sqrt>(m_Value(X))) &&
       FMF.allowReassoc() && FMF.noNaNs() && FMF.noSignedZeros())
     return X;

llvm/test/Transforms/InstCombine/fma.ll

 entry:
   %res = call nnan nsz <2 x double> @llvm.fma.v2f64(<2 x double> <double 1123123.0099110012314, double 9999.0000001>, <2 x double> <double 0.0000000129182, double 0.000009123>, <2 x double> %b)
   ret <2 x double> %res
 }
 
 define <2 x double> @fma_const_fmul_zero(<2 x double> %b) {
 ; CHECK-LABEL: @fma_const_fmul_zero(
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[RES:%.*]] = call nnan nsz <2 x double> @llvm.fma.v2f64(<2 x double> zeroinitializer, <2 x double> <double 0x4131233302898702, double 0x40C387800000D6C0>, <2 x double> [[B:%.*]])
-; CHECK-NEXT:    ret <2 x double> [[RES]]
+; CHECK-NEXT:    ret <2 x double> [[B:%.*]]
 ;
 entry:
   %res = call nnan nsz <2 x double> @llvm.fma.v2f64(<2 x double> <double 0.0, double 0.0>, <2 x double> <double 1123123.0099110012314, double 9999.0000001>, <2 x double> %b)
   ret <2 x double> %res
 }
 
 define <2 x double> @fma_const_fmul_zero2(<2 x double> %b) {
 ; CHECK-LABEL: @fma_const_fmul_zero2(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    ret <2 x double> [[B:%.*]]
 ;
 entry:
   %res = call nnan nsz <2 x double> @llvm.fma.v2f64(<2 x double> <double 1123123.0099110012314, double 9999.0000001>, <2 x double> <double 0.0, double 0.0>, <2 x double> %b)
   ret <2 x double> %res
 }
 
 define <2 x double> @fma_const_fmul_one(<2 x double> %b) {
 ; CHECK-LABEL: @fma_const_fmul_one(
 ; CHECK-NEXT:  entry:
-; CHECK-NEXT:    [[RES:%.*]] = call nnan nsz <2 x double> @llvm.fma.v2f64(<2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double> <double 0x4131233302898702, double 0x40C387800000D6C0>, <2 x double> [[B:%.*]])
+; CHECK-NEXT:    [[RES:%.*]] = fadd nnan nsz <2 x double> [[B:%.*]], <double 0x4131233302898702, double 0x40C387800000D6C0>
 ; CHECK-NEXT:    ret <2 x double> [[RES]]
 ;
 entry:
   %res = call nnan nsz <2 x double> @llvm.fma.v2f64(<2 x double> <double 1.0, double 1.0>, <2 x double> <double 1123123.0099110012314, double 9999.0000001>, <2 x double> %b)
   ret <2 x double> %res
 }
 
 define <2 x double> @fma_const_fmul_one2(<2 x double> %b) {