Add "X / 1.0" to SimplifyFDivInst

[zansari]

Summary

We support most other simplifications, but not "X / 1.0", for some reason.

This should be legal with and without NaNs.

I also added a case to call SimplifyFDivInst in SimplifyFPBinOp. Again, I'm not sure why this was missing, but it's useful to have for cases where the fast math flags are important for simplification (otherwise, we end up calling SimplifyBinOp which will drop the FMFs by the time it gets back to SimplifyFDivInst).

[majnemer]

test/Transforms/EarlyCSE/instsimplify-fdiv.ll

1–19 ↗

(On Diff #80797)

I'd prefer if we replaced this test with once which was more specific in test/Transforms/InstSimplify/fdiv.ll

[spatel]

I just added a test for this before reading David's comment: rL289098 .

Zia, you can update the CHECK lines there; we shouldn't need a more complicated regression test unless I'm missing something.

I assume it's just oversight that this is missing from InstSimplify. Currently, InstCombine gets it via:
/ CvtFDivConstToReciprocal tries to convert X/C into X*1/C if C not a special
/ FP value and:
/ 1) 1/C is exact, or
/ 2) reciprocal is allowed.
/ If the conversion was successful, the simplified expression "X * 1/C" is
/ returned; otherwise, NULL is returned.

[zansari]

That was timely and convenient, Sanjay.. Thanks :)

Also, thanks David.

Removed my overly complicated test, and "FIXME'ed" Sanjay's test to catch X/1.0.

[spatel]

LGTM.

llvm/trunk/lib/Analysis/InstructionSimplify.cpp

static Value *SimplifyFDivInst(Value *Op0, Value *Op1, FastMathFlags FMF,
   // undef / X -> undef    (the undef could be a snan).
   if (match(Op0, m_Undef()))
     return Op0;
 
   // X / undef -> undef
   if (match(Op1, m_Undef()))
     return Op1;
 
+  // X / 1.0 -> X
+  if (match(Op1, m_FPOne()))
+    return Op0;
+
   // 0 / X -> 0
   // Requires that NaNs are off (X could be zero) and signed zeroes are
   // ignored (X could be positive or negative, so the output sign is unknown).
   if (FMF.noNaNs() && FMF.noSignedZeros() && match(Op0, m_AnyZero()))
     return Op0;
 
   if (FMF.noNaNs()) {
     // X / X -> 1.0 is legal when NaNs are ignored.
static Value *SimplifyFPBinOp(unsigned Opcode, Value *LHS, Value *RHS,
                               unsigned MaxRecurse) {
   switch (Opcode) {
   case Instruction::FAdd:
     return SimplifyFAddInst(LHS, RHS, FMF, Q, MaxRecurse);
   case Instruction::FSub:
     return SimplifyFSubInst(LHS, RHS, FMF, Q, MaxRecurse);
   case Instruction::FMul:
     return SimplifyFMulInst(LHS, RHS, FMF, Q, MaxRecurse);
+  case Instruction::FDiv:
+    return SimplifyFDivInst(LHS, RHS, FMF, Q, MaxRecurse);
   default:
     return SimplifyBinOp(Opcode, LHS, RHS, Q, MaxRecurse);
   }
 }
 
 Value *llvm::SimplifyBinOp(unsigned Opcode, Value *LHS, Value *RHS,
                            const DataLayout &DL, const TargetLibraryInfo *TLI,
                            const DominatorTree *DT, AssumptionCache *AC,

llvm/trunk/test/Transforms/InstSimplify/floating-point-arithmetic.ll

 define double @fmul_X_1(double %a) {
 ; CHECK-LABEL: @fmul_X_1(
 ; CHECK-NEXT:    ret double %a
 ;
   %b = fmul double 1.000000e+00, %a
   ret double %b
 }
 
-; FIXME:
 ; fdiv X, 1.0 ==> X
 define float @fdiv_x_1(float %a) {
 ; CHECK-LABEL: @fdiv_x_1(
-; CHECK-NEXT:    [[RET:%.*]] = fdiv float %a, 1.000000e+00
-; CHECK-NEXT:    ret float [[RET]]
+; CHECK-NEXT:    ret float %a
 ;
   %ret = fdiv float %a, 1.0
   ret float %ret
 }
 
 ; We can't optimize away the fadd in this test because the input
 ; value to the function and subsequently to the fadd may be -0.0.
 ; In that one special case, the result of the fadd should be +0.0