[clang] [llvm] [IR] Allow non-constrained math intrinsics in strictfp functions (PR #188297)
via llvm-commits
llvm-commits at lists.llvm.org
Tue Mar 24 10:53:11 PDT 2026
llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-llvm-ir
Author: Serge Pavlov (spavloff)
<details>
<summary>Changes</summary>
The current implementation of floating-point support uses two different representations for each floating-point operation, such as `llvm.trunc` and `llvm.experimental.constrained.trunc`. The main difference between them is the presence of side effects that describe interaction with the floating-point environment. Which of the two functions should be used is determined by the enclosing function's attribute 'strictfp'. The compiler does not check whether a regular functions, like `llvm.trunc` is used in a strictfp function, so maintaining consistency is the user's responsibility. It is easy to mistakenly use the regular, side-effect-free intrinsic in a strictfp function, and even LLVM tests contain examples of this.
If the variant of intrinsic is determined solely by the 'strictfp' function attribute, the distinction between the two forms appear to be redundant, and the regular form could be used in all cases. This would require the compiler to deduce side effects from the function attributes. In this scenario, floating-point operations would have "optional" side effects.
Currently, it is not possible to completely avoid constrained functions. In addition to representing side effects, they can also carry compiler hints, namely the expected rounding mode and exception behavior. However, using regular intrinsics in a strictfp function could be allowed if the mechanism of optional side effects were implemented for them. Such a change would make the current implementation of strictfp support more robust and would represent a step toward more powerful floating-point support.
This change implements minimal support for optional side effects in floating-point operations sufficient to allow use of non-constrained math function intrinsics in strictfp code. It does not alter the compiler's behavior for the code that is correct under the current floating-point model, it affects only the case of non-constrained intrinsics used in a strictfp function, which is currently disallowed.
---
Patch is 51.29 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/188297.diff
20 Files Affected:
- (modified) clang/test/CodeGen/strictfp-elementwise-builtins.cpp (+4-4)
- (modified) llvm/docs/LangRef.rst (+151-29)
- (modified) llvm/docs/ReleaseNotes.md (+3)
- (added) llvm/include/llvm/IR/FloatingPointOps.def (+72)
- (modified) llvm/include/llvm/IR/Function.h (+3)
- (modified) llvm/include/llvm/IR/IRBuilder.h (+3-14)
- (modified) llvm/include/llvm/IR/InstrTypes.h (+3)
- (modified) llvm/include/llvm/IR/Intrinsics.h (+8)
- (modified) llvm/include/llvm/Support/ModRef.h (+5)
- (modified) llvm/lib/Analysis/BasicAliasAnalysis.cpp (+19)
- (modified) llvm/lib/Analysis/GlobalsModRef.cpp (+6-1)
- (modified) llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp (+68-108)
- (modified) llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.h (+1)
- (modified) llvm/lib/IR/Function.cpp (+4)
- (modified) llvm/lib/IR/IRBuilder.cpp (+32)
- (modified) llvm/lib/IR/Instructions.cpp (+19)
- (modified) llvm/lib/IR/Intrinsics.cpp (+11)
- (modified) llvm/test/CodeGen/AMDGPU/amdgpu-simplify-libcall-pow.ll (+9-14)
- (modified) llvm/test/CodeGen/AMDGPU/amdgpu-simplify-libcall-pown.ll (+2-2)
- (modified) llvm/test/CodeGen/AMDGPU/amdgpu-simplify-libcall-rootn.ll (+3-2)
``````````diff
diff --git a/clang/test/CodeGen/strictfp-elementwise-builtins.cpp b/clang/test/CodeGen/strictfp-elementwise-builtins.cpp
index 6453d50f044aa..696f3f65236fc 100644
--- a/clang/test/CodeGen/strictfp-elementwise-builtins.cpp
+++ b/clang/test/CodeGen/strictfp-elementwise-builtins.cpp
@@ -48,9 +48,9 @@ float4 strict_elementwise_min(float4 a, float4 b) {
}
// CHECK-LABEL: define dso_local noundef <4 x float> @_Z26strict_elementwise_maximumDv4_fS_
-// CHECK-SAME: (<4 x float> noundef [[A:%.*]], <4 x float> noundef [[B:%.*]]) local_unnamed_addr #[[ATTR2]] {
+// CHECK-SAME: (<4 x float> noundef [[A:%.*]], <4 x float> noundef [[B:%.*]]) local_unnamed_addr #[[ATTR0]] {
// CHECK-NEXT: entry:
-// CHECK-NEXT: [[ELT_MAXIMUM:%.*]] = tail call <4 x float> @llvm.maximum.v4f32(<4 x float> [[A]], <4 x float> [[B]]) #[[ATTR4]]
+// CHECK-NEXT: [[ELT_MAXIMUM:%.*]] = tail call <4 x float> @llvm.maximum.v4f32(<4 x float> [[A]], <4 x float> [[B]]) #[[ATTR5:[0-9]+]]
// CHECK-NEXT: ret <4 x float> [[ELT_MAXIMUM]]
//
float4 strict_elementwise_maximum(float4 a, float4 b) {
@@ -58,9 +58,9 @@ float4 strict_elementwise_maximum(float4 a, float4 b) {
}
// CHECK-LABEL: define dso_local noundef <4 x float> @_Z26strict_elementwise_minimumDv4_fS_
-// CHECK-SAME: (<4 x float> noundef [[A:%.*]], <4 x float> noundef [[B:%.*]]) local_unnamed_addr #[[ATTR2]] {
+// CHECK-SAME: (<4 x float> noundef [[A:%.*]], <4 x float> noundef [[B:%.*]]) local_unnamed_addr #[[ATTR0]] {
// CHECK-NEXT: entry:
-// CHECK-NEXT: [[ELT_MINIMUM:%.*]] = tail call <4 x float> @llvm.minimum.v4f32(<4 x float> [[A]], <4 x float> [[B]]) #[[ATTR4]]
+// CHECK-NEXT: [[ELT_MINIMUM:%.*]] = tail call <4 x float> @llvm.minimum.v4f32(<4 x float> [[A]], <4 x float> [[B]]) #[[ATTR5]]
// CHECK-NEXT: ret <4 x float> [[ELT_MINIMUM]]
//
float4 strict_elementwise_minimum(float4 a, float4 b) {
diff --git a/llvm/docs/LangRef.rst b/llvm/docs/LangRef.rst
index 13883883d3981..33968d70e024f 100644
--- a/llvm/docs/LangRef.rst
+++ b/llvm/docs/LangRef.rst
@@ -4045,18 +4045,56 @@ seq\_cst total orderings of other operations that are not marked
Floating-Point Environment
--------------------------
-The default LLVM floating-point environment assumes that traps are disabled and
-status flags are not observable. Therefore, floating-point math operations do
-not have side effects and may be speculated freely. Results assume the
-round-to-nearest rounding mode, and subnormals are assumed to be preserved.
-
-Running LLVM code in an environment where these assumptions are not met
-typically leads to undefined behavior. The ``strictfp`` and
-:ref:`denormal_fpenv <denormal_fpenv>` attributes as well as
-:ref:`Constrained Floating-Point Intrinsics <constrainedfp>` can be
-used to weaken LLVM's assumptions and ensure defined behavior in
-non-default floating-point environments; see their respective
-documentation for details.
+The execution of an operation on floating-point values is often a more complex
+process than simply evaluating a function of its input arguments. First, it can
+depend on various parameters like rounding mode, denormal behavior, trap masks
+and so on. These are referenced to as "control modes" and are stored in
+floating-point control registers. In addition, the operation may set status bits
+in a status register. Floating-point environment is a collection of registers
+that hold control modes and status bits.
+
+Interaction with the floating-point environment, including reading control
+modes, writing status bits and trapping, is regarded as side effects. Depending
+on how the side effects are treated, compilation occurs in one of two modes.
+
+In the ``strict mode``, all side effects produced by the floating-point
+operations are taken into account. Modifications to the floating-point
+environment are allowed only in this mode.
+
+In the ``unconstrained mode``, control modes are not modified and status bits
+are not observed. This allows floating-point operations to be considered free
+of side effects, which facilitates code optimizations. An important case of this
+mode is the ``default mode``, in which the control modes have default values:
+rounding mode is "round to nearest, ties to even", traps are disabled, and
+subnormals are assumed to be preserved.
+
+The compilation mode is defined for an entire function and is specified by
+``strictfp`` attribute. If this attribute is set, compilation occurs in strict
+mode. The value of the floating-point environment is specified by function
+attributes (such as :ref:`denormal_fpenv <denormal_fpenv>`) and can be modified
+either by intrinsic functions like ``llvm.set_rounding`` or external functions
+like ``fesetround``.
+
+.. _floatop:
+
+Floating-point operations
+-------------------------
+
+Whether an operation interacts with the floating-point environment depends on
+the operation itself and the attributes of its containing function.
+Operations that can exhibit such
+interaction, and which may be ignored in the unconstrained mode, are referred to
+as ``floating-point operations``. These are computational operations that
+produce floating-point or integer results, round all results according to the
+value of the floating-point environment, and might signal floating-point
+exceptions.
+
+Some operations on floating-point values are not classified as floating-point
+operations. For instance, ``llvm.copysign``, ``llvm.fabs`` or
+``llvm.is_fpclass`` do not depend on control modes and cannot raise exceptions.
+The operations like ``llvm.set_rounding`` or ``llvm.set_fpenv`` interact with
+the floating-point environment, but they are not computational and their
+interaction cannot be ignored.
.. _floatnan:
@@ -16666,6 +16704,9 @@ matches a conforming libm implementation.
When specified with the fast-math-flag 'afn', the result may be approximated
using a less accurate calculation.
+As a :ref:`floating-point operation <floatop>`, this function has side effects
+in a ``strictfp`` function.
+
'``llvm.powi.*``' Intrinsic
^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -16714,6 +16755,9 @@ function may non-deterministically treat signaling NaNs as quiet NaNs. For
example, `powi(QNaN, 0)` returns `1.0`, and `powi(SNaN, 0)` may
non-deterministically return `1.0` or a NaN.
+As a :ref:`floating-point operation <floatop>`, this function has side effects
+in a ``strictfp`` function.
+
.. _t_llvm_sin:
'``llvm.sin.*``' Intrinsic
@@ -16753,6 +16797,9 @@ trapping or setting ``errno``.
When specified with the fast-math-flag 'afn', the result may be approximated
using a less accurate calculation.
+As a :ref:`floating-point operation <floatop>`, this function has side effects
+in a ``strictfp`` function.
+
.. _t_llvm_cos:
'``llvm.cos.*``' Intrinsic
@@ -16792,6 +16839,9 @@ trapping or setting ``errno``.
When specified with the fast-math-flag 'afn', the result may be approximated
using a less accurate calculation.
+As a :ref:`floating-point operation <floatop>`, this function has side effects
+in a ``strictfp`` function.
+
'``llvm.tan.*``' Intrinsic
^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -16829,6 +16879,9 @@ trapping or setting ``errno``.
When specified with the fast-math-flag 'afn', the result may be approximated
using a less accurate calculation.
+As a :ref:`floating-point operation <floatop>`, this function has side effects
+in a ``strictfp`` function.
+
'``llvm.asin.*``' Intrinsic
^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -16866,6 +16919,9 @@ trapping or setting ``errno``.
When specified with the fast-math-flag 'afn', the result may be approximated
using a less accurate calculation.
+As a :ref:`floating-point operation <floatop>`, this function has side effects
+in a ``strictfp`` function.
+
'``llvm.acos.*``' Intrinsic
^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -16903,6 +16959,9 @@ trapping or setting ``errno``.
When specified with the fast-math-flag 'afn', the result may be approximated
using a less accurate calculation.
+As a :ref:`floating-point operation <floatop>`, this function has side effects
+in a ``strictfp`` function.
+
'``llvm.atan.*``' Intrinsic
^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -16940,6 +16999,9 @@ trapping or setting ``errno``.
When specified with the fast-math-flag 'afn', the result may be approximated
using a less accurate calculation.
+As a :ref:`floating-point operation <floatop>`, this function has side effects
+in a ``strictfp`` function.
+
'``llvm.atan2.*``' Intrinsic
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -16978,6 +17040,9 @@ trapping or setting ``errno``.
When specified with the fast-math-flag 'afn', the result may be approximated
using a less accurate calculation.
+As a :ref:`floating-point operation <floatop>`, this function has side effects
+in a ``strictfp`` function.
+
'``llvm.sinh.*``' Intrinsic
^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -17015,6 +17080,9 @@ trapping or setting ``errno``.
When specified with the fast-math-flag 'afn', the result may be approximated
using a less accurate calculation.
+As a :ref:`floating-point operation <floatop>`, this function has side effects
+in a ``strictfp`` function.
+
'``llvm.cosh.*``' Intrinsic
^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -17052,6 +17120,9 @@ trapping or setting ``errno``.
When specified with the fast-math-flag 'afn', the result may be approximated
using a less accurate calculation.
+As a :ref:`floating-point operation <floatop>`, this function has side effects
+in a ``strictfp`` function.
+
'``llvm.tanh.*``' Intrinsic
^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -17089,6 +17160,8 @@ trapping or setting ``errno``.
When specified with the fast-math-flag 'afn', the result may be approximated
using a less accurate calculation.
+As a :ref:`floating-point operation <floatop>`, this function has side effects
+in a ``strictfp`` function.
'``llvm.sincos.*``' Intrinsic
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -17283,6 +17356,9 @@ function may non-deterministically treat signaling NaNs as quiet NaNs. For
example, `pow(QNaN, 0.0)` returns `1.0`, and `pow(SNaN, 0.0)` may
non-deterministically return `1.0` or a NaN.
+As a :ref:`floating-point operation <floatop>`, this function has side effects
+in a ``strictfp`` function.
+
.. _int_exp:
'``llvm.exp.*``' Intrinsic
@@ -17323,6 +17399,9 @@ trapping or setting ``errno``.
When specified with the fast-math-flag 'afn', the result may be approximated
using a less accurate calculation.
+As a :ref:`floating-point operation <floatop>`, this function has side effects
+in a ``strictfp`` function.
+
.. _int_exp2:
'``llvm.exp2.*``' Intrinsic
@@ -17363,6 +17442,9 @@ trapping or setting ``errno``.
When specified with the fast-math-flag 'afn', the result may be approximated
using a less accurate calculation.
+As a :ref:`floating-point operation <floatop>`, this function has side effects
+in a ``strictfp`` function.
+
.. _int_exp10:
'``llvm.exp10.*``' Intrinsic
@@ -17445,6 +17527,9 @@ value is returned. If the result underflows a zero with the same sign
is returned. If the result overflows, the result is an infinity with
the same sign.
+As a :ref:`floating-point operation <floatop>`, this function has side effects
+in a ``strictfp`` function.
+
.. _int_frexp:
'``llvm.frexp.*``' Intrinsic
@@ -17541,6 +17626,9 @@ trapping or setting ``errno``.
When specified with the fast-math-flag 'afn', the result may be approximated
using a less accurate calculation.
+As a :ref:`floating-point operation <floatop>`, this function has side effects
+in a ``strictfp`` function.
+
.. _int_log10:
'``llvm.log10.*``' Intrinsic
@@ -17581,6 +17669,8 @@ trapping or setting ``errno``.
When specified with the fast-math-flag 'afn', the result may be approximated
using a less accurate calculation.
+As a :ref:`floating-point operation <floatop>`, this function has side effects
+in a ``strictfp`` function.
.. _int_log2:
@@ -17622,6 +17712,9 @@ trapping or setting ``errno``.
When specified with the fast-math-flag 'afn', the result may be approximated
using a less accurate calculation.
+As a :ref:`floating-point operation <floatop>`, this function has side effects
+in a ``strictfp`` function.
+
.. _int_fma:
'``llvm.fma.*``' Intrinsic
@@ -17661,6 +17754,9 @@ is assumed to not trap or set ``errno``.
When specified with the fast-math-flag 'afn', the result may be approximated
using a less accurate calculation.
+As a :ref:`floating-point operation <floatop>`, this function has side effects
+in a ``strictfp`` function.
+
.. _int_fabs:
'``llvm.fabs.*``' Intrinsic
@@ -17803,6 +17899,9 @@ which follow :ref:`LLVM's usual signaling NaN behavior <floatnan>` instead.
The ``llvm.minnum`` intrinsic can be refined into ``llvm.minimumnum``, as the
latter exhibits a subset of behaviors of the former.
+As a :ref:`floating-point operation <floatop>`, this function has side effects
+in a ``strictfp`` function.
+
.. warning::
If the intrinsic is used without nsz, not all backends currently respect the
@@ -17869,6 +17968,9 @@ which follow :ref:`LLVM's usual signaling NaN behavior <floatnan>` instead.
The ``llvm.maxnum`` intrinsic can be refined into ``llvm.maximumnum``, as the
latter exhibits a subset of behaviors of the former.
+As a :ref:`floating-point operation <floatop>`, this function has side effects
+in a ``strictfp`` function.
+
.. warning::
If the intrinsic is used without nsz, not all backends currently respect the
@@ -17924,6 +18026,9 @@ If the ``nsz`` flag is specified, ``llvm.maximum`` with one +0.0 and one
``nsz`` semantics, if both operands have the same sign, the result must also
have the same sign.
+As a :ref:`floating-point operation <floatop>`, this function has side effects
+in a ``strictfp`` function.
+
.. _i_maximum:
'``llvm.maximum.*``' Intrinsic
@@ -17972,6 +18077,9 @@ If the ``nsz`` flag is specified, ``llvm.maximum`` with one +0.0 and one
``nsz`` semantics, if both operands have the same sign, the result must also
have the same sign.
+As a :ref:`floating-point operation <floatop>`, this function has side effects
+in a ``strictfp`` function.
+
.. _i_minimumnum:
'``llvm.minimumnum.*``' Intrinsic
@@ -18157,6 +18265,9 @@ Semantics:
This function returns the same values as the libm ``floor`` functions
would, and handles error conditions in the same way.
+As a :ref:`floating-point operation <floatop>`, this function has side effects
+in a ``strictfp`` function.
+
.. _int_ceil:
'``llvm.ceil.*``' Intrinsic
@@ -18194,6 +18305,8 @@ Semantics:
This function returns the same values as the libm ``ceil`` functions
would, and handles error conditions in the same way.
+As a :ref:`floating-point operation <floatop>`, this function has side effects
+in a ``strictfp`` function.
.. _int_llvm_trunc:
@@ -18233,6 +18346,9 @@ Semantics:
This function returns the same values as the libm ``trunc`` functions
would, and handles error conditions in the same way.
+As a :ref:`floating-point operation <floatop>`, this function has side effects
+in a ``strictfp`` function.
+
.. _int_rint:
'``llvm.rint.*``' Intrinsic
@@ -18270,11 +18386,12 @@ Semantics:
""""""""""
This function returns the same values as the libm ``rint`` functions
-would, and handles error conditions in the same way. Since LLVM assumes the
-:ref:`default floating-point environment <floatenv>`, the rounding mode is
-assumed to be set to "nearest", so halfway cases are rounded to the even
-integer. Use :ref:`Constrained Floating-Point Intrinsics <constrainedfp>`
-to avoid that assumption.
+would, and handles error conditions in the same way.
+
+In the :ref:`default floating-point environment <floatenv>`, the rounding mode is
+assumed to be "round to nearest, ties to even".
+As a :ref:`floating-point operation <floatop>`, this function has side effects
+in a ``strictfp`` function.
.. _int_nearbyint:
@@ -18312,11 +18429,12 @@ Semantics:
""""""""""
This function returns the same values as the libm ``nearbyint``
-functions would, and handles error conditions in the same way. Since LLVM
-assumes the :ref:`default floating-point environment <floatenv>`, the rounding
-mode is assumed to be set to "nearest", so halfway cases are rounded to the even
-integer. Use :ref:`Constrained Floating-Point Intrinsics <constrainedfp>` to
-avoid that assumption.
+functions would, and handles error conditions in the same way.
+
+In the :ref:`default floating-point environment <floatenv>`, the rounding mode is
+assumed to be "round to nearest, ties to even".
+As a :ref:`floating-point operation <floatop>`, this function has side effects
+in a ``strictfp`` function.
.. _int_round:
@@ -18356,6 +18474,9 @@ Semantics:
This function returns the same values as the libm ``round``
functions would, and handles error conditions in the same way.
+As a :ref:`floating-point operation <floatop>`, this function has side effects
+in a ``strictfp`` function.
+
.. _int_roundeven:
'``llvm.roundeven.*``' Intrinsic
@@ -18395,6 +18516,8 @@ This function implements IEEE 754 operation ``roundToIntegralTiesToEven``. It
also behaves in the same way as C standard function ``roundeven``, including
that it disregards rounding mode and does not raise floating point exceptions.
+As a :ref:`floating-point operation <floatop>`, this function has side effects
+in a ``strictfp`` function.
'``llvm.lround.*``' Intrinsic
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -18441,6 +18564,9 @@ would, but without setting errno. If the rounded value is too large to
be stored in the result type, the return value is a non-deterministic
value (equivalent to `freeze poison`).
+As a :ref:`floating-point operation <floatop>`, this function has side effects
+in a ``strictfp`` function.
+
'``llvm.llround.*``' Intrinsic
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -18478,6 +18604,9 @@ functions would, but without setting errno. If the rounded value is
too large to be stored in the result type, the return value is a
non-deterministic value (equivalent to `freeze poison`).
+As a :ref:`floating-point operation <floatop>`, this function has side effects
+in a ``strictfp`` function.
+
.. _int_lrint:
'``llvm.lrint.*``' Intrinsic
@@ -28045,13 +28174,6 @@ Constrained FP intrinsics are used to support non-default rounding modes and
accurately preserve exception behavior without compromising LLVM's ability to
optimize FP code when the default behavior is used.
-If any FP operation in a function is constrained then they all must be
-constrained. This is required for correct LLVM IR. Optimizations that
-move code around can create miscompiles if mixing of constrained and normal
-operations is done. The correct way to mix constrained and less constrained
-operations is to use the rounding mode and exception handling metadata to
-mark constrained intrinsics as having LLVM's default behavior.
-
Each of these intrinsics corresponds to a normal floating-point operation. The
data arguments and the return value are the same as the corresponding FP
operation.
diff --git a/llvm/docs/ReleaseNotes.md b/llvm/docs/ReleaseNotes.md
index 249ddc27fb3ea..6068eef48bc90 100644
--- a/llvm/docs/ReleaseNotes.md
+++ b/llvm/docs/ReleaseNotes.md
@@ -63,6 +63,9 @@ Changes to the LLVM IR
intrinsics. These are equivalent to `fptrunc` and `fpext` with half
with a bitcast.
+* Calls to floating-point intrinsics implicitly acquire side effects if
+ containing function has strictfp attribute.
+
* "denormal-fp-math" and "denormal-fp-math-f32" string attributes were
migrated to first-class denormal_fpenv attribute.
diff --git a/llvm/include/llvm/IR/FloatingPointOps.def b/llvm/include/llvm/IR/FloatingPointOps.def
new file mode 100644
index 0000000000000..e533689bd995e
--- /dev/null
+++ b/llvm/include/llvm/IR/FloatingPointOps.def
@@ -0,0 +1,72 @@
+//===- llvm/IR/FloatingPointOps.def - FP intrinsics -------------*- C++ -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+// Defines set of intrinsics, which are classified as floating-point operations.
+//
+//===----------------------------------------------------------------------===//
+
+// Describes floating-point operation.
+// Arguments of the entries are:
+// N - intrinsic function name,
+// R - true if the operation depends on rounding mode
+// ...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/188297
More information about the llvm-commits
mailing list