[FPEnv Core 07/14] Prevent undesired folding by InstSimplify

[sdmitrouk]

Changes required due to updated of patches that go before this one.

lib/Analysis/InstructionSimplify.cpp

 /// Given operands for an FAdd, see if we can fold the result.  If not, this
 /// returns null.
 static Value *SimplifyFAddInst(Value *Op0, Value *Op1, FastMathFlags FMF,
                               const Query &Q, unsigned MaxRecurse) {
   if (Constant *CLHS = dyn_cast<Constant>(Op0)) {
     if (Constant *CRHS = dyn_cast<Constant>(Op1)) {
       Constant *Ops[] = { CLHS, CRHS };
       return ConstantFoldInstOperands(Instruction::FAdd, CLHS->getType(),
-                                      Ops, Q.DL, Q.TLI);
+                                      Ops, Q.DL, Q.TLI, FMF);
     }
 
     // Canonicalize the constant to the RHS.
     std::swap(Op0, Op1);
   }
 
   // fadd X, -0 ==> X
   if (match(Op1, m_NegZero()))

 /// Given operands for an FSub, see if we can fold the result.  If not, this
 /// returns null.
 static Value *SimplifyFSubInst(Value *Op0, Value *Op1, FastMathFlags FMF,
                               const Query &Q, unsigned MaxRecurse) {
   if (Constant *CLHS = dyn_cast<Constant>(Op0)) {
     if (Constant *CRHS = dyn_cast<Constant>(Op1)) {
       Constant *Ops[] = { CLHS, CRHS };
       return ConstantFoldInstOperands(Instruction::FSub, CLHS->getType(),
-                                      Ops, Q.DL, Q.TLI);
+                                      Ops, Q.DL, Q.TLI, FMF);
     }
   }
 
   // fsub X, 0 ==> X
   if (match(Op1, m_Zero()))
     return Op0;
 
   // fsub X, -0 ==> X, when we know X is not -0

 static Value *SimplifyFMulInst(Value *Op0, Value *Op1,
                                FastMathFlags FMF,
                                const Query &Q,
                                unsigned MaxRecurse) {
  if (Constant *CLHS = dyn_cast<Constant>(Op0)) {
     if (Constant *CRHS = dyn_cast<Constant>(Op1)) {
       Constant *Ops[] = { CLHS, CRHS };
       return ConstantFoldInstOperands(Instruction::FMul, CLHS->getType(),
-                                      Ops, Q.DL, Q.TLI);
+                                      Ops, Q.DL, Q.TLI, FMF);
     }
 
     // Canonicalize the constant to the RHS.
     std::swap(Op0, Op1);
  }
 
  // fmul X, 1.0 ==> X
  if (match(Op1, m_FPOne()))

test/Transforms/InstSimplify/fast-math.ll

 
 define float @fdiv_neg_swapped2(float %f) {
   %neg = fsub float 0.000000e+00, %f
   %div = fdiv nnan float %f, %neg
   ret float %div
 ; CHECK-LABEL: fdiv_neg_swapped2
 ; CHECK: ret float -1.000000e+00
 }
+
+; CHECK-LABEL: @nofold_fadd_nexc(
+define double @nofold_fadd_nexc() {
+; CHECK: fadd
+entry:
+  %val = fadd nrnd double 1.000000e+308, 1.000000e+308
+  ret double %val
+}
+
+; CHECK-LABEL: @nofold_fsub_nexc(
+define double @nofold_fsub_nexc() {
+; CHECK: fsub
+entry:
+  %val = fsub nrnd double 1.000000e-308, 1.000000e+308
+  ret double %val
+}
+
+; CHECK-LABEL: @nofold_fmul_nexc(
+define double @nofold_fmul_nexc() {
+; CHECK: fmul
+entry:
+  %val = fmul nrnd double 1.000000e+300, 1.000000e+300
+  ret double %val
+}
+
+; CHECK-LABEL: @nofold_fadd_nrnd(
+define double @nofold_fadd_nrnd() {
+; CHECK: fadd
+entry:
+  %val = fadd nexc double 1.000000e+308, 1.000000e+308
+  ret double %val
+}
+
+; CHECK-LABEL: @nofold_fsub_nrnd(
+define double @nofold_fsub_nrnd() {
+; CHECK: fsub
+entry:
+  %val = fsub nexc double 1.000000e-308, 1.000000e+308
+  ret double %val
+}
+
+; CHECK-LABEL: @nofold_fmul_nrnd(
+define double @nofold_fmul_nrnd() {
+; CHECK: fmul
+entry:
+  %val = fmul nexc double 1.000000e+300, 1.000000e+300
+  ret double %val
+}