[RFC] Alternate implementation of D53157 IRBuilder for Constrained FP using enumeration vs MDNode and add support for fp-model and fp-speculation language options

[mibintc]

Summary

This is part of RFC to support language options -fp-model and -fp-speculation.

This makes a small modification to D53157 to pass some arguments using an enumeration type instead of MDNode.

In addition I created the FPState.h file which declares 2 enumeration types corresponding to the option settings. I want to put them into llvm so it will be available not only to clang but to other language front ends that might want to offer floating point control using option settings. The language options are combined using certain semantics into IRBuilder settings. There's a member function in FPState.h that does this.

There's a clang patch that goes along with this patch, see https://reviews.llvm.org/D62731

Here's the RFC pasted from email to llvm-dev and clang-dev:
Intel would like to contribute a patch to implement support for these Intel- and Microsoft -fp options:
-fp-model=[precise|strict|fast|except[-]] and -fp-speculation=[fast|strict|safe]

This contribution would dovetail with the llvm patch "Teach the IRBuilder about constrained fadd and friends" which is under review here, https://reviews.llvm.org/D53157/new/. I have a patch ready to review that works with D53157. The motivation for providing these is that having a single option to control most basic FP options is better and easier to understand for users.

The option settings -fp-model=[precise|strict|fast|except] are supported by both ICC and CL. The fp-speculation option is supported only by ICC. The CL and ICC -fp-model option is documented on these pages:

https://docs.microsoft.com/en-us/cpp/build/reference/fp-specify-floating-point-behavior?view=vs-2019
https://software.intel.com/en-us/cpp-compiler-developer-guide-and-reference-fp-model-fp

Currently, clang's default behavior corresponds to -fp-model=precise. Clang/llvm support for -fp-model=[strict|except] is being developed in the D53157 patch, and there is current llvm support for the fast settings by using the fast math flags llvm::FastMathFlags. Note: the clang-cl wrapper to support Microsoft options has simplified support for these options by mapping /fp-model=except to ftrapping-math, fp-mdel=fast to ffast-math, fp-model=precise and fp-model=strict to fno-fast-math (see clang/Driver/CLCompatOptions.td).

According to the online options documentation, you can combine except[-] with [precise|strict|fast], but combining both fast and except is not a valid setting (the Driver will emit an error).

precise - Disables optimizations that are not value-safe on floating-point data, although FP contraction is enabled.
strict - Enables precise and except, disables contractions (FMA), and enables pragma stdc fenv_access.   
fast - Equivalent to -ffast-math
except/except- - Determines whether strict floating-point exception semantics are honored.

The ICC option -fp-speculation is described here,

https://software.intel.com/en-us/cpp-compiler-developer-guide-and-reference-fp-speculation-qfp-speculation

These are the meanings of the fp-speculation settings:

fast - Tells the compiler to speculate on floating-point operations.  This is equivalent to “fpexcept.ignore” in the constrained intrinsics review D53157.
strict - Tells the compiler to disable speculation on floating-point operations.  This is equivalent to “fpexcept.strict” in the constrained intrinsics review D53157.
safe - Tells the compiler to disable speculation if there is a possibility that the speculation may cause a floating-point exception.  This is equivalent to “fpexcept.maytrap” in the constrained intrinsics review D53157.

[lebedev.ri]

New files are missing header blurbs; the precise explanation of what is what is missing (should be in doc/, not patch description)

include/llvm/IR/FPState.h

9–31

All this needs comments, and possibly better names.
FPM_Off,etc is very non-self-explanatory.

[kpn]

Incorporating feedback from D53157 is probably a good idea. Looks like that hasn't been done yet here completely.

[kpn]

include/llvm/IR/FPState.h

9–31

Shouldn't there be an "accept default" value? That way CreateConstrainedFAdd()/CreateConstrainedBinOp() can accept enumerations and avoid having front ends having to deal with MDNode*.

[mibintc]

include/llvm/IR/FPState.h

9–31

By "off" I just meant, not specified, and therefore the default setting would prevail. If you prefer "default" instead of "off" that's fine by me.

include/llvm/IR/IRBuilder.h

247

In order to match the code that @kpn wrote, I should set DefaultConstrainedExcept = strict instead of just leaving it off.

261

to match @kpn patch, I should set DefaultConstrainedRounding to dynamic instead of leaving it off

[mibintc]

I'm abandoning this patch in deference to @kpn 's patch under review D53157

include/llvm/IR/FPState.h

