[llvm] r328098 - [LangRef] more hyphens: always write "floating-point"
Sanjay Patel via llvm-commits
llvm-commits at lists.llvm.org
Wed Mar 21 07:15:33 PDT 2018
Author: spatel
Date: Wed Mar 21 07:15:33 2018
New Revision: 328098
URL: http://llvm.org/viewvc/llvm-project?rev=328098&view=rev
Log:
[LangRef] more hyphens: always write "floating-point"
We were inconsistent, sometimes even within a single sentence.
The consensus seems clear that the FP we're looking for is
spelled "floating-point". Without the hyphen, it's a
"surprisingly fine" jazz album.
Modified:
llvm/trunk/docs/LangRef.rst
Modified: llvm/trunk/docs/LangRef.rst
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/docs/LangRef.rst?rev=328098&r1=328097&r2=328098&view=diff
==============================================================================
--- llvm/trunk/docs/LangRef.rst (original)
+++ llvm/trunk/docs/LangRef.rst Wed Mar 21 07:15:33 2018
@@ -324,9 +324,9 @@ added in the future:
limitations:
- On *X86-32* only supports up to 4 bit type parameters. No
- floating point types are supported.
+ floating-point types are supported.
- On *X86-64* only supports up to 10 bit type parameters and 6
- floating point parameters.
+ floating-point parameters.
This calling convention supports `tail call
optimization <CodeGenerator.html#id80>`_ but requires both the
@@ -1434,7 +1434,7 @@ example:
internal linkage and only has one call site, so the original
call is dead after inlining.
``noimplicitfloat``
- This attributes disables implicit floating point instructions.
+ This attributes disables implicit floating-point instructions.
``noinline``
This attribute indicates that the inliner should never inline this
function in any situation. This attribute may not be used together
@@ -1684,9 +1684,9 @@ example:
resulting function will have an ``sspstrong`` attribute.
``strictfp``
This attribute indicates that the function was called from a scope that
- requires strict floating point semantics. LLVM will not attempt any
- optimizations that require assumptions about the floating point rounding
- mode or that might alter the state of floating point status flags that
+ requires strict floating-point semantics. LLVM will not attempt any
+ optimizations that require assumptions about the floating-point rounding
+ mode or that might alter the state of floating-point status flags that
might otherwise be set or cleared by calling this function.
``"thunk"``
This attribute indicates that the function will delegate to some other
@@ -1938,7 +1938,7 @@ as follows:
This specifies the alignment for a vector type of a given bit
``<size>``.
``f<size>:<abi>:<pref>``
- This specifies the alignment for a floating point type of a given bit
+ This specifies the alignment for a floating-point type of a given bit
``<size>``. Only values of ``<size>`` that are supported by the target
will work. 32 (float) and 64 (double) are supported on all targets; 80
or 128 (different flavors of long double) are also supported on some
@@ -2361,7 +2361,7 @@ floating-point transformations.
``reassoc``
Allow reassociation transformations for floating-point instructions.
- This may dramatically change results in floating point.
+ This may dramatically change results in floating-point.
``fast``
This flag implies all of the others.
@@ -2550,7 +2550,7 @@ Examples:
.. _t_floating:
-Floating Point Types
+Floating-Point Types
""""""""""""""""""""
.. list-table::
@@ -2560,22 +2560,22 @@ Floating Point Types
- Description
* - ``half``
- - 16-bit floating point value
+ - 16-bit floating-point value
* - ``float``
- - 32-bit floating point value
+ - 32-bit floating-point value
* - ``double``
- - 64-bit floating point value
+ - 64-bit floating-point value
* - ``fp128``
- - 128-bit floating point value (112-bit mantissa)
+ - 128-bit floating-point value (112-bit mantissa)
* - ``x86_fp80``
- - 80-bit floating point value (X87)
+ - 80-bit floating-point value (X87)
* - ``ppc_fp128``
- - 128-bit floating point value (two 64-bits)
+ - 128-bit floating-point value (two 64-bits)
X86_mmx Type
""""""""""""
@@ -2650,7 +2650,7 @@ type. Vector types are considered :ref:`
< <# elements> x <elementtype> >
The number of elements is a constant integer value larger than 0;
-elementtype may be any integer, floating point or pointer type. Vectors
+elementtype may be any integer, floating-point or pointer type. Vectors
of size zero are not allowed.
:Examples:
@@ -2761,7 +2761,7 @@ Here are some examples of multidimension
+-----------------------------+----------------------------------------------------------+
| ``[3 x [4 x i32]]`` | 3x4 array of 32-bit integer values. |
+-----------------------------+----------------------------------------------------------+
-| ``[12 x [10 x float]]`` | 12x10 array of single precision floating point values. |
+| ``[12 x [10 x float]]`` | 12x10 array of single precision floating-point values. |
+-----------------------------+----------------------------------------------------------+
| ``[2 x [3 x [4 x i16]]]`` | 2x3x4 array of 16-bit integer values. |
+-----------------------------+----------------------------------------------------------+
@@ -2862,14 +2862,14 @@ Simple Constants
Standard integers (such as '4') are constants of the
:ref:`integer <t_integer>` type. Negative numbers may be used with
integer types.
-**Floating point constants**
- Floating point constants use standard decimal notation (e.g.
+**Floating-point constants**
+ Floating-point constants use standard decimal notation (e.g.
123.421), exponential notation (e.g. 1.23421e+2), or a more precise
hexadecimal notation (see below). The assembler requires the exact
decimal value of a floating-point constant. For example, the
assembler accepts 1.25 but rejects 1.3 because 1.3 is a repeating
- decimal in binary. Floating point constants must have a :ref:`floating
- point <t_floating>` type.
+ decimal in binary. Floating-point constants must have a
+ :ref:`floating-point <t_floating>` type.
**Null pointer constants**
The identifier '``null``' is recognized as a null pointer constant
and must be of :ref:`pointer type <t_pointer>`.
@@ -2878,12 +2878,12 @@ Simple Constants
and must be of :ref:`token type <t_token>`.
The one non-intuitive notation for constants is the hexadecimal form of
-floating point constants. For example, the form
+floating-point constants. For example, the form
'``double 0x432ff973cafa8000``' is equivalent to (but harder to read
-than) '``double 4.5e+15``'. The only time hexadecimal floating point
+than) '``double 4.5e+15``'. The only time hexadecimal floating-point
constants are required (and the only time that they are generated by the
-disassembler) is when a floating point constant must be emitted but it
-cannot be represented as a decimal floating point number in a reasonable
+disassembler) is when a floating-point constant must be emitted but it
+cannot be represented as a decimal floating-point number in a reasonable
number of digits. For example, NaN's, infinities, and other special
values are represented in their IEEE hexadecimal format so that assembly
and disassembly do not cause any bits to change in the constants.
@@ -3251,37 +3251,37 @@ The following is the syntax for constant
``sext (CST to TYPE)``
Perform the :ref:`sext operation <i_sext>` on constants.
``fptrunc (CST to TYPE)``
- Truncate a floating point constant to another floating point type.
+ Truncate a floating-point constant to another floating-point type.
The size of CST must be larger than the size of TYPE. Both types
- must be floating point.
+ must be floating-point.
``fpext (CST to TYPE)``
- Floating point extend a constant to another type. The size of CST
+ Floating-point extend a constant to another type. The size of CST
must be smaller or equal to the size of TYPE. Both types must be
- floating point.
+ floating-point.
``fptoui (CST to TYPE)``
- Convert a floating point constant to the corresponding unsigned
+ Convert a floating-point constant to the corresponding unsigned
integer constant. TYPE must be a scalar or vector integer type. CST
- must be of scalar or vector floating point type. Both CST and TYPE
+ must be of scalar or vector floating-point type. Both CST and TYPE
must be scalars, or vectors of the same number of elements. If the
value won't fit in the integer type, the results are undefined.
``fptosi (CST to TYPE)``
- Convert a floating point constant to the corresponding signed
+ Convert a floating-point constant to the corresponding signed
integer constant. TYPE must be a scalar or vector integer type. CST
- must be of scalar or vector floating point type. Both CST and TYPE
+ must be of scalar or vector floating-point type. Both CST and TYPE
must be scalars, or vectors of the same number of elements. If the
value won't fit in the integer type, the results are undefined.
``uitofp (CST to TYPE)``
- Convert an unsigned integer constant to the corresponding floating
- point constant. TYPE must be a scalar or vector floating point type.
- CST must be of scalar or vector integer type. Both CST and TYPE must
+ Convert an unsigned integer constant to the corresponding
+ floating-point constant. TYPE must be a scalar or vector floating-point
+ type. CST must be of scalar or vector integer type. Both CST and TYPE must
be scalars, or vectors of the same number of elements. If the value
- won't fit in the floating point type, the results are undefined.
+ won't fit in the floating-point type, the results are undefined.
``sitofp (CST to TYPE)``
- Convert a signed integer constant to the corresponding floating
- point constant. TYPE must be a scalar or vector floating point type.
+ Convert a signed integer constant to the corresponding floating-point
+ constant. TYPE must be a scalar or vector floating-point type.
CST must be of scalar or vector integer type. Both CST and TYPE must
be scalars, or vectors of the same number of elements. If the value
- won't fit in the floating point type, the results are undefined.
+ won't fit in the floating-point type, the results are undefined.
``ptrtoint (CST to TYPE)``
Perform the :ref:`ptrtoint operation <i_ptrtoint>` on constants.
``inttoptr (CST to TYPE)``
@@ -3330,7 +3330,7 @@ The following is the syntax for constant
may be any of the :ref:`binary <binaryops>` or :ref:`bitwise
binary <bitwiseops>` operations. The constraints on operands are
the same as those for the corresponding instruction (e.g. no bitwise
- operations on floating point values are allowed).
+ operations on floating-point values are allowed).
Other Values
============
@@ -3798,16 +3798,16 @@ PowerPC:
- ``wc``: An individual CR bit in a CR register.
- ``wa``, ``wd``, ``wf``: Any 128-bit VSX vector register, from the full VSX
register set (overlapping both the floating-point and vector register files).
-- ``ws``: A 32 or 64-bit floating point register, from the full VSX register
+- ``ws``: A 32 or 64-bit floating-point register, from the full VSX register
set.
Sparc:
- ``I``: An immediate 13-bit signed integer.
- ``r``: A 32-bit integer register.
-- ``f``: Any floating-point register on SparcV8, or a floating point
+- ``f``: Any floating-point register on SparcV8, or a floating-point
register in the "low" half of the registers on SparcV9.
-- ``e``: Any floating point register. (Same as ``f`` on SparcV8.)
+- ``e``: Any floating-point register. (Same as ``f`` on SparcV8.)
SystemZ:
@@ -3829,7 +3829,7 @@ SystemZ:
address context evaluates as zero).
- ``h``: A 32-bit value in the high part of a 64bit data register
(LLVM-specific)
-- ``f``: A 32, 64, or 128-bit floating point register.
+- ``f``: A 32, 64, or 128-bit floating-point register.
X86:
@@ -4895,7 +4895,7 @@ For example,
'``fpmath``' Metadata
^^^^^^^^^^^^^^^^^^^^^
-``fpmath`` metadata may be attached to any instruction of floating point
+``fpmath`` metadata may be attached to any instruction of floating-point
type. It can be used to express the maximum acceptable error in the
result of that instruction, in ULPs, thus potentially allowing the
compiler to use a more efficient but less accurate method of computing
@@ -6433,9 +6433,9 @@ The '``fadd``' instruction returns the s
Arguments:
""""""""""
-The two arguments to the '``fadd``' instruction must be :ref:`floating
-point <t_floating>` or :ref:`vector <t_vector>` of floating point values.
-Both arguments must have identical types.
+The two arguments to the '``fadd``' instruction must be
+:ref:`floating-point <t_floating>` or :ref:`vector <t_vector>` of
+floating-point values. Both arguments must have identical types.
Semantics:
""""""""""
@@ -6530,9 +6530,9 @@ instruction present in most other interm
Arguments:
""""""""""
-The two arguments to the '``fsub``' instruction must be :ref:`floating
-point <t_floating>` or :ref:`vector <t_vector>` of floating point values.
-Both arguments must have identical types.
+The two arguments to the '``fsub``' instruction must be
+:ref:`floating-point <t_floating>` or :ref:`vector <t_vector>` of
+floating-point values. Both arguments must have identical types.
Semantics:
""""""""""
@@ -6625,9 +6625,9 @@ The '``fmul``' instruction returns the p
Arguments:
""""""""""
-The two arguments to the '``fmul``' instruction must be :ref:`floating
-point <t_floating>` or :ref:`vector <t_vector>` of floating point values.
-Both arguments must have identical types.
+The two arguments to the '``fmul``' instruction must be
+:ref:`floating-point <t_floating>` or :ref:`vector <t_vector>` of
+floating-point values. Both arguments must have identical types.
Semantics:
""""""""""
@@ -6759,9 +6759,9 @@ The '``fdiv``' instruction returns the q
Arguments:
""""""""""
-The two arguments to the '``fdiv``' instruction must be :ref:`floating
-point <t_floating>` or :ref:`vector <t_vector>` of floating point values.
-Both arguments must have identical types.
+The two arguments to the '``fdiv``' instruction must be
+:ref:`floating-point <t_floating>` or :ref:`vector <t_vector>` of
+floating-point values. Both arguments must have identical types.
Semantics:
""""""""""
@@ -6902,9 +6902,9 @@ its two operands.
Arguments:
""""""""""
-The two arguments to the '``frem``' instruction must be :ref:`floating
-point <t_floating>` or :ref:`vector <t_vector>` of floating point values.
-Both arguments must have identical types.
+The two arguments to the '``frem``' instruction must be
+:ref:`floating-point <t_floating>` or :ref:`vector <t_vector>` of
+floating-point values. Both arguments must have identical types.
Semantics:
""""""""""
@@ -8354,8 +8354,8 @@ The '``fptrunc``' instruction truncates
Arguments:
""""""""""
-The '``fptrunc``' instruction takes a :ref:`floating point <t_floating>`
-value to cast and a :ref:`floating point <t_floating>` type to cast it to.
+The '``fptrunc``' instruction takes a :ref:`floating-point <t_floating>`
+value to cast and a :ref:`floating-point <t_floating>` type to cast it to.
The size of ``value`` must be larger than the size of ``ty2``. This
implies that ``fptrunc`` cannot be used to make a *no-op cast*.
@@ -8363,8 +8363,8 @@ Semantics:
""""""""""
The '``fptrunc``' instruction casts a ``value`` from a larger
-:ref:`floating point <t_floating>` type to a smaller :ref:`floating
-point <t_floating>` type. If the value cannot fit (i.e. overflows) within the
+:ref:`floating-point <t_floating>` type to a smaller :ref:`floating-point
+<t_floating>` type. If the value cannot fit (i.e. overflows) within the
destination type, ``ty2``, then the results are undefined. If the cast produces
an inexact result, how rounding is performed (e.g. truncation, also known as
round to zero) is undefined.
@@ -8390,24 +8390,24 @@ Syntax:
Overview:
"""""""""
-The '``fpext``' extends a floating point ``value`` to a larger floating
-point value.
+The '``fpext``' extends a floating-point ``value`` to a larger floating-point
+value.
Arguments:
""""""""""
-The '``fpext``' instruction takes a :ref:`floating point <t_floating>`
-``value`` to cast, and a :ref:`floating point <t_floating>` type to cast it
+The '``fpext``' instruction takes a :ref:`floating-point <t_floating>`
+``value`` to cast, and a :ref:`floating-point <t_floating>` type to cast it
to. The source type must be smaller than the destination type.
Semantics:
""""""""""
The '``fpext``' instruction extends the ``value`` from a smaller
-:ref:`floating point <t_floating>` type to a larger :ref:`floating
-point <t_floating>` type. The ``fpext`` cannot be used to make a
+:ref:`floating-point <t_floating>` type to a larger :ref:`floating-point
+<t_floating>` type. The ``fpext`` cannot be used to make a
*no-op cast* because it always changes bits. Use ``bitcast`` to make a
-*no-op cast* for a floating point cast.
+*no-op cast* for a floating-point cast.
Example:
""""""""
@@ -8430,23 +8430,23 @@ Syntax:
Overview:
"""""""""
-The '``fptoui``' converts a floating point ``value`` to its unsigned
+The '``fptoui``' converts a floating-point ``value`` to its unsigned
integer equivalent of type ``ty2``.
Arguments:
""""""""""
The '``fptoui``' instruction takes a value to cast, which must be a
-scalar or vector :ref:`floating point <t_floating>` value, and a type to
+scalar or vector :ref:`floating-point <t_floating>` value, and a type to
cast it to ``ty2``, which must be an :ref:`integer <t_integer>` type. If
-``ty`` is a vector floating point type, ``ty2`` must be a vector integer
+``ty`` is a vector floating-point type, ``ty2`` must be a vector integer
type with the same number of elements as ``ty``
Semantics:
""""""""""
-The '``fptoui``' instruction converts its :ref:`floating
-point <t_floating>` operand into the nearest (rounding towards zero)
+The '``fptoui``' instruction converts its :ref:`floating-point
+<t_floating>` operand into the nearest (rounding towards zero)
unsigned integer value. If the value cannot fit in ``ty2``, the results
are undefined.
@@ -8472,23 +8472,23 @@ Syntax:
Overview:
"""""""""
-The '``fptosi``' instruction converts :ref:`floating point <t_floating>`
+The '``fptosi``' instruction converts :ref:`floating-point <t_floating>`
``value`` to type ``ty2``.
Arguments:
""""""""""
The '``fptosi``' instruction takes a value to cast, which must be a
-scalar or vector :ref:`floating point <t_floating>` value, and a type to
+scalar or vector :ref:`floating-point <t_floating>` value, and a type to
cast it to ``ty2``, which must be an :ref:`integer <t_integer>` type. If
-``ty`` is a vector floating point type, ``ty2`` must be a vector integer
+``ty`` is a vector floating-point type, ``ty2`` must be a vector integer
type with the same number of elements as ``ty``
Semantics:
""""""""""
-The '``fptosi``' instruction converts its :ref:`floating
-point <t_floating>` operand into the nearest (rounding towards zero)
+The '``fptosi``' instruction converts its :ref:`floating-point
+<t_floating>` operand into the nearest (rounding towards zero)
signed integer value. If the value cannot fit in ``ty2``, the results
are undefined.
@@ -8522,16 +8522,16 @@ Arguments:
The '``uitofp``' instruction takes a value to cast, which must be a
scalar or vector :ref:`integer <t_integer>` value, and a type to cast it to
-``ty2``, which must be an :ref:`floating point <t_floating>` type. If
-``ty`` is a vector integer type, ``ty2`` must be a vector floating point
+``ty2``, which must be an :ref:`floating-point <t_floating>` type. If
+``ty`` is a vector integer type, ``ty2`` must be a vector floating-point
type with the same number of elements as ``ty``
Semantics:
""""""""""
The '``uitofp``' instruction interprets its operand as an unsigned
-integer quantity and converts it to the corresponding floating point
-value. If the value cannot fit in the floating point value, the results
+integer quantity and converts it to the corresponding floating-point
+value. If the value cannot fit in the floating-point value, the results
are undefined.
Example:
@@ -8563,16 +8563,16 @@ Arguments:
The '``sitofp``' instruction takes a value to cast, which must be a
scalar or vector :ref:`integer <t_integer>` value, and a type to cast it to
-``ty2``, which must be an :ref:`floating point <t_floating>` type. If
-``ty`` is a vector integer type, ``ty2`` must be a vector floating point
+``ty2``, which must be an :ref:`floating-point <t_floating>` type. If
+``ty`` is a vector integer type, ``ty2`` must be a vector floating-point
type with the same number of elements as ``ty``
Semantics:
""""""""""
The '``sitofp``' instruction interprets its operand as a signed integer
-quantity and converts it to the corresponding floating point value. If
-the value cannot fit in the floating point value, the results are
+quantity and converts it to the corresponding floating-point value. If
+the value cannot fit in the floating-point value, the results are
undefined.
Example:
@@ -8885,10 +8885,10 @@ Overview:
The '``fcmp``' instruction returns a boolean value or vector of boolean
values based on comparison of its operands.
-If the operands are floating point scalars, then the result type is a
+If the operands are floating-point scalars, then the result type is a
boolean (:ref:`i1 <t_integer>`).
-If the operands are floating point vectors, then the result type is a
+If the operands are floating-point vectors, then the result type is a
vector of boolean with the same number of elements as the operands being
compared.
@@ -8919,9 +8919,9 @@ not a value, just a keyword. The possibl
*Ordered* means that neither operand is a QNAN while *unordered* means
that either operand may be a QNAN.
-Each of ``val1`` and ``val2`` arguments must be either a :ref:`floating
-point <t_floating>` type or a :ref:`vector <t_vector>` of floating point
-type. They must have identical types.
+Each of ``val1`` and ``val2`` arguments must be either a :ref:`floating-point
+<t_floating>` type or a :ref:`vector <t_vector>` of floating-point type.
+They must have identical types.
Semantics:
""""""""""
@@ -8962,7 +8962,7 @@ always yields an :ref:`i1 <t_integer>` r
The ``fcmp`` instruction can also optionally take any number of
:ref:`fast-math flags <fastmath>`, which are optimization hints to enable
-otherwise unsafe floating point optimizations.
+otherwise unsafe floating-point optimizations.
Any set of fast-math flags are legal on an ``fcmp`` instruction, but the
only flags that have any effect on its semantics are those that allow
@@ -10610,7 +10610,7 @@ Syntax:
"""""""
This is an overloaded intrinsic. You can use ``llvm.powi`` on any
-floating point or vector of floating point type. Not all targets support
+floating-point or vector of floating-point type. Not all targets support
all types however.
::
@@ -10626,7 +10626,7 @@ Overview:
The '``llvm.powi.*``' intrinsics return the first operand raised to the
specified (positive or negative) power. The order of evaluation of
-multiplications is not defined. When a vector of floating point type is
+multiplications is not defined. When a vector of floating-point type is
used, the second argument remains a scalar integer value.
Arguments:
@@ -10987,7 +10987,7 @@ Syntax:
"""""""
This is an overloaded intrinsic. You can use ``llvm.fabs`` on any
-floating point or vector of floating point type. Not all targets support
+floating-point or vector of floating-point type. Not all targets support
all types however.
::
@@ -11007,7 +11007,7 @@ operand.
Arguments:
""""""""""
-The argument and return value are floating point numbers of the same
+The argument and return value are floating-point numbers of the same
type.
Semantics:
@@ -11023,7 +11023,7 @@ Syntax:
"""""""
This is an overloaded intrinsic. You can use ``llvm.minnum`` on any
-floating point or vector of floating point type. Not all targets support
+floating-point or vector of floating-point type. Not all targets support
all types however.
::
@@ -11044,7 +11044,7 @@ arguments.
Arguments:
""""""""""
-The arguments and return value are floating point numbers of the same
+The arguments and return value are floating-point numbers of the same
type.
Semantics:
@@ -11065,7 +11065,7 @@ Syntax:
"""""""
This is an overloaded intrinsic. You can use ``llvm.maxnum`` on any
-floating point or vector of floating point type. Not all targets support
+floating-point or vector of floating-point type. Not all targets support
all types however.
::
@@ -11086,7 +11086,7 @@ arguments.
Arguments:
""""""""""
-The arguments and return value are floating point numbers of the same
+The arguments and return value are floating-point numbers of the same
type.
Semantics:
@@ -11106,7 +11106,7 @@ Syntax:
"""""""
This is an overloaded intrinsic. You can use ``llvm.copysign`` on any
-floating point or vector of floating point type. Not all targets support
+floating-point or vector of floating-point type. Not all targets support
all types however.
::
@@ -11126,7 +11126,7 @@ first operand and the sign of the second
Arguments:
""""""""""
-The arguments and return value are floating point numbers of the same
+The arguments and return value are floating-point numbers of the same
type.
Semantics:
@@ -11142,7 +11142,7 @@ Syntax:
"""""""
This is an overloaded intrinsic. You can use ``llvm.floor`` on any
-floating point or vector of floating point type. Not all targets support
+floating-point or vector of floating-point type. Not all targets support
all types however.
::
@@ -11161,7 +11161,7 @@ The '``llvm.floor.*``' intrinsics return
Arguments:
""""""""""
-The argument and return value are floating point numbers of the same
+The argument and return value are floating-point numbers of the same
type.
Semantics:
@@ -11177,7 +11177,7 @@ Syntax:
"""""""
This is an overloaded intrinsic. You can use ``llvm.ceil`` on any
-floating point or vector of floating point type. Not all targets support
+floating-point or vector of floating-point type. Not all targets support
all types however.
::
@@ -11196,7 +11196,7 @@ The '``llvm.ceil.*``' intrinsics return
Arguments:
""""""""""
-The argument and return value are floating point numbers of the same
+The argument and return value are floating-point numbers of the same
type.
Semantics:
@@ -11212,7 +11212,7 @@ Syntax:
"""""""
This is an overloaded intrinsic. You can use ``llvm.trunc`` on any
-floating point or vector of floating point type. Not all targets support
+floating-point or vector of floating-point type. Not all targets support
all types however.
::
@@ -11232,7 +11232,7 @@ nearest integer not larger in magnitude
Arguments:
""""""""""
-The argument and return value are floating point numbers of the same
+The argument and return value are floating-point numbers of the same
type.
Semantics:
@@ -11248,7 +11248,7 @@ Syntax:
"""""""
This is an overloaded intrinsic. You can use ``llvm.rint`` on any
-floating point or vector of floating point type. Not all targets support
+floating-point or vector of floating-point type. Not all targets support
all types however.
::
@@ -11269,7 +11269,7 @@ operand isn't an integer.
Arguments:
""""""""""
-The argument and return value are floating point numbers of the same
+The argument and return value are floating-point numbers of the same
type.
Semantics:
@@ -11285,7 +11285,7 @@ Syntax:
"""""""
This is an overloaded intrinsic. You can use ``llvm.nearbyint`` on any
-floating point or vector of floating point type. Not all targets support
+floating-point or vector of floating-point type. Not all targets support
all types however.
::
@@ -11305,7 +11305,7 @@ nearest integer.
Arguments:
""""""""""
-The argument and return value are floating point numbers of the same
+The argument and return value are floating-point numbers of the same
type.
Semantics:
@@ -11321,7 +11321,7 @@ Syntax:
"""""""
This is an overloaded intrinsic. You can use ``llvm.round`` on any
-floating point or vector of floating point type. Not all targets support
+floating-point or vector of floating-point type. Not all targets support
all types however.
::
@@ -11341,7 +11341,7 @@ nearest integer.
Arguments:
""""""""""
-The argument and return value are floating point numbers of the same
+The argument and return value are floating-point numbers of the same
type.
Semantics:
@@ -11894,7 +11894,7 @@ Overview:
"""""""""
The '``llvm.canonicalize.*``' intrinsic returns the platform specific canonical
-encoding of a floating point number. This canonicalization is useful for
+encoding of a floating-point number. This canonicalization is useful for
implementing certain numeric primitives such as frexp. The canonical encoding is
defined by IEEE-754-2008 to be:
@@ -11912,7 +11912,7 @@ Examples of non-canonical encodings:
- x87 pseudo denormals, pseudo NaNs, pseudo Infinity, Unnormals. These are
converted to a canonical representation per hardware-specific protocol.
-- Many normal decimal floating point numbers have non-canonical alternative
+- Many normal decimal floating-point numbers have non-canonical alternative
encodings.
- Some machines, like GPUs or ARMv7 NEON, do not support subnormal values.
These are treated as non-canonical encodings of zero and will be flushed to
@@ -11946,7 +11946,7 @@ The canonicalization operation may be op
- The input is known to be canonical. For example, it was produced by a
floating-point operation that is required by the standard to be canonical.
- The result is consumed only by (or fused with) other floating-point
- operations. That is, the bits of the floating point value are not examined.
+ operations. That is, the bits of the floating-point value are not examined.
'``llvm.fmuladd.*``' Intrinsic
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -12043,7 +12043,7 @@ Syntax:
Overview:
"""""""""
-The '``llvm.experimental.vector.reduce.fadd.*``' intrinsics do a floating point
+The '``llvm.experimental.vector.reduce.fadd.*``' intrinsics do a floating-point
``ADD`` reduction of a vector, returning the result as a scalar. The return type
matches the element-type of the vector input.
@@ -12059,7 +12059,7 @@ The first argument to this intrinsic is
only used when there are no fast-math flags attached. This argument may be undef
when fast-math flags are used.
-The second argument must be a vector of floating point values.
+The second argument must be a vector of floating-point values.
Examples:
"""""""""
@@ -12106,7 +12106,7 @@ Syntax:
Overview:
"""""""""
-The '``llvm.experimental.vector.reduce.fmul.*``' intrinsics do a floating point
+The '``llvm.experimental.vector.reduce.fmul.*``' intrinsics do a floating-point
``MUL`` reduction of a vector, returning the result as a scalar. The return type
matches the element-type of the vector input.
@@ -12122,7 +12122,7 @@ The first argument to this intrinsic is
only used when there are no fast-math flags attached. This argument may be undef
when fast-math flags are used.
-The second argument must be a vector of floating point values.
+The second argument must be a vector of floating-point values.
Examples:
"""""""""
@@ -12293,7 +12293,7 @@ Syntax:
Overview:
"""""""""
-The '``llvm.experimental.vector.reduce.fmax.*``' intrinsics do a floating point
+The '``llvm.experimental.vector.reduce.fmax.*``' intrinsics do a floating-point
``MAX`` reduction of a vector, returning the result as a scalar. The return type
matches the element-type of the vector input.
@@ -12302,7 +12302,7 @@ assume that NaNs are not present in the
Arguments:
""""""""""
-The argument to this intrinsic must be a vector of floating point values.
+The argument to this intrinsic must be a vector of floating-point values.
'``llvm.experimental.vector.reduce.fmin.*``' Intrinsic
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -12318,7 +12318,7 @@ Syntax:
Overview:
"""""""""
-The '``llvm.experimental.vector.reduce.fmin.*``' intrinsics do a floating point
+The '``llvm.experimental.vector.reduce.fmin.*``' intrinsics do a floating-point
``MIN`` reduction of a vector, returning the result as a scalar. The return type
matches the element-type of the vector input.
@@ -12327,16 +12327,16 @@ assume that NaNs are not present in the
Arguments:
""""""""""
-The argument to this intrinsic must be a vector of floating point values.
+The argument to this intrinsic must be a vector of floating-point values.
-Half Precision Floating Point Intrinsics
+Half Precision Floating-Point Intrinsics
----------------------------------------
-For most target platforms, half precision floating point is a
+For most target platforms, half precision floating-point is a
storage-only format. This means that it is a dense encoding (in memory)
but does not support computation in the format.
-This means that code must first load the half-precision floating point
+This means that code must first load the half-precision floating-point
value as an i16, then convert it to float with
:ref:`llvm.convert.from.fp16 <int_convert_from_fp16>`. Computation can
then be performed on the float value (including extending to double
@@ -12362,7 +12362,7 @@ Overview:
"""""""""
The '``llvm.convert.to.fp16``' intrinsic function performs a conversion from a
-conventional floating point type to half precision floating point format.
+conventional floating-point type to half precision floating-point format.
Arguments:
""""""""""
@@ -12374,7 +12374,7 @@ Semantics:
""""""""""
The '``llvm.convert.to.fp16``' intrinsic function performs a conversion from a
-conventional floating point format to half precision floating point format. The
+conventional floating-point format to half precision floating-point format. The
return value is an ``i16`` which contains the converted number.
Examples:
@@ -12402,8 +12402,8 @@ Overview:
"""""""""
The '``llvm.convert.from.fp16``' intrinsic function performs a
-conversion from half precision floating point format to single precision
-floating point format.
+conversion from half precision floating-point format to single precision
+floating-point format.
Arguments:
""""""""""
@@ -12415,8 +12415,8 @@ Semantics:
""""""""""
The '``llvm.convert.from.fp16``' intrinsic function performs a
-conversion from half single precision floating point format to single
-precision floating point format. The input half-float value is
+conversion from half single precision floating-point format to single
+precision floating-point format. The input half-float value is
represented by an ``i16`` value.
Examples:
@@ -12567,7 +12567,7 @@ LLVM provides intrinsics for predicated
Syntax:
"""""""
-This is an overloaded intrinsic. The loaded data is a vector of any integer, floating point or pointer data type.
+This is an overloaded intrinsic. The loaded data is a vector of any integer, floating-point or pointer data type.
::
@@ -12612,7 +12612,7 @@ The result of this operation is equivale
Syntax:
"""""""
-This is an overloaded intrinsic. The data stored in memory is a vector of any integer, floating point or pointer data type.
+This is an overloaded intrinsic. The data stored in memory is a vector of any integer, floating-point or pointer data type.
::
@@ -12662,7 +12662,7 @@ LLVM provides intrinsics for vector gath
Syntax:
"""""""
-This is an overloaded intrinsic. The loaded data are multiple scalar values of any integer, floating point or pointer data type gathered together into one vector.
+This is an overloaded intrinsic. The loaded data are multiple scalar values of any integer, floating-point or pointer data type gathered together into one vector.
::
@@ -12716,7 +12716,7 @@ The semantics of this operation are equi
Syntax:
"""""""
-This is an overloaded intrinsic. The data stored in memory is a vector of any integer, floating point or pointer data type. Each vector element is stored in an arbitrary memory address. Scatter with overlapping addresses is guaranteed to be ordered from least-significant to most-significant element.
+This is an overloaded intrinsic. The data stored in memory is a vector of any integer, floating-point or pointer data type. Each vector element is stored in an arbitrary memory address. Scatter with overlapping addresses is guaranteed to be ordered from least-significant to most-significant element.
::
@@ -12929,18 +12929,18 @@ for the purposes of ``load``/``store`` `
.. _constrainedfp:
-Constrained Floating Point Intrinsics
+Constrained Floating-Point Intrinsics
-------------------------------------
-These intrinsics are used to provide special handling of floating point
-operations when specific rounding mode or floating point exception behavior is
+These intrinsics are used to provide special handling of floating-point
+operations when specific rounding mode or floating-point exception behavior is
required. By default, LLVM optimization passes assume that the rounding mode is
-round-to-nearest and that floating point exceptions will not be monitored.
+round-to-nearest and that floating-point exceptions will not be monitored.
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.
-Each of these intrinsics corresponds to a normal floating point operation. The
+Each of these intrinsics corresponds to a normal floating-point operation. The
first two arguments and the return value are the same as the corresponding FP
operation.
@@ -12975,7 +12975,7 @@ the specified rounding mode, but this is
non-dynamic rounding mode which does not match the actual rounding mode at
runtime results in undefined behavior.
-The fourth argument to the constrained floating point intrinsics specifies the
+The fourth argument to the constrained floating-point intrinsics specifies the
required exception behavior. This argument must be one of the following
strings:
@@ -12986,7 +12986,7 @@ strings:
"fpexcept.strict"
If this argument is "fpexcept.ignore" optimization passes may assume that the
-exception status flags will not be read and that floating point exceptions will
+exception status flags will not be read and that floating-point exceptions will
be masked. This allows transformations to be performed that may change the
exception semantics of the original code. For example, FP operations may be
speculatively executed in this case whereas they must not be for either of the
@@ -13000,7 +13000,7 @@ original code. For example, exceptions
folding.
If the exception behavior argument is "fpexcept.strict" all transformations must
-strictly preserve the floating point exception semantics of the original code.
+strictly preserve the floating-point exception semantics of the original code.
Any FP exception that would have been raised by the original code must be raised
by the transformed code, and the transformed code must not raise any FP
exceptions that would not have been raised by the original code. This is the
@@ -13008,7 +13008,7 @@ exception behavior argument that will be
the FP exception status flags, but this mode can also be used with code that
unmasks FP exceptions.
-The number and order of floating point exceptions is NOT guaranteed. For
+The number and order of floating-point exceptions is NOT guaranteed. For
example, a series of FP operations that each may raise exceptions may be
vectorized into a single instruction that raises each unique exception a single
time.
@@ -13038,8 +13038,8 @@ Arguments:
""""""""""
The first two arguments to the '``llvm.experimental.constrained.fadd``'
-intrinsic must be :ref:`floating point <t_floating>` or :ref:`vector <t_vector>`
-of floating point values. Both arguments must have identical types.
+intrinsic must be :ref:`floating-point <t_floating>` or :ref:`vector <t_vector>`
+of floating-point values. Both arguments must have identical types.
The third and fourth arguments specify the rounding mode and exception
behavior as described above.
@@ -13047,7 +13047,7 @@ behavior as described above.
Semantics:
""""""""""
-The value produced is the floating point sum of the two value operands and has
+The value produced is the floating-point sum of the two value operands and has
the same type as the operands.
@@ -13075,8 +13075,8 @@ Arguments:
""""""""""
The first two arguments to the '``llvm.experimental.constrained.fsub``'
-intrinsic must be :ref:`floating point <t_floating>` or :ref:`vector <t_vector>`
-of floating point values. Both arguments must have identical types.
+intrinsic must be :ref:`floating-point <t_floating>` or :ref:`vector <t_vector>`
+of floating-point values. Both arguments must have identical types.
The third and fourth arguments specify the rounding mode and exception
behavior as described above.
@@ -13084,7 +13084,7 @@ behavior as described above.
Semantics:
""""""""""
-The value produced is the floating point difference of the two value operands
+The value produced is the floating-point difference of the two value operands
and has the same type as the operands.
@@ -13112,8 +13112,8 @@ Arguments:
""""""""""
The first two arguments to the '``llvm.experimental.constrained.fmul``'
-intrinsic must be :ref:`floating point <t_floating>` or :ref:`vector <t_vector>`
-of floating point values. Both arguments must have identical types.
+intrinsic must be :ref:`floating-point <t_floating>` or :ref:`vector <t_vector>`
+of floating-point values. Both arguments must have identical types.
The third and fourth arguments specify the rounding mode and exception
behavior as described above.
@@ -13121,7 +13121,7 @@ behavior as described above.
Semantics:
""""""""""
-The value produced is the floating point product of the two value operands and
+The value produced is the floating-point product of the two value operands and
has the same type as the operands.
@@ -13149,8 +13149,8 @@ Arguments:
""""""""""
The first two arguments to the '``llvm.experimental.constrained.fdiv``'
-intrinsic must be :ref:`floating point <t_floating>` or :ref:`vector <t_vector>`
-of floating point values. Both arguments must have identical types.
+intrinsic must be :ref:`floating-point <t_floating>` or :ref:`vector <t_vector>`
+of floating-point values. Both arguments must have identical types.
The third and fourth arguments specify the rounding mode and exception
behavior as described above.
@@ -13158,7 +13158,7 @@ behavior as described above.
Semantics:
""""""""""
-The value produced is the floating point quotient of the two value operands and
+The value produced is the floating-point quotient of the two value operands and
has the same type as the operands.
@@ -13186,18 +13186,18 @@ Arguments:
""""""""""
The first two arguments to the '``llvm.experimental.constrained.frem``'
-intrinsic must be :ref:`floating point <t_floating>` or :ref:`vector <t_vector>`
-of floating point values. Both arguments must have identical types.
+intrinsic must be :ref:`floating-point <t_floating>` or :ref:`vector <t_vector>`
+of floating-point values. Both arguments must have identical types.
The third and fourth arguments specify the rounding mode and exception
behavior as described above. The rounding mode argument has no effect, since
the result of frem is never rounded, but the argument is included for
-consistency with the other constrained floating point intrinsics.
+consistency with the other constrained floating-point intrinsics.
Semantics:
""""""""""
-The value produced is the floating point remainder from the division of the two
+The value produced is the floating-point remainder from the division of the two
value operands and has the same type as the operands. The remainder has the
same sign as the dividend.
@@ -13224,8 +13224,8 @@ Arguments:
""""""""""
The first three arguments to the '``llvm.experimental.constrained.fma``'
-intrinsic must be :ref:`floating point <t_floating>` or :ref:`vector
-<t_vector>` of floating point values. All arguments must have identical types.
+intrinsic must be :ref:`floating-point <t_floating>` or :ref:`vector
+<t_vector>` of floating-point values. All arguments must have identical types.
The fourth and fifth arguments specify the rounding mode and exception behavior
as described above.
@@ -13240,15 +13240,15 @@ precision.
Constrained libm-equivalent Intrinsics
--------------------------------------
-In addition to the basic floating point operations for which constrained
+In addition to the basic floating-point operations for which constrained
intrinsics are described above, there are constrained versions of various
operations which provide equivalent behavior to a corresponding libm function.
These intrinsics allow the precise behavior of these operations with respect to
rounding mode and exception behavior to be controlled.
-As with the basic constrained floating point intrinsics, the rounding mode
+As with the basic constrained floating-point intrinsics, the rounding mode
and exception behavior arguments only control the behavior of the optimizer.
-They do not change the runtime floating point environment.
+They do not change the runtime floating-point environment.
'``llvm.experimental.constrained.sqrt``' Intrinsic
@@ -13274,7 +13274,7 @@ functions would, but without setting ``e
Arguments:
""""""""""
-The first argument and the return type are floating point numbers of the same
+The first argument and the return type are floating-point numbers of the same
type.
The second and third arguments specify the rounding mode and exception
@@ -13284,7 +13284,7 @@ Semantics:
""""""""""
This function returns the nonnegative square root of the specified value.
-If the value is less than negative zero, a floating point exception occurs
+If the value is less than negative zero, a floating-point exception occurs
and the return value is architecture specific.
@@ -13310,7 +13310,7 @@ raised to the (positive or negative) pow
Arguments:
""""""""""
-The first two arguments and the return value are floating point numbers of the
+The first two arguments and the return value are floating-point numbers of the
same type. The second argument specifies the power to which the first argument
should be raised.
@@ -13343,14 +13343,14 @@ Overview:
The '``llvm.experimental.constrained.powi``' intrinsic returns the first operand
raised to the (positive or negative) power specified by the second operand. The
-order of evaluation of multiplications is not defined. When a vector of floating
-point type is used, the second argument remains a scalar integer value.
+order of evaluation of multiplications is not defined. When a vector of
+floating-point type is used, the second argument remains a scalar integer value.
Arguments:
""""""""""
-The first argument and the return value are floating point numbers of the same
+The first argument and the return value are floating-point numbers of the same
type. The second argument is a 32-bit signed integer specifying the power to
which the first argument should be raised.
@@ -13386,7 +13386,7 @@ first operand.
Arguments:
""""""""""
-The first argument and the return type are floating point numbers of the same
+The first argument and the return type are floating-point numbers of the same
type.
The second and third arguments specify the rounding mode and exception
@@ -13422,7 +13422,7 @@ first operand.
Arguments:
""""""""""
-The first argument and the return type are floating point numbers of the same
+The first argument and the return type are floating-point numbers of the same
type.
The second and third arguments specify the rounding mode and exception
@@ -13458,7 +13458,7 @@ exponential of the specified value.
Arguments:
""""""""""
-The first argument and the return value are floating point numbers of the same
+The first argument and the return value are floating-point numbers of the same
type.
The second and third arguments specify the rounding mode and exception
@@ -13494,7 +13494,7 @@ exponential of the specified value.
Arguments:
""""""""""
-The first argument and the return value are floating point numbers of the same
+The first argument and the return value are floating-point numbers of the same
type.
The second and third arguments specify the rounding mode and exception
@@ -13529,7 +13529,7 @@ logarithm of the specified value.
Arguments:
""""""""""
-The first argument and the return value are floating point numbers of the same
+The first argument and the return value are floating-point numbers of the same
type.
The second and third arguments specify the rounding mode and exception
@@ -13565,7 +13565,7 @@ logarithm of the specified value.
Arguments:
""""""""""
-The first argument and the return value are floating point numbers of the same
+The first argument and the return value are floating-point numbers of the same
type.
The second and third arguments specify the rounding mode and exception
@@ -13600,7 +13600,7 @@ logarithm of the specified value.
Arguments:
""""""""""
-The first argument and the return value are floating point numbers of the same
+The first argument and the return value are floating-point numbers of the same
type.
The second and third arguments specify the rounding mode and exception
@@ -13630,13 +13630,13 @@ Overview:
"""""""""
The '``llvm.experimental.constrained.rint``' intrinsic returns the first
-operand rounded to the nearest integer. It may raise an inexact floating point
+operand rounded to the nearest integer. It may raise an inexact floating-point
exception if the operand is not an integer.
Arguments:
""""""""""
-The first argument and the return value are floating point numbers of the same
+The first argument and the return value are floating-point numbers of the same
type.
The second and third arguments specify the rounding mode and exception
@@ -13648,7 +13648,7 @@ Semantics:
This function returns the same values as the libm ``rint`` functions
would, and handles error conditions in the same way. The rounding mode is
described, not determined, by the rounding mode argument. The actual rounding
-mode is determined by the runtime floating point environment. The rounding
+mode is determined by the runtime floating-point environment. The rounding
mode argument is only intended as information to the compiler.
@@ -13669,14 +13669,14 @@ Overview:
"""""""""
The '``llvm.experimental.constrained.nearbyint``' intrinsic returns the first
-operand rounded to the nearest integer. It will not raise an inexact floating
-point exception if the operand is not an integer.
+operand rounded to the nearest integer. It will not raise an inexact
+floating-point exception if the operand is not an integer.
Arguments:
""""""""""
-The first argument and the return value are floating point numbers of the same
+The first argument and the return value are floating-point numbers of the same
type.
The second and third arguments specify the rounding mode and exception
@@ -13688,7 +13688,7 @@ Semantics:
This function returns the same values as the libm ``nearbyint`` functions
would, and handles error conditions in the same way. The rounding mode is
described, not determined, by the rounding mode argument. The actual rounding
-mode is determined by the runtime floating point environment. The rounding
+mode is determined by the runtime floating-point environment. The rounding
mode argument is only intended as information to the compiler.
More information about the llvm-commits
mailing list