Apply comments

Signed-off-by: Sidorov, Dmitry <[email protected]>

Author: MrSidims

llvm/docs/LangRef.rst

@@ -21407,7 +21407,7 @@ This intrinsic is not supported on all targets. Some targets may not support
 all rounding modes.
 
 '``llvm.convert.to.arbitrary.fp``' Intrinsic
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
@@ -21446,20 +21446,53 @@ Arguments:
   accepted by :ref:`llvm.fptrunc.round <int_fptrunc_round>` (for example,
   ``"round.tonearest"`` or ``"round.towardzero"``).
 
+  The rounding mode is only consulted when ``value`` is not exactly representable in the target format.
+  If the value is exactly representable, all rounding modes produce the same result.
+
 ``saturation``
-  A compile-time constant boolean value (``i1``). When ``true``, values outside the
-  representable range of the target format are clamped to the minimum or maximum normal value.
-  When ``false``, no saturation is applied. This parameter must be an immediate constant.
+  A compile-time constant boolean value (``i1``). This parameter controls how overflow is handled
+  when values exceed the representable finite range of the target format:
+
+  - When ``true``: overflowing values are clamped to the minimum or maximum representable finite value
+    (saturating to the largest negative finite value or largest positive finite value).
+  - When ``false``: overflowing values are converted to infinity (preserving sign of the original value) if the
+    target format supports infinity, or return a poison value if infinity is not supported
+    by the target format.
+
+  This parameter must be an immediate constant.
 
 Semantics:
 """"""""""
 
 The intrinsic converts the native LLVM floating-point value to the arbitrary FP
 format specified by ``interpretation``, applying the requested rounding mode and
-saturation behavior. The result is returned as an integer (e.g., ``i8`` for FP8,
-``i6`` for FP6) containing the encoded arbitrary FP bits. When saturation is enabled,
-values that exceed the representable range are clamped to the minimum or maximum
-normal value of the target format.
+saturation behavior. The conversion is performed in two steps: first, the value is
+rounded according to the specified rounding mode to fit the target format's precision;
+then, if the rounded result exceeds the target format's representable range, saturation
+is applied according to the ``saturation`` parameter. The result is returned as an
+integer (e.g., ``i8`` for FP8, ``i6`` for FP6) containing the encoded arbitrary FP bits.
+
+**Handling of special values:**
+
+- **NaN**: If the input is NaN and the target format supports NaN, it is converted to a NaN
+  representation in the target format. The exact NaN payload and quiet/signaling status are
+  implementation-defined; implementations may preserve them when the target supports it.
+  If the target format does not support NaN, the intrinsic returns a poison value.
+- **Infinity**: If the input is +/-Inf:
+
+  - When ``saturation`` is ``false`` and the target format supports infinity, +/-Inf is preserved.
+  - When ``saturation`` is ``false`` and the target format does not support infinity (e.g., formats
+    with "FN" suffix), the intrinsic returns a poison value.
+  - When ``saturation`` is ``true``, +/-Inf is clamped to the maximum/minimum representable finite value.
+
+- **Overflow**: When a finite value exceeds the representable range:
+
+  - When ``saturation`` is ``true``, the value is clamped to the maximum/minimum representable finite value.
+  - When ``saturation`` is ``false`` and the target format supports infinity, the value becomes +/-Inf.
+  - When ``saturation`` is ``false`` and the target format does not support infinity, the intrinsic
+    returns a poison value.
+
+For FP6/FP4 interpretations, producers are expected to use ``saturation`` = ``true``; using ``saturation`` = ``false`` and generating NaN/Inf/overflowing values is undefined (poison).
 
 Example:
 """"""""
@@ -21477,16 +21510,15 @@ Example:
           metadata !"round.towardzero", i1 true)
 
 '``llvm.convert.from.arbitrary.fp``' Intrinsic
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 
 ::
 
       declare <fNxM> @llvm.convert.from.arbitrary.fp.<fNxM>.<iNxM>(
-          <iNxM> <value>, metadata <interpretation>,
-          metadata <rounding mode>, i1 <saturation>)
+          <iNxM> <value>, metadata <interpretation>)
 
 Overview:
 """""""""
@@ -21510,24 +21542,20 @@ Arguments:
   - FP6 formats: ``"Float6E3M2FN"``, ``"Float6E2M3FN"``
   - FP4 formats: ``"Float4E2M1FN"``
 