+#ifndef LLVM_FPSTATE_H
+#define LLVM_FPSTATE_H
+namespace llvm {
+
+class MDNode;
+class IRBuilderBase;
+class FPState {
+public:
+  enum FPModelKind {
+    FPM_Off,
+    FPM_Precise,
+    FPM_Strict,
+    FPM_Fast
+  };
+
+  enum FPModelExceptKind {
+    FPME_Off,
+    FPME_Except,
+    FPME_NoExcept
+  };
+
+  enum FPSpeculationKind {
+    FPS_Off,
+    FPS_Fast,
+    FPS_Strict,
+    FPS_Safe
+  };
+
+  enum ConstrainedExceptKind {CE_Off, CE_Strict, CE_Ignore, CE_MayTrap};
+  enum ConstrainedRoundingKind {CR_Off, CR_Dynamic, CR_ToNearest, CR_Downward,
+                                CR_Upward, CR_ToZero};
+
+private:
+  IRBuilderBase &Builder;
+  FPModelKind FPM;
+  FPModelExceptKind FPME;
+  FPSpeculationKind FPS;
+public:
+  FPState(IRBuilderBase &B);
+  // function to update builder.
+  void updateBuilder(FPModelKind fpModel,
+                     FPModelExceptKind fpModelExcept,
+                     FPSpeculationKind fpSpeculation);
+};
+} // end namespace llvm
+
+#endif  // LLVM_FPSTATE_H

include/llvm/IR/IRBuilder.h

 #include "llvm/ADT/Twine.h"
 #include "llvm/IR/BasicBlock.h"
 #include "llvm/IR/Constant.h"
 #include "llvm/IR/ConstantFolder.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/DebugLoc.h"
 #include "llvm/IR/DerivedTypes.h"
+#include "llvm/IR/FPState.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/GlobalVariable.h"
 #include "llvm/IR/InstrTypes.h"
 #include "llvm/IR/Instruction.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/Intrinsics.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
