Added RAII object for authomatic restore of fp state

[sepavloff]

Summary

Class IRBuilderBase has now RAII class that helps to restore floating
point options, including default rounding and exceptions modes.

[kpn]

llvm/include/llvm/IR/IntrinsicInst.h

220

What does this change give us? Having rmDynamic == 0 means that if a bug causes it to be zero initialized we get the most conservative behavior from the compiler. What's the tradeoff? And where is this change tested?

[rjmccall]

Looks good to me; I express no opinion about Kevin's question.

[sepavloff]

llvm/include/llvm/IR/IntrinsicInst.h

220

The intention was to have zero value as the default for RoundingMode, which is used when no constrained operation required. ExceptionBehavior does this: ebIgnore means no special exception behavior is requested. In this case non-zero value indicates that we have to process operation in a special way.

This change is a matter of convenience, it isn't strictly necessary for this patch. If you think it shouldn't go to sources, i'll remove it.

[kpn]

llvm/include/llvm/IR/IntrinsicInst.h

220

Yeah, we're inconsistent. I'd like to resolve that inconsistency another day. Please remove this change.

[sepavloff]

Updated patch

[sepavloff]

llvm/include/llvm/IR/IntrinsicInst.h

220

OK, remove it.

[kpn]

John already gave his go-ahead, and I'm adding my LGTM.

llvm/include/llvm/IR/IRBuilder.h

 protected:
   BasicBlock *BB;
   BasicBlock::iterator InsertPt;
   LLVMContext &Context;
 
   MDNode *DefaultFPMathTag;
   FastMathFlags FMF;
 
+  /// If set, builder creates constrained floating point operations.
   bool IsFPConstrained;
+
+  /// Exception behavior used by default for constrained floating point
+  /// operations.
   ConstrainedFPIntrinsic::ExceptionBehavior DefaultConstrainedExcept;
+
+  /// Rounding mode used by default for constrained floating point operations.
   ConstrainedFPIntrinsic::RoundingMode DefaultConstrainedRounding;
 
   ArrayRef<OperandBundleDef> DefaultOperandBundles;
 
 public:
   IRBuilderBase(LLVMContext &context, MDNode *FPMathTag = nullptr,
                 ArrayRef<OperandBundleDef> OpBundles = None)
       : Context(context), DefaultFPMathTag(FPMathTag), IsFPConstrained(false),
public:
     FastMathFlagGuard &operator=(const FastMathFlagGuard &) = delete;
 
     ~FastMathFlagGuard() {
       Builder.FMF = FMF;
       Builder.DefaultFPMathTag = FPMathTag;
     }
   };
 
+  // RAII object that stores constrained floating point settings and
+  // restores them when the object is destroyed.
+  class FloatingPointStateSaver {
+    IRBuilderBase &Builder;
+    bool IsFPConstrainted;
+    ConstrainedFPIntrinsic::ExceptionBehavior DefaultConstrainedExcept;
+    ConstrainedFPIntrinsic::RoundingMode DefaultConstrainedRounding;
+
+  public:
+    FloatingPointStateSaver(IRBuilderBase &Builder)
+        : Builder(Builder),
+          IsFPConstrainted(Builder.getIsFPConstrained()),
+          DefaultConstrainedExcept(Builder.getDefaultConstrainedExcept()),
+          DefaultConstrainedRounding(Builder.getDefaultConstrainedRounding()) {
+    }
+    FloatingPointStateSaver(IRBuilderBase &Builder, bool NewIsFPConstrained,
+        ConstrainedFPIntrinsic::ExceptionBehavior NewDefaultConstrainedExcept,
+        ConstrainedFPIntrinsic::RoundingMode NewDefaultConstrainedRounding)
+        : FloatingPointStateSaver(Builder) {
+      Builder.setIsFPConstrained(NewIsFPConstrained);
+      Builder.setDefaultConstrainedExcept(NewDefaultConstrainedExcept);
+      Builder.setDefaultConstrainedRounding(NewDefaultConstrainedRounding);
+    }
+    ~FloatingPointStateSaver() {
+      Builder.setDefaultConstrainedRounding(DefaultConstrainedRounding);
+      Builder.setDefaultConstrainedExcept(DefaultConstrainedExcept);
+      Builder.setIsFPConstrained(IsFPConstrainted);
+    }
+  };
+
   //===--------------------------------------------------------------------===//
   // Miscellaneous creation methods.
   //===--------------------------------------------------------------------===//
 
   /// Make a new global variable with initializer type i8*
   ///
   /// Make a new global variable with an initializer that has array of i8 type
   /// filled in with the null terminated string value specified.  The new global

llvm/include/llvm/IR/IntrinsicInst.h

namespace llvm {
 
   /// This is the common base class for constrained floating point intrinsics.
   class ConstrainedFPIntrinsic : public IntrinsicInst {
   public:
     /// Specifies the rounding mode to be assumed. This is only used when
     /// when constrained floating point is enabled. See the LLVM Language
     /// Reference Manual for details.
     enum RoundingMode : uint8_t {
-      rmDynamic,         ///< This corresponds to "fpround.dynamic".
       rmToNearest,       ///< This corresponds to "fpround.tonearest".
       rmDownward,        ///< This corresponds to "fpround.downward".
       rmUpward,          ///< This corresponds to "fpround.upward".
-      rmTowardZero       ///< This corresponds to "fpround.tozero".
+      rmTowardZero,      ///< This corresponds to "fpround.tozero".
+      rmDynamic          ///< This corresponds to "fpround.dynamic".
     };
 
     /// Specifies the required exception behavior. This is only used when
     /// when constrained floating point is used. See the LLVM Language
     /// Reference Manual for details.
     enum ExceptionBehavior : uint8_t {
       ebIgnore,          ///< This corresponds to "fpexcept.ignore".
       ebMayTrap,         ///< This corresponds to "fpexcept.maytrap".
       ebStrict           ///< This corresponds to "fpexcept.strict".