Update according to the obtained feedback

- Bundles are renamed: "fp.control" -> "fp.round",
- Corrected documentation,
- DAG nodes STRICT_* are used to lower the supported intrinsics,
- Constrained properties in IRBuilder are reused for handling FP bundles,
- DAG gets methods for lowering FP operations,
- IR dump prints FP memory effects,
- Fixed some problems in IRBuilderBase::CreateCall,
- Added a new check to Verifier,
- Added tests for checking code generation.

Author: spavloff

clang/lib/CodeGen/CodeGenFunction.cpp

@@ -1092,7 +1092,7 @@ void CodeGenFunction::StartFunction(GlobalDecl GD, QualType RetTy,
   if ((FD && (FD->UsesFPIntrin() || FD->hasAttr<StrictFPAttr>())) ||
       (!FD && (FPExceptionBehavior != llvm::fp::ebIgnore ||
                RM != llvm::RoundingMode::NearestTiesToEven))) {
-    Builder.setIsFPConstrained(true);
+    Builder.setIsFPConstrained(true, false);
     Fn->addFnAttr(llvm::Attribute::StrictFP);
   }
 

llvm/docs/LangRef.rst

@@ -3098,43 +3098,48 @@ Floating-point Operand Bundles
 These operand bundles are used for calls that involve floating-point
 operations and interact with :ref:`floating-point environment <floatenv>` or
 depend on floating-point options, such as rounding mode, denormal modes, etc.
-There are two kinds of such operand bundles, which represent the value of
-floating-point control modes and the treatment of status bits respectively.
 
-An operand bundle tagged with "fp.control" contains information about the
-control modes used for the operation execution. Operands specified in this
-bundle represent particular options. Currently, only rounding mode is supported.
-
-Rounding mode is represented by a metadata string value, which specifies the
-the mode used for the operation evaluation. Possible values are:
+An operand bundle tagged with "fp.round" contains information about the
+rounding mode used for the operation execution (the effective rounding mode).
+This mode is represented by a metadata string value and specifies the mode used
+for the operation evaluation. Possible values are:
 
 ::
 
-    "rtz"  - toward zero
-    "rte"  - to nearest, ties to even
-    "rtp"  - toward positive infinity
-    "rtn"  - toward negative infinity
-    "rmm"  - to nearest, ties away from zero
-    "dyn"  - rounding mode is taken from control register
+    "towardzero"
+    "tonearest"
+    "upward"
+    "downward"
+    "tonearestaway"
+    "dynamic"
 
-Only one such value may be specified. If "fp.control" is absent, the default
-rounding rounding mode is taken from the control register (dynamic rounding).
-In the particular case of :ref:`default floating-point environment <floatenv>`,
-the operation uses rounding to nearest, ties to even.
+Only one value may be specified. If the "fp.round" bundle is absent, and
+the operation depends on rounding mode, the default behavior is to use the value
+from a control register (dynamic rounding). In the specific case of
+:ref:`default floating-point environment <floatenv>`, the register is assumed to
+set rounding to nearest, ties to even.
 
 An operand bundle tagged with "fp.except" may be associated with operations
-that can read or write floating-point exception flags. It contains a single
-metadata string value, which can have one of the following values:
+that can raise floating-point exceptions. It contains a single metadata string
+value, which can have one of the following:
 
 ::
 
     "ignore"
     "strict"
-    "maytrap"
-
-It has the same meaning as the corresponding argument in
-:ref:`constrained intrinsics <constrainedfp>`.
 
+If the argument is "ignore", floating-point exceptions raised by the call are not
+intended to be observed. Optimization transformations may reorder such operations
+or omit them in some cases. For example, if the call result is unused, the call
+may be removed, even if it could raise exceptions. This is the only permitted value
+in the :ref:`default floating-point environment <floatenv>`.
+
+If the argument of "fp.except" is "strict", all transformations must preserve the
+floating-point exception semantics of the original code. Any exception that would
+have been raised by the original code must also be raised by the transformed code
+unless it can be proven unobservable. No new observable floating-point exceptions
+may be introduced. This value may only be used only in functions with
+``strictfp`` attribute.
 
 .. _moduleasm:
 

llvm/include/llvm/IR/FloatingPointOps.def

@@ -10,15 +10,21 @@
 //
 //===----------------------------------------------------------------------===//
 
+// Describes floating-point operation.
+// Arguments of the entries are:
+// N - intrinsic function name,
+// D - DAG node corresponding to the intrinsic.
 #ifndef FUNCTION
 #define FUNCTION(N,D)
 #endif
 
-// Arguments of the entries are:
-// - intrinsic function name,
-// - DAG node corresponding to the intrinsic.
+// Describes floating-point operation, which lowers to STRICT_* nodes in DAG.
+#ifndef LEGACY_DAG
+#define LEGACY_DAG(N,D) FUNCTION(N,D)
+#endif
 
-FUNCTION(nearbyint,                          FNEARBYINT)
-FUNCTION(trunc,                              FTRUNC)
+LEGACY_DAG(nearbyint,                        FNEARBYINT)
+LEGACY_DAG(trunc,                            FTRUNC)
 
 #undef FUNCTION
+#undef LEGACY_DAG

llvm/include/llvm/IR/IRBuilder.h

@@ -153,8 +153,8 @@ class IRBuilderBase {
   FastMathFlags FMF;
 
   bool IsFPConstrained = false;
-  fp::ExceptionBehavior DefaultConstrainedExcept = fp::ebStrict;
-  RoundingMode DefaultConstrainedRounding = RoundingMode::Dynamic;
+  fp::ExceptionBehavior DefaultConstrainedExcept = fp::ebIgnore;
+  RoundingMode DefaultConstrainedRounding = RoundingMode::NearestTiesToEven;
 
   ArrayRef<OperandBundleDef> DefaultOperandBundles;
 
@@ -348,7 +348,18 @@ class IRBuilderBase {
   /// enabled the CreateF<op>() calls instead create constrained
   /// floating point intrinsic calls. Fast math flags are unaffected
   /// by this setting.
-  void setIsFPConstrained(bool IsCon) { IsFPConstrained = IsCon; }
+  void setIsFPConstrained(bool IsCon, bool AndReset = true) {
+    if (AndReset) {
+      if (IsCon) {
+        setDefaultConstrainedRounding(RoundingMode::Dynamic);
+        setDefaultConstrainedExcept(fp::ebStrict);
+      } else {
+        setDefaultConstrainedRounding(RoundingMode::NearestTiesToEven);
+        setDefaultConstrainedExcept(fp::ebIgnore);
+      }
+    }
+    IsFPConstrained = IsCon;
+  }
 
   /// Query for the use of constrained floating point math
   bool getIsFPConstrained() { return IsFPConstrained; }
@@ -2761,23 +2772,21 @@ class IRBuilderBase {
   LLVM_ABI CallInst *CreateDereferenceableAssumption(Value *PtrValue,
                                                      Value *SizeValue);
 
-  /// Create an operand bundle in the provided bundle set to represent given FP
-  /// rounding mode.
+  /// Create an operand bundle in the provided bundle set to represent the given
+  /// floating-point rounding mode.
   ///
   /// If the rounding mode is not defined, adds the default rounding mode,
   /// stored in this builder object.
-  void
-  createFPRoundingBundle(SmallVectorImpl<OperandBundleDef> &Bundles,
-                         std::optional<RoundingMode> Rounding = std::nullopt);
+  void createRoundingBundle(SmallVectorImpl<OperandBundleDef> &Bundles,
+                            RoundingMode RM);
 
-  /// Create an operand bundle in the provided bundle set to represent FP
-  /// exception behavior.
+  /// Create an operand bundle in the provided bundle set to represent the given
+  /// floating-point exception behavior.
   ///
   /// If the exception behavior is not defined, adds the default behavior,
   /// stored in this builder object.
-  void createFPExceptionBundle(
-      SmallVectorImpl<OperandBundleDef> &Bundles,
-      std::optional<fp::ExceptionBehavior> Except = std::nullopt);
+  void createExceptionBundle(SmallVectorImpl<OperandBundleDef> &Bundles,
+                             fp::ExceptionBehavior Except);
 };
 
 /// This provides a uniform API for creating instructions and inserting

llvm/include/llvm/IR/InstrTypes.h

@@ -1096,12 +1096,17 @@ template <typename InputTy> class OperandBundleDefT {
 using OperandBundleDef = OperandBundleDefT<Value *>;
 using ConstOperandBundleDef = OperandBundleDefT<const Value *>;
 
-void addFPRoundingBundle(LLVMContext &Ctx,
-                         SmallVectorImpl<OperandBundleDef> &Bundles,
-                         RoundingMode Rounding);
-void addFPExceptionBundle(LLVMContext &Ctx,
-                          SmallVectorImpl<OperandBundleDef> &Bundles,
-                          fp::ExceptionBehavior Except);
+/// Add a bundle with tag "fp.round" and the specified rounding to the given
+/// bundle set.
+void addRoundingBundle(LLVMContext &Ctx,
+                       SmallVectorImpl<OperandBundleDef> &Bundles,
+                       RoundingMode Rounding);
+
+/// Add a bundle with tag "fp.except" and the specified exception behavior to
+/// the given bundle set.
+void addExceptionBundle(LLVMContext &Ctx,
+                        SmallVectorImpl<OperandBundleDef> &Bundles,
+                        fp::ExceptionBehavior Except);
 
 //===----------------------------------------------------------------------===//
 //                               CallBase Class
@@ -1162,6 +1167,7 @@ class CallBase : public Instruction {
   /// number of extra operands.
   LLVM_ABI unsigned getNumSubclassExtraOperandsDynamic() const;
 
+  /// Get memory effects specific to floating-point operations.
   MemoryEffects getFloatingPointMemoryEffects() const;
 
 public:
@@ -2174,10 +2180,10 @@ class CallBase : public Instruction {
     return false;
   }
 
-  /// Return rounding mode specified for this call.
+  /// Return the effective rounding mode for this call.
   RoundingMode getRoundingMode() const;
 
-  /// Return exception behavior specified for this call.
+  /// Return the effective exception behavior for this call.
   fp::ExceptionBehavior getExceptionBehavior() const;
 
   /// Used to keep track of an operand bundle.  See the main comment on

llvm/include/llvm/IR/LLVMContext.h

@@ -97,7 +97,7 @@ class LLVMContext {
     OB_ptrauth = 7,                // "ptrauth"
     OB_kcfi = 8,                   // "kcfi"
     OB_convergencectrl = 9,        // "convergencectrl"
-    OB_fp_control = 10,            // "fp.control"
+    OB_fp_round = 10,              // "fp.round"
     OB_fp_except = 11,             // "fp.except"
   };
 

llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

@@ -6816,9 +6816,7 @@ void SelectionDAGBuilder::visitIntrinsicCall(const CallInst &I,
   case Intrinsic::exp10:
   case Intrinsic::floor:
   case Intrinsic::ceil:
-  case Intrinsic::trunc:
   case Intrinsic::rint:
-  case Intrinsic::nearbyint:
   case Intrinsic::round:
   case Intrinsic::roundeven:
   case Intrinsic::canonicalize: {
@@ -6840,9 +6838,7 @@ void SelectionDAGBuilder::visitIntrinsicCall(const CallInst &I,
     case Intrinsic::exp10:        Opcode = ISD::FEXP10;        break;
     case Intrinsic::floor:        Opcode = ISD::FFLOOR;        break;
     case Intrinsic::ceil:         Opcode = ISD::FCEIL;         break;
-    case Intrinsic::trunc:        Opcode = ISD::FTRUNC;        break;
     case Intrinsic::rint:         Opcode = ISD::FRINT;         break;
-    case Intrinsic::nearbyint:    Opcode = ISD::FNEARBYINT;    break;
     case Intrinsic::round:        Opcode = ISD::FROUND;        break;
     case Intrinsic::roundeven:    Opcode = ISD::FROUNDEVEN;    break;
     case Intrinsic::canonicalize: Opcode = ISD::FCANONICALIZE; break;
@@ -6977,6 +6973,11 @@ void SelectionDAGBuilder::visitIntrinsicCall(const CallInst &I,
 #include "llvm/IR/VPIntrinsics.def"
     visitVectorPredicationIntrinsic(cast<VPIntrinsic>(I));
     return;
+#define FUNCTION(NAME, DAGN)                                                   \
+  case Intrinsic::NAME:                                                        \
+    visitFPOperation(I, ISD::DAGN);                                            \
+    break;
+#include "llvm/IR/FloatingPointOps.def"
   case Intrinsic::fptrunc_round: {
     // Get the last argument, the metadata and convert it to an integer in the
     // call
@@ -8273,6 +8274,33 @@ void SelectionDAGBuilder::visitIntrinsicCall(const CallInst &I,
   }
 }
 
+void SelectionDAGBuilder::pushOutChain(SDValue Result,
+                                       fp::ExceptionBehavior EB) {
+  assert(Result.getNode()->getNumValues() == 2);
+
+  // Push node to the appropriate list so that future instructions can be
+  // chained up correctly.
+  SDValue OutChain = Result.getValue(1);
+  switch (EB) {
+  case fp::ExceptionBehavior::ebIgnore:
+    // The only reason why ebIgnore nodes still need to be chained is that
+    // they might depend on the current rounding mode, and therefore must
+    // not be moved across instruction that may change that mode.
+    [[fallthrough]];
+  case fp::ExceptionBehavior::ebMayTrap:
+    // These must not be moved across calls or instructions that may change
+    // floating-point exception masks.
+    PendingConstrainedFP.push_back(OutChain);
+    break;
+  case fp::ExceptionBehavior::ebStrict:
+    // These must not be moved across calls or instructions that may change
+    // floating-point exception masks or read floating-point exception flags.
+    // In addition, they cannot be optimized out even if unused.
+    PendingConstrainedFPStrict.push_back(OutChain);
+    break;
+  }
+}
+
 void SelectionDAGBuilder::visitConstrainedFPIntrinsic(
     const ConstrainedFPIntrinsic &FPI) {
   SDLoc sdl = getCurSDLoc();
@@ -8286,32 +8314,6 @@ void SelectionDAGBuilder::visitConstrainedFPIntrinsic(
   for (unsigned I = 0, E = FPI.getNonMetadataArgCount(); I != E; ++I)
     Opers.push_back(getValue(FPI.getArgOperand(I)));
 
-  auto pushOutChain = [this](SDValue Result, fp::ExceptionBehavior EB) {
-    assert(Result.getNode()->getNumValues() == 2);
-
-    // Push node to the appropriate list so that future instructions can be
-    // chained up correctly.
-    SDValue OutChain = Result.getValue(1);
-    switch (EB) {
-    case fp::ExceptionBehavior::ebIgnore:
-      // The only reason why ebIgnore nodes still need to be chained is that
-      // they might depend on the current rounding mode, and therefore must
-      // not be moved across instruction that may change that mode.
-      [[fallthrough]];
-    case fp::ExceptionBehavior::ebMayTrap:
-      // These must not be moved across calls or instructions that may change
-      // floating-point exception masks.
-      PendingConstrainedFP.push_back(OutChain);
-      break;
-    case fp::ExceptionBehavior::ebStrict:
-      // These must not be moved across calls or instructions that may change
-      // floating-point exception masks or read floating-point exception flags.
-      // In addition, they cannot be optimized out even if unused.
-      PendingConstrainedFPStrict.push_back(OutChain);
-      break;
-    }
-  };
-
   const TargetLowering &TLI = DAG.getTargetLoweringInfo();
   EVT VT = TLI.getValueType(DAG.getDataLayout(), FPI.getType());
   SDVTList VTs = DAG.getVTList(VT, MVT::Other);
@@ -9355,6 +9357,56 @@ bool SelectionDAGBuilder::visitBinaryFloatCall(const CallInst &I,
   return true;
 }
 
+bool SelectionDAGBuilder::visitFPOperation(const CallInst &I, unsigned Opcode) {
+  // We already checked this call's prototype; verify it doesn't modify errno.
+  MemoryEffects ME = I.getMemoryEffects();
+  if (!ME.onlyAccessesInaccessibleMem())
+    return false;
+
+  SmallVector<SDValue, 4> Operands;
+  bool HasChain = ME.doesAccessInaccessibleMem();
+  if (HasChain)
+    Operands.push_back(getRoot());
+  for (auto &Arg : I.args())
+    Operands.push_back(getValue(Arg));
+
+  const TargetLowering &TLI = DAG.getTargetLoweringInfo();
+  EVT VT = TLI.getValueType(DAG.getDataLayout(), I.getType(), true);
+  SDVTList NodeVT;
+  if (HasChain)
+    NodeVT = DAG.getVTList(VT, MVT::Other);
+  else
+    NodeVT = DAG.getVTList(VT);
+
+  SDNodeFlags Flags;
+  fp::ExceptionBehavior EB = I.getExceptionBehavior();
+  if (EB == fp::ExceptionBehavior::ebIgnore)
+    Flags.setNoFPExcept(true);
+  if (auto *FPOp = dyn_cast<FPMathOperator>(&I))
+    Flags.copyFMF(*FPOp);
+
+  // Temporary solution: use STRICT_* nodes.
+  if (HasChain)
+    switch (Opcode) {
+    default:
+      break;
+#define LEGACY_DAG(NAME, DAGN)                                                 \
+  case ISD::DAGN:                                                              \
+    Opcode = ISD::STRICT_##DAGN;                                               \
+    break;
+#include "llvm/IR/FloatingPointOps.def"
+    }
+
+  SDLoc sdl = getCurSDLoc();
+  SDValue Result = DAG.getNode(Opcode, sdl, NodeVT, Operands, Flags);
+  if (HasChain)
+    pushOutChain(Result, EB);
+
+  SDValue FPResult = Result.getValue(0);
+  setValue(&I, FPResult);
+  return true;
+}
+
 void SelectionDAGBuilder::visitCall(const CallInst &I) {
   // Handle inline assembly differently.
   if (I.isInlineAsm()) {

llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.h

@@ -367,6 +367,8 @@ class SelectionDAGBuilder {
   /// Evict any dangling debug information, attempting to salvage it first.
   void resolveOrClearDbgInfo();
 
+  void pushOutChain(SDValue Result, fp::ExceptionBehavior EB);
+
   SDValue getValue(const Value *V);
 
   SDValue getNonRegisterValue(const Value *V);
@@ -611,6 +613,7 @@ class SelectionDAGBuilder {
   bool visitStrNLenCall(const CallInst &I);
   bool visitUnaryFloatCall(const CallInst &I, unsigned Opcode);
   bool visitBinaryFloatCall(const CallInst &I, unsigned Opcode);
+  bool visitFPOperation(const CallInst &I, unsigned Opcode);
   void visitAtomicLoad(const LoadInst &I);
   void visitAtomicStore(const StoreInst &I);
   void visitLoadFromSwiftError(const LoadInst &I);