void InsertHelper(Instruction *I, const Twine &Name,
     IRBuilderDefaultInserter::InsertHelper(I, Name, BB, InsertPt);
     Callback(I);
   }
 };
 
 /// Common base class shared among various IRBuilders.
 class IRBuilderBase {
   DebugLoc CurDbgLocation;
-
 protected:
   BasicBlock *BB;
   BasicBlock::iterator InsertPt;
   LLVMContext &Context;
 
   MDNode *DefaultFPMathTag;
   FastMathFlags FMF;
 
+  bool IsFPConstrained;
+  FPState::ConstrainedExceptKind DefaultConstrainedExcept;
+  FPState::ConstrainedRoundingKind DefaultConstrainedRounding;
+
   ArrayRef<OperandBundleDef> DefaultOperandBundles;
 
 public:
   IRBuilderBase(LLVMContext &context, MDNode *FPMathTag = nullptr,
                 ArrayRef<OperandBundleDef> OpBundles = None)
       : Context(context), DefaultFPMathTag(FPMathTag),
+        IsFPConstrained(false), DefaultConstrainedExcept(FPState::CE_Off),
+        DefaultConstrainedRounding(FPState::CR_Off),
         DefaultOperandBundles(OpBundles) {
     ClearInsertionPoint();
   }
 
   //===--------------------------------------------------------------------===//
   // Builder configuration methods
   //===--------------------------------------------------------------------===//
 
public:
   void clearFastMathFlags() { FMF.clear(); }
 
   /// Set the floating point math metadata to be used.
   void setDefaultFPMathTag(MDNode *FPMathTag) { DefaultFPMathTag = FPMathTag; }
 
   /// Set the fast-math flags to be used with generated fp-math operators
   void setFastMathFlags(FastMathFlags NewFMF) { FMF = NewFMF; }
 
+  /// Enable/Disable use of constrained floating point math
+  void setIsConstrainedFP(bool IsCon) { IsFPConstrained = IsCon; }
+
+  /// Disable use of constrained floating point math
+  void clearIsConstrainedFP() { setIsConstrainedFP(false); }
+
+  /// Set the exception handling to be used with constrained floating point
+  void setDefaultConstrainedExcept(FPState::ConstrainedExceptKind NewExcept) {
+    DefaultConstrainedExcept = NewExcept;
+  }
+
+  /// Set the rounding mode handling to be used with constrained floating point
+  void
+  setDefaultConstrainedRounding(FPState::ConstrainedRoundingKind NewRounding) {
+    DefaultConstrainedRounding = NewRounding;
+  }
+
+  /// Get the exception handling used with constrained floating point
+  MDNode *getDefaultConstrainedExcept() {
+    switch (DefaultConstrainedExcept) {
+    case FPState::CE_Off:
+    case FPState::CE_Strict:
+        return MDNode::get(Context, MDString::get(Context, "fpexcept.strict"));
+    case FPState::CE_Ignore:
+        return MDNode::get(Context, MDString::get(Context, "fpexcept.ignore"));
+    case FPState::CE_MayTrap:
+        return MDNode::get(Context, MDString::get(Context, "fpexcept.maytrap"));
+    default: llvm_unreachable("Invalid constrained except kind");
+    }
+  }
+
+  /// Get the rounding mode handling used with constrained floating point
+  MDNode *getDefaultConstrainedRounding() {
+    switch (DefaultConstrainedRounding) {
+    case FPState::CR_Off:
+    case FPState::CR_Dynamic:
+        return MDNode::get(Context, MDString::get(Context, "round.dynamic"));
+    case FPState::CR_ToNearest:
+        return MDNode::get(Context, MDString::get(Context, "round.tonearest"));
+    case FPState::CR_Downward:
+        return MDNode::get(Context, MDString::get(Context, "round.downward"));
+    case FPState::CR_Upward:
+        return MDNode::get(Context, MDString::get(Context, "round.upward"));
+    case FPState::CR_ToZero:
+        return MDNode::get(Context, MDString::get(Context, "round.tozero"));
+    default: llvm_unreachable("Invalid constrained rounding kind");
+    }
+  }
+
   //===--------------------------------------------------------------------===//
   // RAII helpers.
   //===--------------------------------------------------------------------===//
 
   // RAII object that stores the current insertion point and restores it
   // when the object is destroyed. This includes the debug location.
   class InsertPointGuard {
     IRBuilderBase &Builder;
private:
 
   Value *foldConstant(Instruction::BinaryOps Opc, Value *L,
                       Value *R, const Twine &Name) const {
     auto *LC = dyn_cast<Constant>(L);
     auto *RC = dyn_cast<Constant>(R);
     return (LC && RC) ? Insert(Folder.CreateBinOp(Opc, LC, RC), Name) : nullptr;
   }
 
+  Value *getConstrainedRounding(MDNode *RoundingMD) {
+    MDString *Rounding;
+
+    if (!RoundingMD)
+      RoundingMD = getDefaultConstrainedRounding();
+
+    Rounding = cast<MDString>(RoundingMD->getOperand(0));
+
+    return MetadataAsValue::get(Context, Rounding);
+  }
+
+  Value *getConstrainedExcept(MDNode *ExceptMD) {
+    MDString *Except;
+
+    if (!ExceptMD)
+      ExceptMD = getDefaultConstrainedExcept();
+
+    Except = cast<MDString>(ExceptMD->getOperand(0));
+
+    return MetadataAsValue::get(Context, Except);
+  }
+
 public:
   Value *CreateAdd(Value *LHS, Value *RHS, const Twine &Name = "",
                    bool HasNUW = false, bool HasNSW = false) {
     if (auto *LC = dyn_cast<Constant>(LHS))
       if (auto *RC = dyn_cast<Constant>(RHS))
         return Insert(Folder.CreateAdd(LC, RC, HasNUW, HasNSW), Name);
     return CreateInsertNUWNSWBinOp(Instruction::Add, LHS, RHS, Name,
                                    HasNUW, HasNSW);
public:
   }
 
   Value *CreateXor(Value *LHS, uint64_t RHS, const Twine &Name = "") {
     return CreateXor(LHS, ConstantInt::get(LHS->getType(), RHS), Name);
   }
 
   Value *CreateFAdd(Value *L, Value *R, const Twine &Name = "",
                     MDNode *FPMD = nullptr) {
+    if (IsFPConstrained)
+      return CreateConstrainedFAdd(L, R, nullptr, Name, nullptr, nullptr);
+
     if (Value *V = foldConstant(Instruction::FAdd, L, R, Name)) return V;
     Instruction *I = setFPAttrs(BinaryOperator::CreateFAdd(L, R), FPMD, FMF);
     return Insert(I, Name);
   }
 
   /// Copy fast-math-flags from an instruction rather than using the builder's
   /// default FMF.
   Value *CreateFAddFMF(Value *L, Value *R, Instruction *FMFSource,
                        const Twine &Name = "") {
+    if (IsFPConstrained)
+      return CreateConstrainedFAdd(L, R, FMFSource, Name, nullptr, nullptr);
+
     if (Value *V = foldConstant(Instruction::FAdd, L, R, Name)) return V;
     Instruction *I = setFPAttrs(BinaryOperator::CreateFAdd(L, R), nullptr,
                                 FMFSource->getFastMathFlags());
     return Insert(I, Name);
   }
 
+  CallInst *CreateConstrainedFAdd(Value *L, Value *R,
+                                  Instruction *FMFSource = nullptr,                                               const Twine &Name = "",
+                                  MDNode *RoundingMD = nullptr,
+                                  MDNode *ExceptMD = nullptr) {
+
+    Value *Rounding = getConstrainedRounding(RoundingMD);
+    Value *Except = getConstrainedExcept(ExceptMD);
+
+    return CreateIntrinsic(Intrinsic::experimental_constrained_fadd,
+                           { L->getType() },
+                           { L, R, Rounding, Except },
+                           FMFSource, Name);
+  }
+
   Value *CreateFSub(Value *L, Value *R, const Twine &Name = "",
                     MDNode *FPMD = nullptr) {
+    if (IsFPConstrained)
+      return CreateConstrainedFSub(L, R, nullptr, Name, nullptr, nullptr);
+
     if (Value *V = foldConstant(Instruction::FSub, L, R, Name)) return V;
     Instruction *I = setFPAttrs(BinaryOperator::CreateFSub(L, R), FPMD, FMF);
     return Insert(I, Name);
   }
 
   /// Copy fast-math-flags from an instruction rather than using the builder's
   /// default FMF.
   Value *CreateFSubFMF(Value *L, Value *R, Instruction *FMFSource,
                        const Twine &Name = "") {
+    if (IsFPConstrained)
+      return CreateConstrainedFSub(L, R, FMFSource, Name, nullptr, nullptr);
+
     if (Value *V = foldConstant(Instruction::FSub, L, R, Name)) return V;
     Instruction *I = setFPAttrs(BinaryOperator::CreateFSub(L, R), nullptr,
                                 FMFSource->getFastMathFlags());
     return Insert(I, Name);
   }
 
+  CallInst *CreateConstrainedFSub(Value *L, Value *R,
+                                  Instruction *FMFSource = nullptr,
+                                  const Twine &Name = "",
+                                  MDNode *RoundingMD = nullptr,
+                                  MDNode *ExceptMD = nullptr) {
+
+    Value *Rounding = getConstrainedRounding(RoundingMD);
+    Value *Except = getConstrainedExcept(ExceptMD);
+
+    return CreateIntrinsic(Intrinsic::experimental_constrained_fsub,
+                           { L->getType() },
+                           { L, R, Rounding, Except },
+                           FMFSource, Name);
+  }
+
   Value *CreateFMul(Value *L, Value *R, const Twine &Name = "",
                     MDNode *FPMD = nullptr) {
+    if (IsFPConstrained)
+      return CreateConstrainedFMul(L, R, nullptr, Name, nullptr, nullptr);
+
     if (Value *V = foldConstant(Instruction::FMul, L, R, Name)) return V;
     Instruction *I = setFPAttrs(BinaryOperator::CreateFMul(L, R), FPMD, FMF);
     return Insert(I, Name);
   }
 
   /// Copy fast-math-flags from an instruction rather than using the builder's
   /// default FMF.
   Value *CreateFMulFMF(Value *L, Value *R, Instruction *FMFSource,
                        const Twine &Name = "") {
+    if (IsFPConstrained)
+      return CreateConstrainedFMul(L, R, FMFSource, Name, nullptr, nullptr);
+
     if (Value *V = foldConstant(Instruction::FMul, L, R, Name)) return V;
     Instruction *I = setFPAttrs(BinaryOperator::CreateFMul(L, R), nullptr,
                                 FMFSource->getFastMathFlags());
     return Insert(I, Name);
   }
 
+  CallInst *CreateConstrainedFMul(Value *L, Value *R,
+                                  Instruction *FMFSource = nullptr,
+                                  const Twine &Name = "",
+                                  MDNode *RoundingMD = nullptr,
+                                  MDNode *ExceptMD = nullptr) {
+
+    Value *Rounding = getConstrainedRounding(RoundingMD);
+    Value *Except = getConstrainedExcept(ExceptMD);
+
+    return CreateIntrinsic(Intrinsic::experimental_constrained_fmul,
+                           { L->getType() },
+                           { L, R, Rounding, Except },
+                           FMFSource, Name);
+  }
+
   Value *CreateFDiv(Value *L, Value *R, const Twine &Name = "",
                     MDNode *FPMD = nullptr) {
+    if (IsFPConstrained)
+      return CreateConstrainedFDiv(L, R, nullptr, Name, nullptr, nullptr);
+
     if (Value *V = foldConstant(Instruction::FDiv, L, R, Name)) return V;
     Instruction *I = setFPAttrs(BinaryOperator::CreateFDiv(L, R), FPMD, FMF);
     return Insert(I, Name);
   }
 
   /// Copy fast-math-flags from an instruction rather than using the builder's
   /// default FMF.
   Value *CreateFDivFMF(Value *L, Value *R, Instruction *FMFSource,
                        const Twine &Name = "") {
+    if (IsFPConstrained)
+      return CreateConstrainedFDiv(L, R, FMFSource, Name, nullptr, nullptr);
+
     if (Value *V = foldConstant(Instruction::FDiv, L, R, Name)) return V;
     Instruction *I = setFPAttrs(BinaryOperator::CreateFDiv(L, R), nullptr,
                                 FMFSource->getFastMathFlags());
     return Insert(I, Name);
   }
 
+  CallInst *CreateConstrainedFDiv(Value *L, Value *R,
+                                  Instruction *FMFSource = nullptr,
+                                  const Twine &Name = "",
+                                  MDNode *RoundingMD = nullptr,
+                                  MDNode *ExceptMD = nullptr) {
+
+    Value *Rounding = getConstrainedRounding(RoundingMD);
+    Value *Except = getConstrainedExcept(ExceptMD);
+
+    return CreateIntrinsic(Intrinsic::experimental_constrained_fdiv,
+                           { L->getType() },
+                           { L, R, Rounding, Except },
+                           FMFSource, Name);
+  }
+
   Value *CreateFRem(Value *L, Value *R, const Twine &Name = "",
                     MDNode *FPMD = nullptr) {
+    if (IsFPConstrained)
+      return CreateConstrainedFRem(L, R, nullptr, Name, nullptr, nullptr);
+
     if (Value *V = foldConstant(Instruction::FRem, L, R, Name)) return V;
     Instruction *I = setFPAttrs(BinaryOperator::CreateFRem(L, R), FPMD, FMF);
     return Insert(I, Name);
   }
 
   /// Copy fast-math-flags from an instruction rather than using the builder's
   /// default FMF.
   Value *CreateFRemFMF(Value *L, Value *R, Instruction *FMFSource,
                        const Twine &Name = "") {
+    if (IsFPConstrained)
+      return CreateConstrainedFRem(L, R, FMFSource, Name, nullptr, nullptr);
+
     if (Value *V = foldConstant(Instruction::FRem, L, R, Name)) return V;
     Instruction *I = setFPAttrs(BinaryOperator::CreateFRem(L, R), nullptr,
                                 FMFSource->getFastMathFlags());
     return Insert(I, Name);
   }
 
+  CallInst *CreateConstrainedFRem(Value *L, Value *R,
+                                  Instruction *FMFSource = nullptr,
+                                  const Twine &Name = "",
+                                  MDNode *RoundingMD = nullptr,
+                                  MDNode *ExceptMD = nullptr) {
+
+    Value *Rounding = getConstrainedRounding(RoundingMD);
+    Value *Except = getConstrainedExcept(ExceptMD);
+
+    return CreateIntrinsic(Intrinsic::experimental_constrained_frem,
+                           { L->getType() },
+                           { L, R, Rounding, Except },
+                           FMFSource, Name);
+  }
+
   Value *CreateBinOp(Instruction::BinaryOps Opc,
                      Value *LHS, Value *RHS, const Twine &Name = "",
                      MDNode *FPMathTag = nullptr) {
     if (Value *V = foldConstant(Opc, LHS, RHS, Name)) return V;
     Instruction *BinOp = BinaryOperator::Create(Opc, LHS, RHS);
     if (isa<FPMathOperator>(BinOp))
       BinOp = setFPAttrs(BinOp, FPMathTag, FMF);
     return Insert(BinOp, Name);

lib/IR/CMakeLists.txt

add_llvm_library(LLVMCore
   DataLayout.cpp
   DebugInfo.cpp
   DebugInfoMetadata.cpp
   DebugLoc.cpp
   DiagnosticHandler.cpp
   DiagnosticInfo.cpp
   DiagnosticPrinter.cpp
   Dominators.cpp
+  FPState.cpp
   Function.cpp
   GVMaterializer.cpp
   Globals.cpp
   IRBuilder.cpp
   IRPrintingPasses.cpp
   InlineAsm.cpp
   Instruction.cpp
   Instructions.cpp

lib/IR/FPState.cpp

+#include "llvm/IR/FPState.h"
+#include "llvm/IR/IRBuilder.h"
+
+namespace llvm {
+FPState::FPState(IRBuilderBase &B) : Builder(B), FPM(FPM_Off), FPME(FPME_Off),
+                                  FPS(FPS_Off) {}
+
+void FPState::updateBuilder(FPModelKind fpModel,
+                   FPModelExceptKind fpModelExcept,
+                   FPSpeculationKind fpSpeculation) {
+  // Save the new settings in the state variables.
+  FPM = fpModel;
+  FPME = fpModelExcept;
+  FPS = fpSpeculation;
+
+  // Translate the compiler options into
+  // the 3 settings that are transmitted to the IR Builder
+  bool isConstrained = false;
+  ConstrainedRoundingKind ConstrainedRoundingMD = CR_Off;
+  ConstrainedExceptKind ConstrainedExceptMD = CE_Off;
+
+  switch (fpModel) {
+  case FPM_Off:
+  case FPM_Precise:
+  case FPM_Fast:
+    break;
+  case FPM_Strict:
+    isConstrained = true;
+    ConstrainedRoundingMD = CR_Dynamic;
+    ConstrainedExceptMD = CE_Strict;
+    break;
+  default:
+    llvm_unreachable("Unsupported FP Model");
+  }
+
+  switch (fpModelExcept) {
+  case FPME_Off:
+    break;
+  case FPME_Except:
+    isConstrained = true;
+    ConstrainedExceptMD = CE_Strict;
+    break;
+  case FPME_NoExcept:
+    isConstrained = true;
+    ConstrainedExceptMD = CE_Ignore;
+    break;
+  default:
+    llvm_unreachable("Unsupported FP Except Model");
+  }
+
+  switch (fpSpeculation) {
+  case FPS_Off:
+    break;
+  case FPS_Fast:
+    isConstrained = true;
+    ConstrainedExceptMD = CE_Ignore;
+    break;
+  case FPS_Strict:
+    isConstrained = true;
+    ConstrainedExceptMD = CE_Strict;
+    break;
+  case FPS_Safe:
+    isConstrained = true;
+    ConstrainedExceptMD = CE_MayTrap;
+    break;
+  default:
+    llvm_unreachable("Unsupported FP Speculation");
+  }
+
+  if (isConstrained && ConstrainedRoundingMD == CR_Off)
+    ConstrainedRoundingMD = CR_ToNearest;
+
+  Builder.setIsConstrainedFP(isConstrained);
+  if (isConstrained) {
+    Builder.setDefaultConstrainedRounding(ConstrainedRoundingMD);
+    Builder.setDefaultConstrainedExcept(ConstrainedExceptMD);
+  }
+}
+} // end namespace llvm

unittests/IR/IRBuilderTest.cpp

 //===- llvm/unittest/IR/IRBuilderTest.cpp - IRBuilder tests ---------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/BasicBlock.h"
 #include "llvm/IR/DIBuilder.h"
 #include "llvm/IR/DataLayout.h"
+#include "llvm/IR/FPState.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/MDBuilder.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/NoFolder.h"
 #include "llvm/IR/Verifier.h"
 #include "gtest/gtest.h"
TEST_F(IRBuilderTest, Intrinsics) {
 
   Call = Builder.CreateIntrinsic(Intrinsic::fma, {V->getType()}, {V, V, V}, I);
   II = cast<IntrinsicInst>(Call);
   EXPECT_EQ(II->getIntrinsicID(), Intrinsic::fma);
   EXPECT_TRUE(II->hasNoInfs());
   EXPECT_FALSE(II->hasNoNaNs());
 }
 
+TEST_F(IRBuilderTest, ConstrainedFP) {
+  IRBuilder<> Builder(BB);
+  Value *V;
+  CallInst *Call;
+  IntrinsicInst *II;
+
+  V = Builder.CreateLoad(GV);
+
+  Call = Builder.CreateConstrainedFAdd(V, V);
+  II = cast<IntrinsicInst>(Call);
+  EXPECT_EQ(II->getIntrinsicID(), Intrinsic::experimental_constrained_fadd);
+
+  Call = Builder.CreateConstrainedFSub(V, V);
+  II = cast<IntrinsicInst>(Call);
+  EXPECT_EQ(II->getIntrinsicID(), Intrinsic::experimental_constrained_fsub);
+
+  Call = Builder.CreateConstrainedFMul(V, V);
+  II = cast<IntrinsicInst>(Call);
+  EXPECT_EQ(II->getIntrinsicID(), Intrinsic::experimental_constrained_fmul);
+
+  Call = Builder.CreateConstrainedFDiv(V, V);
+  II = cast<IntrinsicInst>(Call);
+  EXPECT_EQ(II->getIntrinsicID(), Intrinsic::experimental_constrained_fdiv);
+
+  Call = Builder.CreateConstrainedFRem(V, V);
+  II = cast<IntrinsicInst>(Call);
+  EXPECT_EQ(II->getIntrinsicID(), Intrinsic::experimental_constrained_frem);
+
+  // Now see if we get constrained intrinsics instead of non-constrained
+  // instructions.
+  Builder.setIsConstrainedFP(true);
+
+  V = Builder.CreateFAdd(V, V);
+  ASSERT_TRUE(isa<IntrinsicInst>(V));
+  II = cast<IntrinsicInst>(V);
+  EXPECT_EQ(II->getIntrinsicID(), Intrinsic::experimental_constrained_fadd);
+
+  V = Builder.CreateFSub(V, V);
+  ASSERT_TRUE(isa<IntrinsicInst>(V));
+  II = cast<IntrinsicInst>(V);
+  EXPECT_EQ(II->getIntrinsicID(), Intrinsic::experimental_constrained_fsub);
+
+  V = Builder.CreateFMul(V, V);
+  ASSERT_TRUE(isa<IntrinsicInst>(V));
+  II = cast<IntrinsicInst>(V);
+  EXPECT_EQ(II->getIntrinsicID(), Intrinsic::experimental_constrained_fmul);
+  
+  V = Builder.CreateFDiv(V, V);
+  ASSERT_TRUE(isa<IntrinsicInst>(V));
+  II = cast<IntrinsicInst>(V);
+  EXPECT_EQ(II->getIntrinsicID(), Intrinsic::experimental_constrained_fdiv);
+  
+  V = Builder.CreateFRem(V, V);
+  ASSERT_TRUE(isa<IntrinsicInst>(V));
+  II = cast<IntrinsicInst>(V);
+  EXPECT_EQ(II->getIntrinsicID(), Intrinsic::experimental_constrained_frem);
+
+  // Verify the codepaths for setting and overriding the default metadata.
+  MDNode *ExceptStr = MDNode::get(Builder.getContext(), 
+                                  MDString::get(Builder.getContext(), 
+                                                "fpexcept.strict"));
+  MDNode *RoundDyn = MDNode::get(Builder.getContext(), 
+                                 MDString::get(Builder.getContext(),
+                                               "round.dynamic"));
+
+  V = Builder.CreateFAdd(V, V);
+  ASSERT_TRUE(isa<ConstrainedFPIntrinsic>(V));
+  auto *CII = cast<ConstrainedFPIntrinsic>(V);
+  ASSERT_TRUE(CII->getExceptionBehavior() == ConstrainedFPIntrinsic::ebStrict);
+  ASSERT_TRUE(CII->getRoundingMode() == ConstrainedFPIntrinsic::rmDynamic);
+
+  Builder.setDefaultConstrainedExcept(FPState::CE_Ignore);
+  Builder.setDefaultConstrainedRounding(FPState::CR_Upward);
+  V = Builder.CreateFAdd(V, V);
+  CII = cast<ConstrainedFPIntrinsic>(V);
+  ASSERT_TRUE(CII->getExceptionBehavior() == ConstrainedFPIntrinsic::ebIgnore);
+  ASSERT_TRUE(CII->getRoundingMode() == ConstrainedFPIntrinsic::rmUpward);
+
+  // Now override the defaults.
+  Call = Builder.CreateConstrainedFAdd(V, V, nullptr, "", RoundDyn, ExceptStr);
+  CII = cast<ConstrainedFPIntrinsic>(Call);
+  ASSERT_TRUE(CII->getExceptionBehavior() == ConstrainedFPIntrinsic::ebStrict);
+  ASSERT_TRUE(CII->getRoundingMode() == ConstrainedFPIntrinsic::rmDynamic);
+
+  // Use FPState to update the builder settings
+  FPState fpState(Builder);
+
+  fpState.updateBuilder(FPState::FPM_Off, FPState::FPME_Off, FPState::FPS_Off);
+  V = Builder.CreateFAdd(V, V);
+  ASSERT_TRUE(!isa<ConstrainedFPIntrinsic>(V));
+
+  fpState.updateBuilder(FPState::FPM_Precise, FPState::FPME_Off,
+                        FPState::FPS_Off);
+  V = Builder.CreateFAdd(V, V);
+  ASSERT_TRUE(!isa<ConstrainedFPIntrinsic>(V));
+
+  fpState.updateBuilder(FPState::FPM_Strict,
+                        FPState::FPME_Off, FPState::FPS_Off);
+  V = Builder.CreateFAdd(V, V);
+  CII = cast<ConstrainedFPIntrinsic>(V);
+  ASSERT_TRUE(isa<ConstrainedFPIntrinsic>(V));
+  ASSERT_TRUE(CII->getExceptionBehavior() == ConstrainedFPIntrinsic::ebStrict);
+  ASSERT_TRUE(CII->getRoundingMode() == ConstrainedFPIntrinsic::rmDynamic);
+
+  fpState.updateBuilder(FPState::FPM_Off,
+                        FPState::FPME_Except, FPState::FPS_Off);
+  V = Builder.CreateFAdd(V, V);
+  CII = cast<ConstrainedFPIntrinsic>(V);
+  ASSERT_TRUE(isa<ConstrainedFPIntrinsic>(V));
+  ASSERT_TRUE(CII->getExceptionBehavior() == ConstrainedFPIntrinsic::ebStrict);
+  ASSERT_TRUE(CII->getRoundingMode() == ConstrainedFPIntrinsic::rmToNearest);
+
+  fpState.updateBuilder(FPState::FPM_Off,
+                        FPState::FPME_NoExcept, FPState::FPS_Off);
+  V = Builder.CreateFAdd(V, V);
+  CII = cast<ConstrainedFPIntrinsic>(V);
+  ASSERT_TRUE(isa<ConstrainedFPIntrinsic>(V));
+  ASSERT_TRUE(CII->getExceptionBehavior() == ConstrainedFPIntrinsic::ebIgnore);
+  ASSERT_TRUE(CII->getRoundingMode() == ConstrainedFPIntrinsic::rmToNearest);
+
+  fpState.updateBuilder(FPState::FPM_Fast,
+                        FPState::FPME_Off, FPState::FPS_Off);
+  V = Builder.CreateFAdd(V, V);
+  ASSERT_TRUE(!isa<ConstrainedFPIntrinsic>(V));
+
+  fpState.updateBuilder(FPState::FPM_Off,
+                        FPState::FPME_Off, FPState::FPS_Fast);
+  V = Builder.CreateFAdd(V, V);
+  CII = cast<ConstrainedFPIntrinsic>(V);
+  ASSERT_TRUE(isa<ConstrainedFPIntrinsic>(V));
+  ASSERT_TRUE(CII->getExceptionBehavior() == ConstrainedFPIntrinsic::ebIgnore);
+  ASSERT_TRUE(CII->getRoundingMode() == ConstrainedFPIntrinsic::rmToNearest);
+
+  fpState.updateBuilder(FPState::FPM_Off,
+                        FPState::FPME_Off, FPState::FPS_Strict);
+  V = Builder.CreateFAdd(V, V);
+  CII = cast<ConstrainedFPIntrinsic>(V);
+  ASSERT_TRUE(isa<ConstrainedFPIntrinsic>(V));
+  ASSERT_TRUE(CII->getExceptionBehavior() == ConstrainedFPIntrinsic::ebStrict);
+  ASSERT_TRUE(CII->getRoundingMode() == ConstrainedFPIntrinsic::rmToNearest);
+
+  fpState.updateBuilder(FPState::FPM_Off,
+                        FPState::FPME_Off, FPState::FPS_Safe);
+  V = Builder.CreateFAdd(V, V);
+  CII = cast<ConstrainedFPIntrinsic>(V);
+  ASSERT_TRUE(isa<ConstrainedFPIntrinsic>(V));
+  ASSERT_TRUE(CII->getExceptionBehavior() == ConstrainedFPIntrinsic::ebMayTrap);
+  ASSERT_TRUE(CII->getRoundingMode() == ConstrainedFPIntrinsic::rmToNearest);
+
+  Builder.CreateRetVoid();
+  EXPECT_FALSE(verifyModule(*M));
+}
+
 TEST_F(IRBuilderTest, Lifetime) {
   IRBuilder<> Builder(BB);
   AllocaInst *Var1 = Builder.CreateAlloca(Builder.getInt8Ty());
   AllocaInst *Var2 = Builder.CreateAlloca(Builder.getInt32Ty());
   AllocaInst *Var3 = Builder.CreateAlloca(Builder.getInt8Ty(),
                                           Builder.getInt32(123));
 
   CallInst *Start1 = Builder.CreateLifetimeStart(Var1);