[FPEnv Core 08/14] Do not simplify expressions with FPEnv access

[sdmitrouk]

Summary

Modify ConstantExpression to store these flags and then use them.

[sdmitrouk]

Update of test per flags rename and correction of one condition (need to ignore non-floating-point types).

[sdmitrouk]

Use different overload of ConstantExpr::get().

[mehdi_amini]

include/llvm/IR/Constants.h

1111

Document the new parameter

[sdmitrouk]

Document the new parameter (Strict).

[majnemer]

lib/IR/Constants.cpp

1890–1891

Er, why not teach ConstantExpression about these flags?

[mehdi_amini]

(mark unaccepted waiting to settle the ConstantExpr case)

lib/IR/Constants.cpp

1890–1891

I thought that since it was float specific it couldn't be added, but I just checked and saw that we have integer nsw/nuw already on ConstantExpr, so it seems possible.

ConstantExprKeyType accepts unsigned short SubclassOptionalData. FastMathFlags are currently unsigned Flags but there is not reason they couldn't be uint16_t instead right?

David: do you know why we don't already have FastMath on ConstantExpr? Is it because there was no case with FP where we wouldn't constant fold immediately?

Now, what are the potential benefit to deal with Floating point ConstantExpr with FastMath flags? And what are the complications (i.e. will we have to add extra care everywhere we deal with FP ConstantExpr?)?

[majnemer]

lib/IR/Constants.cpp

1890–1891

AFAIK, yes. We didn't believe the flags would meaningfully change the result of what expression we'd give back. This would change with the new flags.

[mehdi_amini]

lib/IR/Constants.cpp

1890–1891

Talk with David on IRC, I agree with him that it seems cleaner to have this.
Sergey: can you prepare a separate patch that would add FMF to ConstantExpr?
Thanks!

[sdmitrouk]

lib/IR/Constants.cpp

1890–1891

I forgot about this change and another code related to constant expressions got removed from different patch, so I thought there is no need to do something about them.

can you prepare a separate patch that would add FMF to ConstantExpr?

I can try if it's just adding the field and considering it in several places where folding is performed. If it's significantly more complex, then I'm afraid someone else should do this as I'll stop contributing to LLVM very soon (and either upload the rest of the patches for ARM and FENV pragma in Clang or pass them over to somebody else to do this).

By the way, the field is not of unsigned short type:

uint8_t SubclassOptionalData;

[sdmitrouk]

Replacing with FastMathFlags for ConstantExpr, separate patch would almost completely undo this one and two more (two following ones, which are related to Strict flag), so I guess it's better to have it here.

[sdmitrouk]

Realized that I forgot to update other methods of ConstantExprKeyType to include the new field, will do that later, it won't change much. Optional data field was already used and it's only 7bits in Value class, which would need to be extended to hold new flags, so I added a field to ConstantExpr instead.

[mehdi_amini]

lib/AsmParser/LLParser.cpp

2985

Remove

lib/IR/ConstantsContext.h

423

Can we reuse one of the previous field?

[sdmitrouk]

Remove extra empty line.

[sdmitrouk]

lib/IR/ConstantsContext.h

423

In case of binary expressions SubclassData holds 0 and SubclassOptionalData holds binary operation specific flags. We can use SubclassData, which will be inconsistent with other types of constant expressions, but can be done if that's OK.

[mehdi_amini]

lib/Analysis/ConstantFolding.cpp

1005

Why not always use CE->getFastMathFlags();? Wasn't the FMF param added to this function because of the lack of FMF in ConstantExpr originally?

lib/IR/ConstantsContext.h

423

I think it is OK, unless you have any clue why it wouldn't?

[sdmitrouk]

lib/Analysis/ConstantFolding.cpp

1005

Wasn't the FMF param added to this function because of the lack of FMF in ConstantExpr originally?

No, it wasn't. FMF can be from instruction which contains CE as one of its operands, the argument was added for llvm::ConstantFoldInstruction.

lib/IR/ConstantsContext.h

423

No, I just didn't see such use and thought maybe there is a reason for that, which isn't documented. I'll change this then.

[mehdi_amini]

lib/Analysis/ConstantFolding.cpp

1005