-``rounding mode``
-  A metadata string specifying the rounding mode. The permitted strings match those
-  accepted by :ref:`llvm.fptrunc.round <int_fptrunc_round>` (for example,
-  ``"round.tonearest"`` or ``"round.towardzero"``).
-
-``saturation``
-  A compile-time constant boolean value (``i1``). When ``true``, values outside the
-  representable range of the target format are clamped to the minimum or maximum normal value.
-  When ``false``, no saturation is applied. This parameter must be an immediate constant.
-
 Semantics:
 """"""""""
 
 The intrinsic interprets the integer value as arbitrary FP bits according to
-``interpretation``, then converts to the native LLVM floating-point result type,
-applying the requested rounding mode and saturation behavior. When saturation is
-enabled, values that exceed the representable range of the target format are
-clamped to the minimum or maximum normal value.
+``interpretation``, then converts to the native LLVM floating-point result type.
+
+Conversions from arbitrary FP formats to native LLVM floating-point types are typically
+widening conversions (e.g., FP8 to FP16 or FP32), which are exact and require no rounding.
+Normal finite values are converted exactly. NaN values in the source format are converted to
+NaN in the target format. The exact NaN payload and quiet/signaling status are
+implementation-defined; implementations may preserve them when the target supports it.
+Infinity values are preserved as infinity. If a value exceeds the representable range of the
+target type (for example, converting ``Float8E8M0FNU`` with large exponents to ``half``),
+the result is converted to infinity with the appropriate sign.
 
 Example:
 """"""""
@@ -21536,13 +21564,11 @@ Example:
 
       ; Convert FP8 E4M3 bits to half
       %half_val = call half @llvm.convert.from.arbitrary.fp.f16.i8(
-          i8 %fp8bits, metadata !"Float8E4M3",
-          metadata !"round.tonearest", i1 false)
+          i8 %fp8bits, metadata !"Float8E4M3")
 
       ; Convert vector of FP8 E5M2 bits to float
       %vec_float = call <4 x float> @llvm.convert.from.arbitrary.fp.v4f32.v4i8(
-          <4 x i8> %fp8_values, metadata !"Float8E5M2",
-          metadata !"round.tonearest", i1 false)
+          <4 x i8> %fp8_values, metadata !"Float8E5M2")
 
 Convergence Intrinsics
 ----------------------

llvm/include/llvm/IR/Intrinsics.h

@@ -284,6 +284,11 @@ namespace Intrinsic {
   /// N.
   LLVM_ABI Intrinsic::ID getDeinterleaveIntrinsicID(unsigned Factor);
 
+  /// Returns true if the given string is a valid arbitrary floating-point
+  /// format interpretation for llvm.convert.to.arbitrary.fp and
+  /// llvm.convert.from.arbitrary.fp intrinsics.
+  LLVM_ABI bool isValidArbitraryFPFormat(StringRef Format);
+
   } // namespace Intrinsic
 
   } // namespace llvm

llvm/include/llvm/IR/Intrinsics.td

@@ -1104,8 +1104,8 @@ let IntrProperties = [IntrNoMem, IntrSpeculatable] in {
   def int_convert_from_arbitrary_fp
       : DefaultAttrsIntrinsic<
             [ llvm_anyfloat_ty ],
-            [ llvm_anyint_ty, llvm_metadata_ty, llvm_metadata_ty, llvm_i1_ty ],
-            [ IntrNoMem, IntrSpeculatable, ImmArg<ArgIndex<3>> ]>;
+            [ llvm_anyint_ty, llvm_metadata_ty ],
+            [ IntrNoMem, IntrSpeculatable ]>;
 
   def int_canonicalize : DefaultAttrsIntrinsic<[llvm_anyfloat_ty], [LLVMMatchType<0>],
                                    [IntrNoMem]>;

llvm/lib/CodeGen/GlobalISel/IRTranslator.cpp

@@ -2842,10 +2842,7 @@ bool IRTranslator::translateCall(const User &U, MachineIRBuilder &MIRBuilder) {
       if (!MDN) {
         if (auto *ConstMD = dyn_cast<ConstantAsMetadata>(MD))
           MDN = MDNode::get(MF->getFunction().getContext(), ConstMD);
-        else if (auto *MDS = dyn_cast<MDString>(MD)) {
-          Metadata *Ops[] = {MDS};
-          MDN = MDNode::get(MF->getFunction().getContext(), Ops);
-        } else
+        else // This was probably an MDString.
           return false;
       }
       MIB.addMetadata(MDN);

llvm/lib/IR/Intrinsics.cpp

@@ -1142,3 +1142,12 @@ Intrinsic::ID Intrinsic::getDeinterleaveIntrinsicID(unsigned Factor) {
   assert(Factor >= 2 && Factor <= 8 && "Unexpected factor");
   return InterleaveIntrinsics[Factor - 2].Deinterleave;
 }
+
+bool Intrinsic::isValidArbitraryFPFormat(StringRef Format) {
+  return Format == "Float8E5M2" || Format == "Float8E5M2FNUZ" ||
+         Format == "Float8E4M3" || Format == "Float8E4M3FN" ||
+         Format == "Float8E4M3FNUZ" || Format == "Float8E4M3B11FNUZ" ||
+         Format == "Float8E3M4" || Format == "Float8E8M0FNU" ||
+         Format == "Float6E3M2FN" || Format == "Float6E2M3FN" ||
+         Format == "Float4E2M1FN";
+}

llvm/lib/IR/Verifier.cpp

@@ -5849,9 +5849,24 @@ void Verifier::visitIntrinsicCall(Intrinsic::ID ID, CallBase &Call) {
           "unsupported rounding mode argument", Call);
     break;
   }
-  case Intrinsic::convert_to_arbitrary_fp:
-  case Intrinsic::convert_from_arbitrary_fp: {
-    // Check interpretation metadata (argoperand 1)
+  case Intrinsic::convert_to_arbitrary_fp: {
+    // Check that vector element counts are consistent.
+    Type *ValueTy = Call.getArgOperand(0)->getType();
+    Type *IntTy = Call.getType();
+
+    if (auto *ValueVecTy = dyn_cast<VectorType>(ValueTy)) {
+      auto *IntVecTy = dyn_cast<VectorType>(IntTy);
+      Check(IntVecTy,
+            "if floating-point operand is a vector, integer operand must also "
+            "be a vector",
+            Call);
+      Check(ValueVecTy->getElementCount() == IntVecTy->getElementCount(),
+            "floating-point and integer vector operands must have the same "
+            "element count",
+            Call);
+    }
+
+    // Check interpretation metadata (argoperand 1).
     auto *InterpMAV = dyn_cast<MetadataAsValue>(Call.getArgOperand(1));
     Check(InterpMAV, "missing interpretation metadata operand", Call);
     auto *InterpStr = dyn_cast<MDString>(InterpMAV->getMetadata());
@@ -5861,16 +5876,11 @@ void Verifier::visitIntrinsicCall(Intrinsic::ID ID, CallBase &Call) {
     Check(!Interp.empty(), "interpretation metadata string must not be empty",
           Call);
 
-    // Valid interpretation strings: mini-float format names
-    bool IsKnown = Interp == "Float8E5M2" || Interp == "Float8E5M2FNUZ" ||
-                   Interp == "Float8E4M3" || Interp == "Float8E4M3FN" ||
-                   Interp == "Float8E4M3FNUZ" || Interp == "Float8E4M3B11FNUZ" ||
-                   Interp == "Float8E3M4" || Interp == "Float8E8M0FNU" ||
-                   Interp == "Float6E3M2FN" || Interp == "Float6E2M3FN" ||
-                   Interp == "Float4E2M1FN";
-    Check(IsKnown, "unsupported interpretation metadata string", Call);
+    // Valid interpretation strings: mini-float format names.
+    Check(Intrinsic::isValidArbitraryFPFormat(Interp),
+          "unsupported interpretation metadata string", Call);
 
-    // Check rounding mode metadata (argoperand 2)
+    // Check rounding mode metadata (argoperand 2).
     auto *RoundingMAV = dyn_cast<MetadataAsValue>(Call.getArgOperand(2));
     Check(RoundingMAV, "missing rounding mode metadata operand", Call);
     auto *RoundingStr = dyn_cast<MDString>(RoundingMAV->getMetadata());
@@ -5882,6 +5892,38 @@ void Verifier::visitIntrinsicCall(Intrinsic::ID ID, CallBase &Call) {
           "unsupported rounding mode argument", Call);
     break;
   }
+  case Intrinsic::convert_from_arbitrary_fp: {
+    // Check that vector element counts are consistent.
+    Type *IntTy = Call.getArgOperand(0)->getType();
+    Type *ValueTy = Call.getType();
+
+    if (auto *ValueVecTy = dyn_cast<VectorType>(ValueTy)) {
+      auto *IntVecTy = dyn_cast<VectorType>(IntTy);
+      Check(IntVecTy,
+            "if floating-point operand is a vector, integer operand must also "
+            "be a vector",
+            Call);
+      Check(ValueVecTy->getElementCount() == IntVecTy->getElementCount(),
+            "floating-point and integer vector operands must have the same "
+            "element count",
+            Call);
+    }
+
+    // Check interpretation metadata (argoperand 1).
+    auto *InterpMAV = dyn_cast<MetadataAsValue>(Call.getArgOperand(1));
+    Check(InterpMAV, "missing interpretation metadata operand", Call);
+    auto *InterpStr = dyn_cast<MDString>(InterpMAV->getMetadata());
+    Check(InterpStr, "interpretation metadata operand must be a string", Call);
+    StringRef Interp = InterpStr->getString();
+
+    Check(!Interp.empty(), "interpretation metadata string must not be empty",
+          Call);
+
+    // Valid interpretation strings: mini-float format names.
+    Check(Intrinsic::isValidArbitraryFPFormat(Interp),
+          "unsupported interpretation metadata string", Call);
+    break;
+  }
 #define BEGIN_REGISTER_VP_INTRINSIC(VPID, ...) case Intrinsic::VPID:
 #include "llvm/IR/VPIntrinsics.def"
 #undef BEGIN_REGISTER_VP_INTRINSIC