Again, now that constant expression have dedicated FMF, I'm not sure why we should apply the parent instruction FMF?
If a constant expression does not have FMF enabled and it an operand of an instruction with FMF enabled it does not give license to fold I think.
And on the opposite, a constant expression with FMF as an operand of an instruction with FMF disabled should be foldable.

It is very possible that I miss something, David and/or Hal may have an opinion on this?

[sdmitrouk]

lib/Analysis/ConstantFolding.cpp

1005

Maybe we can drop it, I'll need to check (don't remember by now) and see whether it causes any problems. Initially it did make sense to propagate flags of instruction to its operands, I agree that it might be useless now.

[sdmitrouk]

Reuse SubclassData and remove FastMathFlags argument.

[mehdi_amini]

LGTM. Thanks.

include/llvm/Analysis/ConstantFolding.h

/// and stores, which have no constant expression form.
   Constant *ConstantFoldInstruction(Instruction *I, const DataLayout &DL,
                                     const TargetLibraryInfo *TLI = nullptr);
 
 /// ConstantFoldConstantExpression - Attempt to fold the constant expression
 /// using the specified DataLayout.  If successful, the constant result is
 /// result is returned, if not, null is returned.
   Constant *
   ConstantFoldConstantExpression(const ConstantExpr *CE, const DataLayout &DL,
-                                 const TargetLibraryInfo *TLI = nullptr,
-                                 FastMathFlags FMF = FastMathFlags());
+                                 const TargetLibraryInfo *TLI = nullptr);
 
 /// ConstantFoldInstOperands - Attempt to constant fold an instruction with the
 /// specified operands.  If successful, the constant result is returned, if not,
 /// null is returned.  Note that this function can fail when attempting to
 /// fold instructions like loads and stores, which have no constant expression
 /// form.
 ///
   Constant *ConstantFoldInstOperands(unsigned Opcode, Type *DestTy,

include/llvm/IR/Constants.h

 /// maintained in the Value::SubclassData field.
 class ConstantExpr : public Constant {
   friend struct ConstantExprKeyType;
 
   friend class Constant;
   void destroyConstantImpl();
   Value *handleOperandChangeImpl(Value *From, Value *To, Use *U);
 
+  // Flags to control and limit possible optimizations.
+  FastMathFlags FMF;
+
 protected:
-  ConstantExpr(Type *ty, unsigned Opcode, Use *Ops, unsigned NumOps)
-    : Constant(ty, ConstantExprVal, Ops, NumOps) {
+  ConstantExpr(Type *ty, unsigned Opcode, Use *Ops, unsigned NumOps,
+               FastMathFlags FMF = FastMathFlags())
+    : Constant(ty, ConstantExprVal, Ops, NumOps), FMF(FMF) {
     // Operation type (an Instruction opcode) is stored as the SubclassData.
     setValueSubclassData(Opcode);
   }
 
 public:
   // Static methods to construct a ConstantExpr of different kinds.  Note that
   // these methods may return a object that is not an instance of the
   // ConstantExpr class, because they will attempt to fold the constant
public:
   /// folding if possible.
   ///
   /// \param Flags operator-specific set of flags (e.g. SDivOperator::IsExact).
   /// \param OnlyIfReducedTy see \a getWithOperands() docs.
   /// \param FMF common fast-math flags that can affect folding.
   static Constant *get(unsigned Opcode, Constant *C1, Constant *C2,
                        unsigned Flags = 0, Type *OnlyIfReducedTy = nullptr,
                        FastMathFlags FMF = FastMathFlags());
 
   /// Return a binary or shift operator constant expression, folding if
   /// possible.
   ///
   /// Convenience overload for passing fast-math flags.
   ///
   /// \param FMF common fast-math flags that can affect folding.
   static Constant *get(unsigned Opcode, Constant *C1, Constant *C2,
                        FastMathFlags FMF);
public:
   /// block.
   ///
   /// A better approach to this could be to have a constructor for Instruction
   /// which would take a ConstantExpr parameter, but that would have spread
   /// implementation details of ConstantExpr outside of Constants.cpp, which
   /// would make it harder to remove ConstantExprs altogether.
   Instruction *getAsInstruction();
 
+  /// Returns fast math flags for this constant expression.
+  FastMathFlags getFastMathFlags() const { return FMF; }
+
   /// Methods for support type inquiry through isa, cast, and dyn_cast:
   static inline bool classof(const Value *V) {
     return V->getValueID() == ConstantExprVal;
   }
 
 private:
   // Shadow Value::setValueSubclassData with a private forwarding method so that
   // subclasses cannot accidentally use it.

include/llvm/IR/FastMathFlags.h

 #define LLVM_IR_FASTMATHFLAGS_H
 
 namespace llvm {
 
 /// Convenience struct for specifying and reasoning about fast-math flags.
 class FastMathFlags {
 private:
   friend class FPMathOperator;
+  friend class ConstantExpr;
+  friend class ConstantExprKeyType;
   unsigned Flags;
   FastMathFlags(unsigned F) : Flags(F) { }
 
 public:
   enum {
     UnsafeAlgebra   = (1 << 0),
     NoNaNs          = (1 << 1),
     NoInfs          = (1 << 2),

lib/Analysis/ConstantFolding.cpp

 
 /// Try to constant fold the specified instruction.
 /// If successful, the constant result is returned, if not, null is returned.
 /// Note that this fails if not all of the operands are constant.  Otherwise,
 /// this function can only fail when attempting to fold instructions like loads
 /// and stores, which have no constant expression form.
 Constant *llvm::ConstantFoldInstruction(Instruction *I, const DataLayout &DL,
                                         const TargetLibraryInfo *TLI) {
-  FastMathFlags FMF;
-
-  if (isa<FPMathOperator>(I))
-    FMF = I->getFastMathFlags();
-
   // Handle PHI nodes quickly here...
   if (PHINode *PN = dyn_cast<PHINode>(I)) {
     Constant *CommonValue = nullptr;
 
     for (Value *Incoming : PN->incoming_values()) {
       // If the incoming value is undef then skip it.  Note that while we could
       // skip the value if it is equal to the phi node itself we choose not to
       // because that would break the rule that constant folding only applies if
       // all operands are constants.
       if (isa<UndefValue>(Incoming))
         continue;
       // If the incoming value is not a constant, then give up.
       Constant *C = dyn_cast<Constant>(Incoming);
       if (!C)
         return nullptr;
       // Fold the PHI's operands.
       if (ConstantExpr *NewC = dyn_cast<ConstantExpr>(C))
-        C = ConstantFoldConstantExpression(NewC, DL, TLI, FMF);
+        C = ConstantFoldConstantExpression(NewC, DL, TLI);
       // If the incoming value is a different constant to
       // the one we saw previously, then give up.
       if (CommonValue && C != CommonValue)
         return nullptr;
       CommonValue = C;
     }
 
 
     // If we reach here, all incoming values are the same constant or undef.
     return CommonValue ? CommonValue : UndefValue::get(PN->getType());
   }
 
   // Scan the operand list, checking to see if they are all constants, if so,
   // hand off to ConstantFoldInstOperands.
   SmallVector<Constant*, 8> Ops;
   for (User::op_iterator i = I->op_begin(), e = I->op_end(); i != e; ++i) {
     Constant *Op = dyn_cast<Constant>(*i);
     if (!Op)
       return nullptr;  // All operands not constant!
 
     // Fold the Instruction's operands.
     if (ConstantExpr *NewCE = dyn_cast<ConstantExpr>(Op))
-      if (Constant *C = ConstantFoldConstantExpression(NewCE, DL, TLI, FMF))
+      if (Constant *C = ConstantFoldConstantExpression(NewCE, DL, TLI))
         Op = C;
 
     Ops.push_back(Op);
   }
 
   if (const CmpInst *CI = dyn_cast<CmpInst>(I))
     return ConstantFoldCompareInstOperands(CI->getPredicate(), Ops[0], Ops[1],
                                            DL, TLI);
Constant *llvm::ConstantFoldInstruction(Instruction *I, const DataLayout &DL,
   }
 
   if (ExtractValueInst *EVI = dyn_cast<ExtractValueInst>(I)) {
     return ConstantExpr::getExtractValue(
                                     cast<Constant>(EVI->getAggregateOperand()),
                                     EVI->getIndices());
   }
 
+  FastMathFlags FMF;
+  if (isa<FPMathOperator>(I))
+    FMF = I->getFastMathFlags();
   return ConstantFoldInstOperands(I->getOpcode(), I->getType(), Ops, DL, TLI,
                                   FMF);
 }
 
 static Constant *
 ConstantFoldConstantExpressionImpl(const ConstantExpr *CE, const DataLayout &DL,
                                    const TargetLibraryInfo *TLI,
                                    SmallPtrSetImpl<ConstantExpr *> &FoldedOps,
return ConstantFoldInstOperands(CE->getOpcode(), CE->getType(), Ops, DL, TLI,
                                   FMF);
 }
 
 /// Attempt to fold the constant expression
 /// using the specified DataLayout.  If successful, the constant result is
 /// result is returned, if not, null is returned.
 Constant *llvm::ConstantFoldConstantExpression(const ConstantExpr *CE,
                                                const DataLayout &DL,
-                                               const TargetLibraryInfo *TLI,
-                                               FastMathFlags FMF) {
+                                               const TargetLibraryInfo *TLI) {
   SmallPtrSet<ConstantExpr *, 4> FoldedOps;
-  return ConstantFoldConstantExpressionImpl(CE, DL, TLI, FoldedOps, FMF);
+  return ConstantFoldConstantExpressionImpl(CE, DL, TLI, FoldedOps,
+                                            CE->getFastMathFlags());
 }
 
 /// Attempt to constant fold an instruction with the
 /// specified opcode and operands.  If successful, the constant result is
 /// returned, if not, null is returned.  Note that this function can fail when
 /// attempting to fold instructions like loads and stores, which have no
 /// constant expression form.
 ///

lib/AsmParser/LLParser.cpp

bool LLParser::ParseValID(ValID &ID, PerFunctionState *PFS) {
   case lltok::kw_ashr: {
     bool NUW = false;
     bool NSW = false;
     bool Exact = false;
     unsigned Opc = Lex.getUIntVal();
     Constant *Val0, *Val1;
     Lex.Lex();
     LocTy ModifierLoc = Lex.getLoc();
+
+    FastMathFlags FMF;
+    if (Opc == Instruction::FAdd || Opc == Instruction::FSub ||
+        Opc == Instruction::FMul || Opc == Instruction::FDiv ||
+        Opc == Instruction::FRem)
+      FMF = EatFastMathFlagsIfPresent();
+
     if (Opc == Instruction::Add || Opc == Instruction::Sub ||
         Opc == Instruction::Mul || Opc == Instruction::Shl) {
       if (EatIfPresent(lltok::kw_nuw))
         NUW = true;
       if (EatIfPresent(lltok::kw_nsw)) {
         NSW = true;
         if (EatIfPresent(lltok::kw_nuw))
           NUW = true;
       }
     } else if (Opc == Instruction::SDiv || Opc == Instruction::UDiv ||
                Opc == Instruction::LShr || Opc == Instruction::AShr) {
       if (EatIfPresent(lltok::kw_exact))
         Exact = true;
     }
     if (ParseToken(lltok::lparen, "expected '(' in binary constantexpr") ||
         ParseGlobalTypeAndValue(Val0) ||
         ParseToken(lltok::comma, "expected comma in binary constantexpr") ||
         ParseGlobalTypeAndValue(Val1) ||
         ParseToken(lltok::rparen, "expected ')' in binary constantexpr"))
       return true;
     if (Val0->getType() != Val1->getType())
       return Error(ID.Loc, "operands of constexpr must have same type");
     if (!Val0->getType()->isIntOrIntVectorTy()) {
case Instruction::FRem:
         return Error(ID.Loc, "constexpr requires fp operands");
       break;
     default: llvm_unreachable("Unknown binary operator!");
     }
     unsigned Flags = 0;
     if (NUW)   Flags |= OverflowingBinaryOperator::NoUnsignedWrap;
     if (NSW)   Flags |= OverflowingBinaryOperator::NoSignedWrap;
     if (Exact) Flags |= PossiblyExactOperator::IsExact;
-    Constant *C = ConstantExpr::get(Opc, Val0, Val1, Flags);
+    Constant *C = ConstantExpr::get(Opc, Val0, Val1, Flags, nullptr, FMF);
     ID.ConstantVal = C;
     ID.Kind = ValID::t_Constant;
     return false;
   }
 
   // Logical Operations
   case lltok::kw_and:
   case lltok::kw_or:

lib/IR/AsmWriter.cpp

static void writeAtomicRMWOperation(raw_ostream &Out,
   case AtomicRMWInst::Max:  Out << " max"; break;
   case AtomicRMWInst::Min:  Out << " min"; break;
   case AtomicRMWInst::UMax: Out << " umax"; break;
   case AtomicRMWInst::UMin: Out << " umin"; break;
   }
 }
 
 static void WriteOptimizationInfo(raw_ostream &Out, const User *U) {
-  if (const FPMathOperator *FPO = dyn_cast<const FPMathOperator>(U)) {
+  FastMathFlags FMF;
+
+  if (const FPMathOperator *FPO = dyn_cast<const FPMathOperator>(U))
+    FMF = FPO->getFastMathFlags();
+  else if (const ConstantExpr *CE = dyn_cast<const ConstantExpr>(U))
+    FMF = CE->getFastMathFlags();
+
+  if (FMF.any()) {
     // Unsafe algebra implies all the others, no need to write them all out
-    if (FPO->hasUnsafeAlgebra())
+    if (FMF.unsafeAlgebra())
       Out << " fast";
     else {
-      if (FPO->hasNoNaNs())
+      if (FMF.noNaNs())
         Out << " nnan";
-      if (FPO->hasNoInfs())
+      if (FMF.noInfs())
         Out << " ninf";
-      if (FPO->hasNoSignedZeros())
+      if (FMF.noSignedZeros())
         Out << " nsz";
-      if (FPO->hasAllowReciprocal())
+      if (FMF.allowReciprocal())
         Out << " arcp";
-      if (FPO->hasNoExceptions())
+      if (FMF.noExceptions())
         Out << " nexc";
-      if (FPO->hasNoRounding())
+      if (FMF.noRounding())
         Out << " nrnd";
     }
   }
 
   if (const OverflowingBinaryOperator *OBO =
         dyn_cast<OverflowingBinaryOperator>(U)) {
     if (OBO->hasNoUnsignedWrap())
       Out << " nuw";

lib/IR/Constants.cpp

#endif
 
   if (Constant *FC = ConstantFoldBinaryInstruction(Opcode, C1, C2, FMF))
     return FC;          // Fold a few common cases.
 
   if (OnlyIfReducedTy == C1->getType())
     return nullptr;
 
   Constant *ArgVec[] = { C1, C2 };
-  ConstantExprKeyType Key(Opcode, ArgVec, 0, Flags);
+  ConstantExprKeyType Key(Opcode, ArgVec, FMF.Flags, Flags);
 
   LLVMContextImpl *pImpl = C1->getContext().pImpl;
   return pImpl->ExprConstants.getOrCreate(C1->getType(), Key);
 }
 
 Constant *ConstantExpr::get(unsigned Opcode, Constant *C1, Constant *C2,
                             FastMathFlags FMF) {
     return get(Opcode, C1, C2, 0, nullptr, FMF);
 }

lib/IR/ConstantsContext.h

class BinaryConstantExpr : public ConstantExpr {
   void anchor() override;
   void *operator new(size_t, unsigned) = delete;
 public:
   // allocate space for exactly two operands
   void *operator new(size_t s) {
     return User::operator new(s, 2);
   }
   BinaryConstantExpr(unsigned Opcode, Constant *C1, Constant *C2,
-                     unsigned Flags)
-    : ConstantExpr(C1->getType(), Opcode, &Op<0>(), 2) {
+                     unsigned Flags, FastMathFlags FMF)
+    : ConstantExpr(C1->getType(), Opcode, &Op<0>(), 2, FMF) {
     Op<0>() = C1;
     Op<1>() = C2;
     SubclassOptionalData = Flags;
   }
   /// Transparently provide more efficient getOperand methods.
   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
 };
 
return new InlineAsm(FTy, AsmString, Constraints, HasSideEffects,
                          IsAlignStack, AsmDialect);
   }
 };
 
 struct ConstantExprKeyType {
   uint8_t Opcode;
   uint8_t SubclassOptionalData;
   uint16_t SubclassData;
   ArrayRef<Constant *> Ops;
   ArrayRef<unsigned> Indexes;
   Type *ExplicitTy;
 
   ConstantExprKeyType(unsigned Opcode, ArrayRef<Constant *> Ops,
                       unsigned short SubclassData = 0,
                       unsigned short SubclassOptionalData = 0,
                       ArrayRef<unsigned> Indexes = None,
                       Type *ExplicitTy = nullptr)
       : Opcode(Opcode), SubclassOptionalData(SubclassOptionalData),
         SubclassData(SubclassData), Ops(Ops), Indexes(Indexes),
         ExplicitTy(ExplicitTy) {}
   ConstantExprKeyType(ArrayRef<Constant *> Operands, const ConstantExpr *CE)
       : Opcode(CE->getOpcode()),
         SubclassOptionalData(CE->getRawSubclassOptionalData()),
-        SubclassData(CE->isCompare() ? CE->getPredicate() : 0), Ops(Operands),
+        SubclassData(CE->isCompare() ?
+                     CE->getPredicate() : CE->getFastMathFlags().Flags),
+        Ops(Operands),
         Indexes(CE->hasIndices() ? CE->getIndices() : ArrayRef<unsigned>()) {}
   ConstantExprKeyType(const ConstantExpr *CE,
                       SmallVectorImpl<Constant *> &Storage)
       : Opcode(CE->getOpcode()),
         SubclassOptionalData(CE->getRawSubclassOptionalData()),
-        SubclassData(CE->isCompare() ? CE->getPredicate() : 0),
+        SubclassData(CE->isCompare() ?
+                     CE->getPredicate() : CE->getFastMathFlags().Flags),
         Indexes(CE->hasIndices() ? CE->getIndices() : ArrayRef<unsigned>()) {
     assert(Storage.empty() && "Expected empty storage");
     for (unsigned I = 0, E = CE->getNumOperands(); I != E; ++I)
       Storage.push_back(CE->getOperand(I));
     Ops = Storage;
   }
 
   bool operator==(const ConstantExprKeyType &X) const {
     return Opcode == X.Opcode && SubclassData == X.SubclassData &&
            SubclassOptionalData == X.SubclassOptionalData && Ops == X.Ops &&
            Indexes == X.Indexes;
   }
 
   bool operator==(const ConstantExpr *CE) const {
     if (Opcode != CE->getOpcode())
       return false;
     if (SubclassOptionalData != CE->getRawSubclassOptionalData())
       return false;
     if (Ops.size() != CE->getNumOperands())
       return false;
-    if (SubclassData != (CE->isCompare() ? CE->getPredicate() : 0))
+    if (SubclassData != (CE->isCompare() ?
+                         CE->getPredicate() : CE->getFastMathFlags().Flags))
       return false;
     for (unsigned I = 0, E = Ops.size(); I != E; ++I)
       if (Ops[I] != CE->getOperand(I))
         return false;
     if (Indexes != (CE->hasIndices() ? CE->getIndices() : ArrayRef<unsigned>()))
       return false;
     return true;
   }
 
   unsigned getHash() const {
     return hash_combine(Opcode, SubclassOptionalData, SubclassData,
                         hash_combine_range(Ops.begin(), Ops.end()),
                         hash_combine_range(Indexes.begin(), Indexes.end()));
   }
 
   typedef ConstantInfo<ConstantExpr>::TypeClass TypeClass;
   ConstantExpr *create(TypeClass *Ty) const {
     switch (Opcode) {
     default:
       if (Instruction::isCast(Opcode))
         return new UnaryConstantExpr(Opcode, Ops[0], Ty);
       if ((Opcode >= Instruction::BinaryOpsBegin &&
            Opcode < Instruction::BinaryOpsEnd))
         return new BinaryConstantExpr(Opcode, Ops[0], Ops[1],
-                                      SubclassOptionalData);
+                                      SubclassOptionalData,
+                                      FastMathFlags(SubclassData));
       llvm_unreachable("Invalid ConstantExpr!");
     case Instruction::Select:
       return new SelectConstantExpr(Ops[0], Ops[1], Ops[2]);
     case Instruction::ExtractElement:
       return new ExtractElementConstantExpr(Ops[0], Ops[1]);
     case Instruction::InsertElement:
       return new InsertElementConstantExpr(Ops[0], Ops[1], Ops[2]);
     case Instruction::ShuffleVector:

test/Other/fpenv-constant-fold.ll

 ; InstCombine is used just for its calls to constant folder.
 ; RUN: opt -S -instcombine -o - < %s | FileCheck %s
 
 ; Target independent constant folder should not fold floating-point operations
 ; that have constant expression as their operands when FEnv access is requested
 ; and such folding leads to differences in observable effects at runtime.
 
 define double @do-not-fold-fadd-that-can-trap() {
 ; CHECK-LABEL: @do-not-fold-fadd-that-can-trap
-; CHECK: fadd nrnd double 1.000000e+308, 1.000000e+308
+; CHECK: ret double fadd nrnd (double 1.000000e+308, double 1.000000e+308)
 entry:
-  %val = fadd nrnd double 1.000000e+308, 1.000000e+308
-  ret double %val
+  ret double fadd nrnd (double 1.000000e+308, double 1.000000e+308)
 }
 
 define double @do-not-fold-fsub-that-can-trap() {
 ; CHECK-LABEL: @do-not-fold-fsub-that-can-trap
-; CHECK: fsub nrnd double 1.000000e-308, 1.000000e+308
+; CHECK: ret double fsub nrnd (double 1.000000e-308, double 1.000000e+308)
 entry:
-  %val = fsub nrnd double 1.000000e-308, 1.000000e+308
-  ret double %val
+  ret double fsub nrnd (double 1.000000e-308, double 1.000000e+308)
 }
 
 define double @do-not-fold-fmul-that-can-trap() {
 ; CHECK-LABEL: @do-not-fold-fmul-that-can-trap
-; CHECK: fmul nrnd double 1.000000e+300, 1.000000e+300
+; CHECK: ret double fmul nrnd (double 1.000000e+300, double 1.000000e+300)
 entry:
-  %val = fmul nrnd double 1.000000e+300, 1.000000e+300
-  ret double %val
+  ret double fmul nrnd (double 1.000000e+300, double 1.000000e+300)
 }
 
 define double @do-not-fold-fdiv-that-can-trap() {
 ; CHECK-LABEL: @do-not-fold-fdiv-that-can-trap
-; CHECK: fdiv nrnd double 1.000000e+300, 1.000000e-300
+; CHECK: ret double fdiv nrnd (double 1.000000e+300, double 1.000000e-300)
 entry:
-  %val = fdiv nrnd double 1.000000e+300, 1.000000e-300
-  ret double %val
+  ret double fdiv nrnd (double 1.000000e+300, double 1.000000e-300)
 }
 
 define double @do-not-fold-frem-that-can-trap() {
 ; CHECK-LABEL: @do-not-fold-frem-that-can-trap
-; CHECK: frem nrnd double 1.000000e+300, 1.000000e-300
+; CHECK: ret double frem nrnd (double 1.000000e+300, double 1.000000e-300)
 entry:
-  %val = frem nrnd double 1.000000e+300, 1.000000e-300
-  ret double %val
+  ret double frem nrnd (double 1.000000e+300, double 1.000000e-300)
 }
 
 define double @do-not-fold-fadd-because-of-rounding() {
 ; CHECK-LABEL: @do-not-fold-fadd-because-of-rounding
-; CHECK: fadd nexc double 0.101, 0.93
+; CHECK: ret double fadd nexc (double 1.010000e-01, double 9.300000e-01)
 entry:
-  %val = fadd nexc double 0.101, 0.93
-  ret double %val
+  ret double fadd nexc (double 0.101, double 0.93)
 }
 
 define double @do-not-fold-fsub-because-of-rounding() {
 ; CHECK-LABEL: @do-not-fold-fsub-because-of-rounding
-; CHECK: fsub nexc double 0.101, 0.93
+; CHECK: ret double fsub nexc (double 1.010000e-01, double 9.300000e-01)
 entry:
-  %val = fsub nexc double 0.101, 0.93
-  ret double %val
+  ret double fsub nexc (double 0.101, double 0.93)
 }
 
 define double @do-not-fold-fmul-because-of-rounding() {
 ; CHECK-LABEL: @do-not-fold-fmul-because-of-rounding
-; CHECK: fmul nexc double 0.101, 0.93
+; CHECK: ret double fmul nexc (double 1.010000e-01, double 9.300000e-01)
 entry:
-  %val = fmul nexc double 0.101, 0.93
-  ret double %val
+  ret double fmul nexc (double 0.101, double 0.93)
 }
 
 define double @do-not-fold-fdiv-because-of-rounding() {
 ; CHECK-LABEL: @do-not-fold-fdiv-because-of-rounding
-; CHECK: fdiv nexc double 0.101, 0.93
+; CHECK: ret double fdiv nexc (double 1.010000e-01, double 9.300000e-01)
 entry:
-  %val = fdiv nexc double 0.101, 0.93
-  ret double %val
+  ret double fdiv nexc (double 0.101, double 0.93)
 }
 
 ; "frem" instruction falls into the same category, but none of tried test-cases
 ; could raised inexact exception.
 
 define double @fold-fadd-that-cant-trap() {
 ; CHECK-LABEL: @fold-fadd-that-cant-trap
 ; CHECK-NOT: fadd
 entry:
-  %val = fadd double 1.0, 1.0
-  ret double %val
+  ret double fadd (double 1.0, double 1.0)
 }
 
 define double @fold-fsub-that-cant-trap() {
 ; CHECK-LABEL: @fold-fsub-that-cant-trap
 ; CHECK-NOT: fsub
 entry:
-  %val = fsub double 1.0, 1.0
-  ret double %val
+  ret double fsub (double 1.0, double 1.0)
 }
 
 define double @fold-fmul-that-cant-trap() {
 ; CHECK-LABEL: @fold-fmul-that-cant-trap
 ; CHECK-NOT: fmul
 entry:
-  %val = fmul double 1.0, 1.0
-  ret double %val
+  ret double fmul (double 1.0, double 1.0)
 }
 
 define double @fold-fdiv-that-cant-trap() {
 ; CHECK-LABEL: @fold-fdiv-that-cant-trap
 ; CHECK-NOT: fdiv
 entry:
-  %val = fdiv double 1.0, 1.0
-  ret double %val
+  ret double fdiv (double 1.0, double 1.0)
 }
 
 define double @fold-frem-that-cant-trap() {
 ; CHECK-LABEL: @fold-frem-that-cant-trap
 ; CHECK-NOT: frem
 entry:
-  %val = frem double 1.0, 1.0
-  ret double %val
+  ret double frem (double 1.0, double 1.0)
 }
 
 define double @correcly-handle-nested-expressions() {
 ; CHECK-LABEL: @correcly-handle-nested-expressions
-; CHECK: fmul nrnd double 1.000000e+300, 1.000000e+300
+; CHECK: ret double fdiv nrnd (double fmul nrnd (double 1.000000e+300, double 1.000000e+300), double 1.000000e+300)
 entry:
-  %val1 = fmul nrnd double 1.000000e+300, 1.000000e+300
-  %val2 = fdiv nrnd double %val1, 1.000000e+300
-  ret double %val2
+  ret double fdiv nrnd (double fmul nrnd (double 1.000000e+300, double 1.000000e+300), double 1.000000e+300)
 }

test/Transforms/EarlyCSE/fpenv.ll

+; %val.true and %val.false should not be moved inside phi-node as constant
+; expressions as such transformation looses fast-math flags.
+; RUN: opt < %s -S -early-cse | FileCheck %s
+
+define double @do-not-fold-on-turning-into-constexpr(double %x) {
+; CHECK-LABEL: @do-not-fold-on-turning-into-constexpr(
+; CHECK: fmul
+entry:
+  %cmp = fcmp oeq double %x, 0.000000e+00
+  br i1 %cmp, label %cond.true, label %cond.false
+
+cond.true:                                        ; preds = %entry
+  %val.true = fmul nrnd double 1.000000e+300, 1.000000e+300
+  br label %cond.end
+
+cond.false:                                       ; preds = %entry
+  %val.false = fmul nrnd double 1.000000e-300, 1.000000e-300
+  br label %cond.end
+
+cond.end:                                         ; preds = %cond.false, %cond.true
+  %cond = phi double [ %val.true, %cond.true ], [ %val.false, %cond.false ]
+  ret double %cond
+}