From 74391aff91acfd28508f7af38baf25dfb9af5ae8 Mon Sep 17 00:00:00 2001 From: Ajaykumar Kannan Date: Fri, 19 Jun 2020 11:47:50 -0400 Subject: [PATCH 01/19] [SYCL] Floating point and fixed point operations added to SPIR-V --- ...L_arbitrary_precision_fixed_point.asciidoc | 501 +++++++ ...rbitrary_precision_floating_point.asciidoc | 1280 +++++++++++++++++ 2 files changed, 1781 insertions(+) create mode 100755 sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_fixed_point.asciidoc create mode 100755 sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_floating_point.asciidoc diff --git a/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_fixed_point.asciidoc b/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_fixed_point.asciidoc new file mode 100755 index 0000000000000..9da572e8525bd --- /dev/null +++ b/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_fixed_point.asciidoc @@ -0,0 +1,501 @@ += SPV_INTEL_arbitrary_precision_fixed_point + +== Name Strings + +SPV_INTEL_arbitrary_precision_fixed_point + +== Contact + +To report problems with this extension, please open a new issue at: + +https://github.com/KhronosGroup/SPIRV-Headers + +== Contributors + +Ajaykumar Kannan, Intel + +== Notice + +Copyright (c) 2020 Intel Corporation. All rights reserved. + +== Status + +Initial Release + +== Version + +[width="40%",cols="25,25"] +|======================================== +| Last Modified Date | {docdate} +| Revision | 1 +|======================================== + +== Dependencies + +This extension is written against the SPIR-V Specification Version 1.5, Revision 2. + +This extension depends on the SPV_INTEL_arbitrary_precision_int spec. + +This extension is built on Mentor Graphics ac_datatypes spec v3.9.2. + +== Overview + +This extension introduces operations for arbitrary precision fixed point numbers called ac_fixed. +The ac_fixed datatype is an industry standard for fixed point numbers and is published by Mentor Graphics at https://hlslibs.org[hlslibs.org]. +This datatype and its corresponding operations can be useful on targets that can take advantage of narrower representation such as FPGAs. + +=== Data Representation + +The ac_fixed datatype will be represented in SPIR-V as a _pseudo type_ using `OpTypeInt`. +It requires three parameters, `W`, `I`, and `S`. + +* `W` is the total width of the datatype (including a sign bit, if required) and is encoded in the width of the `OpTypeInt`. +* `I` determines the position of the decimal point. +* `S` determines if this is a signed or an unsigned number. Note that the support for signedness in `OpTypeInt` is not leveraged here. If the ac_fixed is signed, then the MSB (most significant bit) will contain the sign bit. + +The datatype itself does not contain any information regarding `I` and `S`. +Each operation will contain information about the input and result datatypes (including `W`, `S`, and `I`) where `W` is implicit from the size of the `OpTypeInt`. + +ac_fixed can contain both an integer component and a fractional component depending on the value of `I`. +Based on its value, the number of bits allocated for the integer and fractional portions will change. +Note that it is also possible that one of two portions may have no bits. + +The data layout is shown below: + +`[ 1'b sign (if signed) ] [ I'b integer portion ] [ (W-I)'b fractional portion ]` + +== Extension Name + +To use this extension within a SPIR-V module, the following *OpExtension* must be present in the module: + +---- +OpExtension "SPV_INTEL_arbitrary_precision_fixed_point" +---- + +== New Capabilities + +This extension introduces a new capability: + +---- +ArbitraryPrecisionFixedPointINTEL +---- + +== New Instructions + +Instructions added under the *ArbitraryPrecisionFixedPointINTEL* capability: + +---- +OpFixedSqrtINTEL +OpFixedRecipINTEL +OpFixedRsqrtINTEL +OpFixedSinINTEL +OpFixedCosINTEL +OpFixedSinCosINTEL +OpFixedSinPiINTEL +OpFixedCosPiINTEL +OpFixedSinCosPiINTEL +OpFixedLogINTEL +OpFixedExpINTEL +---- + +== Token Number Assignments +[width="40%"] +[cols="70%,30%"] +[grid="rows"] +|==== +|`ArbitraryPrecisionFixedPointINTEL` | 5922 +|`OpFixedSqrtINTEL` | 5923 +|`OpFixedRecipINTEL` | 5924 +|`OpFixedRsqrtINTEL` | 5925 +|`OpFixedSinINTEL` | 5926 +|`OpFixedCosINTEL` | 5927 +|`OpFixedSinCosINTEL` | 5928 +|`OpFixedSinPiINTEL` | 5929 +|`OpFixedCosPiINTEL` | 5930 +|`OpFixedSinCosPiINTEL` | 5931 +|`OpFixedLogINTEL` | 5932 +|`OpFixedExpINTEL` | 5933 +|==== + + +== Modifications to the SPIR-V Specification Version 1.5 + +After Section 3.16, add a new section "3.16b Quantization Modes" as follows: + +=== Quantization Modes +[options="header"] +[width="80%"] +[cols="15%,20%,65%"] +|==== +| Value ^| Mode ^| Behavior +| 0 | TRN | Truncate towards -Inf +| 1 | TRN_ZERO | Truncate towards 0 +| 2 | RND | Round towards +Inf +| 3 | RND_ZERO | Round towards 0 +| 4 | RND_INF | Round towards +/-Inf +| 5 | RND_MIN_INF | Round towards -Inf +| 6 | RND_CONV | Round towards even +| 7 | RND_CONV_ODD | Round towards odd +|==== + +After Section 3.16, add a new section "3.16c Overflow Modes" as follows: + +=== Overflow Modes +[options="header"] +[width="80%"] +[cols="15%,20%,65%"] +|==== +| Value ^| Mode ^| Behavior +| 0 | WRAP | Drop the bits to the left of the MSB +| 1 | SAT | Saturate to the closest of MIN or MAX +| 2 | SAT_ZERO | Set to 0 on overflow +| 3 | SAT_SYM | For unsigned, treat as SAT. + + +For signed: a positive overflow will saturate at the maximum positive value, whereas a negative overflow will saturate to the negation of the maximum positive value, as opposed to the most negative value. +|==== + +=== Capability +Modify Section 3.31, *Capability*, adding a row to the Capability table: + +[options="header"] +|==== +2+^| Capability ^| Implicitly Declares +| 5922 | *ArbitraryPrecisionFixedPointINTEL* + + +Enables arbitrary precision fixed-point math instructions +| *INTELArbitraryPrecisionIntegers* +|==== + +=== Instructions + +In Section 3.32.13, *Arithmetic Instructions*, add the following instructions: + +[cols="11", width="100%"] +|===== +10+<|*OpFixedSqrtINTEL* + + +An `OpTypeInt` representing an arbitrary precision fixed point number (ac_fixed) is passed in as the _Input_ and the square root of the value is returned in _Result_. +The behavior of this function is undefined for input values < 0. + +_Result Type_ is an `OpTypeInt` of width _rW_ and is the type of _Result_. + +_Input Type_ is an `OpTypeInt` of width _W_ and is the type of _Input_. + +_S_ is an `OpTypeBool` that indicates if the input and output are signed or unsigned. +A value of `1` indicates that the two types are signed. +Note that the operation does not use the signedness capabilities of `OpTypeInt`. + +_I_ is an `OpTypeInt` that refers to the location of the fixed-point relative to the MSB of the input. + +_rI_ is an `OpTypeInt` that refers to the location of the fixed-point relative to the MSB of the result. + +_Q_ is an `OpTypeInt` chosen from _Table 3.16b_ that indicates the Quantization Mode of this operation. + +_O_ is an `OpTypeInt` chosen from _Table 3.16c_ that indicates the Overflow Mode of this operation. + +| Capability: +*ArbitraryPrecisionFixedPointINTEL* + +| 10 | 5923 | Result Type | Result | Input Type | Input | _Literal_ S | _Literal_ I | _Literal_ rI | _Literal_ Q | _Literal_ O +|===== + +[cols="11", width="100%"] +|===== +10+<|*OpFixedRecipINTEL* + + +An `OpTypeInt` representing an arbitrary precision fixed point number (ac_fixed) is passed in as the _Input_ and the reciprocal (`1/Input`) of the value is returned in _Result_. + +_Result Type_ is an `OpTypeInt` of width _rW_ and is the type of _Result_. + +_Input Type_ is an `OpTypeInt` of width _W_ and is the type of _Input_. + +_S_ is an `OpTypeBool` that indicates if the input and output are signed or unsigned. +A value of `1` indicates that the two types are signed. +Note that the operation does not use the signedness capabilities of `OpTypeInt`. + +_I_ is an `OpTypeInt` that refers to the location of the fixed-point relative to the MSB of the input. + +_rI_ is an `OpTypeInt` that refers to the location of the fixed-point relative to the MSB of the result. + +_Q_ is an `OpTypeInt` chosen from _Table 3.16b_ that indicates the Quantization Mode of this operation. + +_O_ is an `OpTypeInt` chosen from _Table 3.16c_ that indicates the Overflow Mode of this operation. + +| Capability: +*ArbitraryPrecisionFixedPointINTEL* + +| 10 | 5924 | Result Type | Result | Input Type | Input | _Literal_ S | _Literal_ I | _Literal_ rI | _Literal_ Q | _Literal_ O +|===== + +[cols="11", width="100%"] +|===== +10+<|*OpFixedRsqrtINTEL* + + +An `OpTypeInt` representing an arbitrary precision fixed point number (ac_fixed) is passed in as the _Input_ and the reciprocal square root (`1/sqrt(Input)`) of the value is returned in _Result_. +The behavior of this function is undefined for input values < 0. + +_Result Type_ is an `OpTypeInt` of width _rW_ and is the type of _Result_. + +_Input Type_ is an `OpTypeInt` of width _W_ and is the type of _Input_. + +_S_ is an `OpTypeBool` that indicates if the input and output are signed or unsigned. +A value of `1` indicates that the two types are signed. +Note that the operation does not use the signedness capabilities of `OpTypeInt`. + +_I_ is an `OpTypeInt` that refers to the location of the fixed-point relative to the MSB of the input. + +_rI_ is an `OpTypeInt` that refers to the location of the fixed-point relative to the MSB of the result. + +_Q_ is an `OpTypeInt` chosen from _Table 3.16b_ that indicates the Quantization Mode of this operation. + +_O_ is an `OpTypeInt` chosen from _Table 3.16c_ that indicates the Overflow Mode of this operation. + +| Capability: +*ArbitraryPrecisionFixedPointINTEL* + +| 10 | 5925 | Result Type | Result | Input Type | Input | _Literal_ S | _Literal_ I | _Literal_ rI | _Literal_ Q | _Literal_ O +|===== + +[cols="11", width="100%"] +|===== +10+<|*OpFixedSinINTEL* + + +An `OpTypeInt` representing an arbitrary precision fixed point number (ac_fixed) is passed in as the _Input_ and the sine of the value is returned in _Result_. + +_Input Type_ is an `OpTypeInt` of width _W_ and is the type of _Input_. + +_Result Type_ is an `OpTypeInt` of width _rW_ and is the type of _Result_. + +_S_ is an `OpTypeBool` that indicates if the input and output are signed or unsigned. +A value of `1` indicates that the two types are signed. +Note that the operation does not use the signedness capabilities of `OpTypeInt`. + +_I_ is an `OpTypeInt` that refers to the location of the fixed-point relative to the MSB of the input type. + +_rI_ is an `OpTypeInt` that refers to the location of the fixed-point relative to the MSB of the result type. + +_Q_ is an `OpTypeInt` chosen from _Table 3.16b_ that indicates the Quantization Mode of this operation. + +_O_ is an `OpTypeInt` chosen from _Table 3.16c_ that indicates the Overflow Mode of this operation. + +| Capability: +*ArbitraryPrecisionFixedPointINTEL* + +| 10 | 5926 | Result Type | Result | Input Type| Input | _Literal_ S | _Literal_ I | _Literal_ rI | _Literal_ Q | _Literal_ O +|===== + +[cols="11", width="100%"] +|===== +10+<|*OpFixedCosINTEL* + + +An `OpTypeInt` representing an arbitrary precision fixed point number (ac_fixed) is passed in as the _Input_ and the cosine of the value is returned in _Result_. + +_Result Type_ is an `OpTypeInt` of width _rW_ and is the type of _Result_. + +_Input Type_ is an `OpTypeInt` of width _W_ and is the type of _Input_. + +_S_ is an `OpTypeBool` that indicates if the input and output are signed or unsigned. +A value of `1` indicates that the two types are signed. +Note that the operation does not use the signedness capabilities of `OpTypeInt`. + +_I_ is an `OpTypeInt` that refers to the location of the fixed-point relative to the MSB. + +_rI_ is an `OpTypeInt` that refers to the location of the fixed-point relative to the MSB of the result type. + +_Q_ is an `OpTypeInt` chosen from _Table 3.16b_ that indicates the Quantization Mode of this operation. + +_O_ is an `OpTypeInt` chosen from _Table 3.16c_ that indicates the Overflow Mode of this operation. + +| Capability: +*ArbitraryPrecisionFixedPointINTEL* + +| 10 | 5927 | Result Type | Result | Input Type| Input | _Literal_ S | _Literal_ I | _Literal_ rI | _Literal_ Q | _Literal_ O +|===== + +[cols="11", width="100%"] +|===== +10+<|*OpFixedSinCosINTEL* + + +An `OpTypeInt` representing an arbitrary precision fixed point number (ac_fixed) is passed in as the _Input_ and both the sine and cosine of the value are returned in _Result_. + +_Input Type_ is an `OpTypeInt` of width _W_ and is the type of _Input_. + +_Result Type_ is an `OpTypeInt` of `2 * rW` and is the type of _Result_. +The lower significant bits (`rW`) of the _Result_ are used to hold the cosine value, and the more significant bits (`rW`) are used to hold the sine value. + +_S_ is an `OpTypeBool` that indicates if the input and output are signed or unsigned. +A value of `1` indicates that the two types are signed. +Note that the operation does not use the signedness capabilities of `OpTypeInt`. + +_I_ is an `OpTypeInt` that refers to the location of the fixed-point relative to the MSB. + +_rI_ is an `OpTypeInt` that refers to the location of the fixed-point relative to the MSB of the result type. + +_Q_ is an `OpTypeInt` chosen from _Table 3.16b_ that indicates the Quantization Mode of this operation. + +_O_ is an `OpTypeInt` chosen from _Table 3.16c_ that indicates the Overflow Mode of this operation. + +| Capability: +*ArbitraryPrecisionFixedPointINTEL* + +| 10 | 5928 | Result Type | Result | Input Type| Input | _Literal_ S | _Literal_ I | _Literal_ rI | _Literal_ Q | _Literal_ O +|===== + +[cols="11", width="100%"] +|===== +10+<|*OpFixedSinPiINTEL* + + +An `OpTypeInt` representing an arbitrary precision fixed point number (ac_fixed) is passed in as the _Input_ and the sine of pi * value is returned in _Result_. + +_Result Type_ is an `OpTypeInt` of width _rW_ and is the type of _Result_. + +_Input Type_ is an `OpTypeInt` of width _W_ and is the type of _Input_. + +_S_ is an `OpTypeBool` that indicates if the input and output are signed or unsigned. +A value of `1` indicates that the two types are signed. +Note that the operation does not use the signedness capabilities of `OpTypeInt`. + +_I_ is an `OpTypeInt` that refers to the location of the fixed-point relative to the MSB. + +_rI_ is an `OpTypeInt` that refers to the location of the fixed-point relative to the MSB of the result type. + +_Q_ is an `OpTypeInt` chosen from _Table 3.16b_ that indicates the Quantization Mode of this operation. + +_O_ is an `OpTypeInt` chosen from _Table 3.16c_ that indicates the Overflow Mode of this operation. + +| Capability: +*ArbitraryPrecisionFixedPointINTEL* + +| 10 | 5929 | Result Type | Result | Input Type| Input | _Literal_ S | _Literal_ I | _Literal_ rI | _Literal_ Q | _Literal_ O +|===== + +[cols="11", width="100%"] +|===== +10+<|*OpFixedCosPiINTEL* + + +An `OpTypeInt` representing an arbitrary precision fixed point number (ac_fixed) is passed in as the _Input_ and the cosine of pi * value is returned in _Result_. + +_Result Type_ is an `OpTypeInt` of width _rW_ and is the type of _Result_. + +_Input Type_ is an `OpTypeInt` of width _W_ and is the type of _Input_. + +_S_ is an `OpTypeBool` that indicates if the input and output are signed or unsigned. +A value of `1` indicates that the two types are signed. +Note that the operation does not use the signedness capabilities of `OpTypeInt`. + +_I_ is an `OpTypeInt` that refers to the location of the fixed-point relative to the MSB. + +_rI_ is an `OpTypeInt` that refers to the location of the fixed-point relative to the MSB of the result type. + +_Q_ is an `OpTypeInt` chosen from _Table 3.16b_ that indicates the Quantization Mode of this operation. + +_O_ is an `OpTypeInt` chosen from _Table 3.16c_ that indicates the Overflow Mode of this operation. + +| Capability: +*ArbitraryPrecisionFixedPointINTEL* + +| 10 | 5930 | Result Type | Result | Input Type| Input | _Literal_ S | _Literal_ I | _Literal_ rI | _Literal_ Q | _Literal_ O +|===== + + +[cols="11", width="100%"] +|===== +10+<|*OpFixedSinCosPiINTEL* + + +An `OpTypeInt` representing an arbitrary precision fixed point number (ac_fixed) is passed in as the _Input_ and both the sine and cosine of pi * value are returned in _Result_. + +_Input Type_ is an `OpTypeInt` of width _W_ and is the type of _Input_. + +_Result Type_ is an `OpTypeInt` of twice the width of `rW` and is the type of _Result_. +The lower significant bits (`rW`) of the _Result_ are used to hold the cosine value, and the more significant bits (`rW`) are used to hold the sine value. + +_S_ is an `OpTypeBool` that indicates if the input and output are signed or unsigned. +A value of `1` indicates that the two types are signed. +Note that the operation does not use the signedness capabilities of `OpTypeInt`. + +_I_ is an `OpTypeInt` that refers to the location of the fixed-point relative to the MSB. + +_rI_ is an `OpTypeInt` that refers to the location of the fixed-point relative to the MSB of the result type. + +_Q_ is an `OpTypeInt` chosen from _Table 3.16b_ that indicates the Quantization Mode of this operation. + +_O_ is an `OpTypeInt` chosen from _Table 3.16c_ that indicates the Overflow Mode of this operation. + +| Capability: +*ArbitraryPrecisionFixedPointINTEL* + +| 10 | 5931 | Result Type | Input Type | Result | Input | _Literal_ S | _Literal_ I | _Literal_ rI | _Literal_ Q | _Literal_ O +|===== + +[cols="11", width="100%"] +|===== +10+<|*OpFixedLogINTEL* + + +An `OpTypeInt` representing an arbitrary precision fixed point number (ac_fixed) is passed in as the _Input_ and the log of the value is returned in _Result_. + +_Result Type_ is an `OpTypeInt` of width _rW_ and is the type of _Result_. + +_Input Type_ is an `OpTypeInt` of width _W_ and is the type of _Input_. + +_S_ is an `OpTypeBool` that indicates if the input and output are signed or unsigned. +A value of `1` indicates that the two types are signed. +Note that the operation does not use the signedness capabilities of `OpTypeInt`. + +_I_ is an `OpTypeInt` that refers to the location of the fixed-point relative to the MSB. + +_rI_ is an `OpTypeInt` that refers to the location of the fixed-point relative to the MSB of the result type. + +_Q_ is an `OpTypeInt` chosen from _Table 3.16b_ that indicates the Quantization Mode of this operation. + +_O_ is an `OpTypeInt` chosen from _Table 3.16c_ that indicates the Overflow Mode of this operation. + +| Capability: +*ArbitraryPrecisionFixedPointINTEL* + +| 10 | 5932 | Result Type | Result | Input Type| Input | _Literal_ S | _Literal_ I | _Literal_ rI | _Literal_ Q | _Literal_ O +|===== + +[cols="11", width="100%"] +|===== +10+<|*OpFixedExpINTEL* + + +An `OpTypeInt` representing an arbitrary precision fixed point number (ac_fixed) is passed in as the _Input_ and the exp of the value is returned in _Result_. + +_Result Type_ is an `OpTypeInt` of width _rW_ and is the type of _Result_. + +_Input Type_ is an `OpTypeInt` of width _W_ and is the type of _Input_. + +_S_ is an `OpTypeBool` that indicates if the input and output are signed or unsigned. +A value of `1` indicates that the two types are signed. +Note that the operation does not use the signedness capabilities of `OpTypeInt`. + +_I_ is an `OpTypeInt` that refers to the location of the fixed-point relative to the MSB. + +_rI_ is an `OpTypeInt` that refers to the location of the fixed-point relative to the MSB of the result type. + +_Q_ is an `OpTypeInt` chosen from _Table 3.16b_ that indicates the Quantization Mode of this operation. + +_O_ is an `OpTypeInt` chosen from _Table 3.16c_ that indicates the Overflow Mode of this operation. + +| Capability: +*ArbitraryPrecisionFixedPointINTEL* + +| 10 | 5933 | Result Type | Result | Input Type| Input | _Literal_ S | _Literal_ I | _Literal_ rI | _Literal_ Q | _Literal_ O +|===== + +=== Validation Rules + +None. + +== Issues + +None. + +== Revision History + +[cols="^,<,<,<",options="header",] +|======================================================== +|Rev |Date |Author |Changes +|A |2020-01-30 |Ajaykumar Kannan |Initial Version +|B |2020-06-19 |Ajaykumar Kannan |Initial Public Release +|======================================================== diff --git a/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_floating_point.asciidoc b/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_floating_point.asciidoc new file mode 100755 index 0000000000000..c00c817d7f55b --- /dev/null +++ b/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_floating_point.asciidoc @@ -0,0 +1,1280 @@ += SPV_INTEL_arbitrary_precision_floating_point + +== Name Strings + +SPV_INTEL_arbitrary_precision_floating_point + +== Contact + +To report problems with this extension, please open a new issue at: + +https://github.com/KhronosGroup/SPIRV-Headers + +== Contributors + +Ajaykumar Kannan, Intel + +== Notice + +Copyright (c) 2020 Intel Corporation. All rights reserved. + +== Status + +Initial Release + +== Version + +[width="40%",cols="25,25"] +|======================================== +| Last Modified Date | {docdate} +| Revision | 1 +|======================================== + +== Dependencies + +This extension is written against the SPIR-V Specification Version 1.5, Revision 2. + +This extension depends on the SPV_INTEL_arbitrary_precision_int spec. + +== Overview + +_ihc_float_ is a datatype represented in SPIR-V using `OpTypeInt` that implements arbitrary precision floating point support. +This datatype and its corresponding operations can be useful on targets that can take advantage of narrower representation such as FPGAs. + +The datatype is additionally described with two parameters: + +* _E_: represents the number of exponent bits +* _M_: represents the number of mantissa bits + +The total width of the type is `E+M+1` where the last bit is used to represent the sign. +The data layout is shown below: + +`[ S (sign bit) ][ E (Exponent) ][ M (Mantissa) ]` + +The width of the data `(E+M+1)` is encoded with the width of the `OpTypeInt`. +The other parameters regarding the type (namely `E` and `M`) are encoded within each of the signature of the operations. + +=== Operation Controls + +Each of the operations will also provide some control over the _Rounding Mode_ and the _Subnormal support_. +`OpTypeInt` literals are used to map to the various modes. + +== Extension Name + +To use this extension within a SPIR-V module, the following *OpExtension* must be present in the module: + +---- +OpExtension "SPV_INTEL_arbitrary_precision_floating_point" +---- + +== New Capabilities + +This extension introduces a new capability: + +---- +ArbitraryPrecisionFloatingPointINTEL +---- + +== New Instructions + +Instructions added under the *ArbitraryPrecisionFloatingPointINTEL* capability: + +---- +OpArbitraryFloatAddINTEL +OpArbitraryFloatSubINTEL +OpArbitraryFloatMulINTEL +OpArbitraryFloatDivINTEL +OpArbitraryFloatGTINTEL +OpArbitraryFloatGEINTEL +OpArbitraryFloatLTINTEL +OpArbitraryFloatLEINTEL +OpArbitraryFloatEQINTEL +OpArbitraryFloatRecipINTEL +OpArbitraryFloatRSqrtINTEL +OpArbitraryFloatCbrtINTEL +OpArbitraryFloatHypotINTEL +OpArbitraryFloatSqrtINTEL +OpArbitraryFloatLogINTEL +OpArbitraryFloatLog2INTEL +OpArbitraryFloatLog10INTEL +OpArbitraryFloatLog1pINTEL +OpArbitraryFloatExpINTEL +OpArbitraryFloatExp2INTEL +OpArbitraryFloatExp10INTEL +OpArbitraryFloatExpm1INTEL +OpArbitraryFloatSinINTEL +OpArbitraryFloatCosINTEL +OpArbitraryFloatSinCosINTEL +OpArbitraryFloatSinPiINTEL +OpArbitraryFloatCosPiINTEL +OpArbitraryFloatSinCosPiINTEL +OpArbitraryFloatASinINTEL +OpArbitraryFloatASinPiINTEL +OpArbitraryFloatACosINTEL +OpArbitraryFloatACosPiINTEL +OpArbitraryFloatATanINTEL +OpArbitraryFloatATanPiINTEL +OpArbitraryFloatATan2INTEL +OpArbitraryFloatPowINTEL +OpArbitraryFloatPowRINTEL +OpArbitraryFloatPowNINTEL +OpArbitraryFloatCastINTEL +OpArbitraryFloatCastFromIntINTEL +OpArbitraryFloatCastToIntINTEL +---- + +== Token Number Assignments +[width="40%"] +[cols="70%,30%"] +[grid="rows"] +|==== +|`ArbitraryPrecisionFloatingPointINTEL` | 5845 +|`OpArbitraryFloatAddINTEL` | 5846 +|`OpArbitraryFloatSubINTEL` | 5847 +|`OpArbitraryFloatMulINTEL` | 5848 +|`OpArbitraryFloatDivINTEL` | 5849 +|`OpArbitraryFloatGTINTEL` | 5850 +|`OpArbitraryFloatGEINTEL` | 5851 +|`OpArbitraryFloatLTINTEL` | 5852 +|`OpArbitraryFloatLEINTEL` | 5853 +|`OpArbitraryFloatEQINTEL` | 5854 +|`OpArbitraryFloatRecipINTEL` | 5855 +|`OpArbitraryFloatRSqrtINTEL` | 5856 +|`OpArbitraryFloatCbrtINTEL` | 5857 +|`OpArbitraryFloatHypotINTEL` | 5858 +|`OpArbitraryFloatSqrtINTEL` | 5859 +|`OpArbitraryFloatLogINTEL` | 5860 +|`OpArbitraryFloatLog2INTEL` | 5861 +|`OpArbitraryFloatLog10INTEL` | 5862 +|`OpArbitraryFloatLog1pINTEL` | 5863 +|`OpArbitraryFloatExpINTEL` | 5864 +|`OpArbitraryFloatExp2INTEL` | 5865 +|`OpArbitraryFloatExp10INTEL` | 5866 +|`OpArbitraryFloatExpm1INTEL` | 5867 +|`OpArbitraryFloatSinINTEL` | 5868 +|`OpArbitraryFloatCosINTEL` | 5869 +|`OpArbitraryFloatSinCosINTEL` | 5870 +|`OpArbitraryFloatSinPiINTEL` | 5871 +|`OpArbitraryFloatCosPiINTEL` | 5872 +|`OpArbitraryFloatSinCosPiINTEL` | 5840 +|`OpArbitraryFloatASinINTEL` | 5873 +|`OpArbitraryFloatASinPiINTEL` | 5874 +|`OpArbitraryFloatACosINTEL` | 5875 +|`OpArbitraryFloatACosPiINTEL` | 5876 +|`OpArbitraryFloatATanINTEL` | 5877 +|`OpArbitraryFloatATanPiINTEL` | 5878 +|`OpArbitraryFloatATan2INTEL` | 5879 +|`OpArbitraryFloatPowINTEL` | 5880 +|`OpArbitraryFloatPowRINTEL` | 5881 +|`OpArbitraryFloatPowNINTEL` | 5882 +|`OpArbitraryFloatCastINTEL` | 5841 +|`OpArbitraryFloatCastFromIntINTEL` | 5842 +|`OpArbitraryFloatCastToIntINTEL` | 5843 +|==== + +== Modifications to the SPIR-V Specification Version 1.5 + +After Section 3.16, add a new section "3.16a Subnormal Support" as follows: + +=== Subnormal Support + +Control whether subnormal support is enabled or not. + +[options="header"] +[width="60%"] +[cols="15%,85%"] +|==== +| Value ^| Subnormal Support (`OpTypeInt`) +| 0 | Flush subnormals numbers to zero on inputs and outputs +| 1 | Enable support for operating on subnormal numbers +|==== + +After Section 3.16, add a new section "3.16d Rounding Accuracy" as follows: + +=== Rounding Accuracy + +Controls whether rounding operations can be relaxed to trade correctness for improved resource utilization. + +[options="header"] +[width="80%"] +[cols="15%,20%,65%"] +|==== +| Value ^| Mode ^| Behavior +| 0 | CORRECT | Conform to the IEEE-754 standard for rounding accuracy +| 1 | FAITHFUL | Allow some tolerance for error (within 1ULP of the IEEE-754 standard) for rounding. + +The returned result is one of the two floating point values closest to the mathematical result. + +This mode is useful for devices that can trade CORRECT rounding for improved resource utilization. +|==== + +=== Capability +Modify Section 3.31, *Capability*, adding a row to the Capability table: + +[options="header"] +|==== +2+^| Capability ^| Implicitly Declares +| 5845 | *ArbitraryPrecisionFloatingPointINTEL* + + +Allows the use of various operations for arbitrary precision floating-point math + +| *ArbitraryPrecisionIntegersINTEL* | +|==== + +=== Instructions + +In Section 3.32.13, *Arithmetic Instructions*, add the following instructions: + +[cols="14", width="100%"] +|===== +13+<|*OpArbitraryFloatAddINTEL* + + +Two `OpTypeInts` representing two arbitrary precision floating point numbers (ihc_float) are passed in as _A_ and _B_ and the result of `A+B` is returned in _Result_. + +_Result Type_ is an `OpTypeInt` of width `1+Eout+Mout` and is the type of _Result_. + +_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. + +_B Type_ is an `OpTypeInt` of width `1+E2+M2` and is the type of _B_. + +_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _Result_, _A_, and _B_. +Note that the exponent values (E1, E2, Eout) are inferred from the width of the `OpTypeInt`. + +_EnableSubnormals_ specifies whether subnormal numbers should be supported or flushed to zero before and after the operation and is chosen from _Table 3.16a_. + +_RoundingMode_ controls the rounding mode for the result and is chosen from _Table 3.16_. + +_RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen from _Table 3.16d_. + +| Capability: +*ArbitraryPrecisionFloatingPointINTEL* +| 13 | 5846 | Result Type | Result | A Type | A | _Literal_ M1 | B Type | B | _Literal_ M2 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +|===== + +[cols="14", width="100%"] +|===== +13+<|*OpArbitraryFloatSubINTEL* + + +Two `OpTypeInts` representing two arbitrary precision floating point numbers (ihc_float) are passed in as _A_ and _B_ and the result of `A-B` is returned in _Result_. + +_Result Type_ is an `OpTypeInt` of width `1+Eout+Mout` and is the type of _Result_. + +_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. + +_B Type_ is an `OpTypeInt` of width `1+E2+M2` and is the type of _B_. + +_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _Result_, _A_, and _B_. +Note that the exponent values (E1, E2, Eout) are inferred from the width of the `OpTypeInt`. + +_EnableSubnormals_ specifies whether subnormal numbers should be supported or flushed to zero before and after the operation and is chosen from _Table 3.16a_. + +_RoundingMode_ controls the rounding mode for the result and is chosen from _Table 3.16_. + +_RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen from _Table 3.16d_. + +| Capability: +*ArbitraryPrecisionFloatingPointINTEL* +| 13 | 5847 | Result Type | Result | A Type | A | _Literal_ M1 | B Type | B | _Literal_ M2 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +|===== + +[cols="14", width="100%"] +|===== +13+<|*OpArbitraryFloatMulINTEL* + + +Two `OpTypeInts` representing two arbitrary precision floating point numbers (ihc_float) are passed in as _A_ and _B_ and the result of `A*B` is returned in _Result_. + +_Result Type_ is an `OpTypeInt` of width `1+Eout+Mout` and is the type of _Result_. + +_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. + +_B Type_ is an `OpTypeInt` of width `1+E2+M2` and is the type of _B_. + +_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _Result_, _A_, and _B_. +Note that the exponent values (E1, E2, Eout) are inferred from the width of the `OpTypeInt`. + +_EnableSubnormals_ specifies whether subnormal numbers should be supported or flushed to zero before and after the operation and is chosen from _Table 3.16a_. + +_RoundingMode_ controls the rounding mode for the result and is chosen from _Table 3.16_. + +_RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen from _Table 3.16d_. + +| Capability: +*ArbitraryPrecisionFloatingPointINTEL* +| 13 | 5848 | Result Type | Result | A Type | A | _Literal_ M1 | B Type | B | _Literal_ M2 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +|===== + +[cols="14", width="100%"] +|===== +13+<|*OpArbitraryFloatDivINTEL* + + +Two `OpTypeInts` representing two arbitrary precision floating point numbers (ihc_float) are passed in as _A_ and _B_ and the result of `A/B` is returned in _Result_. + +_Result Type_ is an `OpTypeInt` of width `1+Eout+Mout` and is the type of _Result_. + +_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. + +_B Type_ is an `OpTypeInt` of width `1+E2+M2` and is the type of _B_. + +_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _Result_, _A_, and _B_. +Note that the exponent values (E1, E2, Eout) are inferred from the width of the `OpTypeInt`. + +_EnableSubnormals_ specifies whether subnormal numbers should be supported or flushed to zero before and after the operation and is chosen from _Table 3.16a_. + +_RoundingMode_ controls the rounding mode for the result and is chosen from _Table 3.16_. + +_RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen from _Table 3.16d_. + +| Capability: +*ArbitraryPrecisionFloatingPointINTEL* +| 13 | 5849 | Result Type | Result | A Type | A | _Literal_ M1 | B Type | B | _Literal_ M2 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +|===== + +[cols="10", width="100%"] +|===== +9+<|*OpArbitraryFloatGTINTEL* + + +Two `OpTypeInts` representing two arbitrary precision floating point numbers (ihc_float) are passed in as _A_ and _B_. +The two numbers are compared and a value of `true` is returned in _Result_ if `A > B`. +Otherwise, a value of `false` is returned. + +_Result Type_ must be a Boolean type. + +_Result_ is of type `OpTypeBool`. + +_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. + +_B Type_ is an `OpTypeInt` of width `1+E2+M2` and is the type of _B_. + +_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _A_ and _B_. +Note that the exponent values (E1, E2) are inferred from the width of the `OpTypeInt`. + +| Capability: +*ArbitraryPrecisionFloatingPointINTEL* +| 9 | 5850 | Result Type | Result | A Type | A | _Literal_ M1 | B Type | B | _Literal_ M2 +|===== + +[cols="10", width="100%"] +|===== +9+<|*OpArbitraryFloatGEINTEL* + + +Two `OpTypeInts` representing two arbitrary precision floating point numbers (ihc_float) are passed in as _A_ and _B_. +The two numbers are compared and a value of `true` is returned in _Result_ if `A >= B`. +Otherwise, a value of `false` is returned. + +_Result Type_ must be a Boolean type. + +_Result_ is of type `OpTypeBool`. + +_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. + +_B Type_ is an `OpTypeInt` of width `1+E2+M2` and is the type of _B_. + +_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _A_ and _B_. +Note that the exponent values (E1, E2) are inferred from the width of the `OpTypeInt`. + +| Capability: +*ArbitraryPrecisionFloatingPointINTEL* +| 9 | 5851 | Result Type | Result | A Type | A | _Literal_ M1 | B Type | B | _Literal_ M2 +|===== + +[cols="10", width="100%"] +|===== +9+<|*OpArbitraryFloatLTINTEL* + + +Two `OpTypeInts` representing two arbitrary precision floating point numbers (ihc_float) are passed in as _A_ and _B_. +The two numbers are compared and a value of `true` is returned in _Result_ if `A < B`. +Otherwise, a value of `false` is returned. + +_Result Type_ must be a Boolean type. + +_Result_ is of type `OpTypeBool`. + +_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. + +_B Type_ is an `OpTypeInt` of width `1+E2+M2` and is the type of _B_. + +_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _A_ and _B_. +Note that the exponent values (E1, E2) are inferred from the width of the `OpTypeInt`. + +| Capability: +*ArbitraryPrecisionFloatingPointINTEL* +| 9 | 5852 | Result Type | Result | A Type | A | _Literal_ M1 | B Type | B | _Literal_ M2 +|===== + +[cols="10", width="100%"] +|===== +9+<|*OpArbitraryFloatLEINTEL* + + +Two `OpTypeInts` representing two arbitrary precision floating point numbers (ihc_float) are passed in as _A_ and _B_. +The two numbers are compared and a value of `true` is returned in _Result_ if `A \<= B`. +Otherwise, a value of `false` is returned. + +_Result Type_ must be a Boolean type. + +_Result_ is of type `OpTypeBool`. + +_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. + +_B Type_ is an `OpTypeInt` of width `1+E2+M2` and is the type of _B_. + +_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _A_ and _B_. +Note that the exponent values (E1, E2) are inferred from the width of the `OpTypeInt`. + +| Capability: +*ArbitraryPrecisionFloatingPointINTEL* +| 9 | 5853 | Result Type | Result | A Type | A | _Literal_ M1 | B Type | B | _Literal_ M2 +|===== + +[cols="10", width="100%"] +|===== +9+<|*OpArbitraryFloatEQINTEL* + + +Two `OpTypeInts` representing two arbitrary precision floating point numbers (ihc_float) are passed in as _A_ and _B_. +The two numbers are compared and a value of `true` is returned in _Result_ if `A == B`. +Otherwise, a value of `false` is returned. + +_Result Type_ must be a Boolean type. + +_Result_ is of type `OpTypeBool`. + +_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. + +_B Type_ is an `OpTypeInt` of width `1+E2+M2` and is the type of _B_. + +_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _A_ and _B_. +Note that the exponent values (E1, E2) are inferred from the width of the `OpTypeInt`. + +| Capability: +*ArbitraryPrecisionFloatingPointINTEL* +| 9 | 5854 | Result Type | Result | A Type | A | _Literal_ M1 | B Type | B | _Literal_ M2 +|===== + +[cols="11", width="100%"] +|===== +10+<|*OpArbitraryFloatRecipINTEL* + + +An `OpTypeInt` representing an arbitrary precision floating point number (ihc_float) is passed in as _A_. +The reciprocal of _A_ is returned as _Result_. + +_Result Type_ is an `OpTypeInt` of width `1+Eout+Mout` and is the type of _Result_. + +_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. + +_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _Result_ and _A_. +Note that the exponent values (E1, Eout) are inferred from the width of the `OpTypeInt`. + +_EnableSubnormals_ specifies whether subnormal numbers should be supported or flushed to zero before and after the operation and is chosen from _Table 3.16a_. + +_RoundingMode_ controls the rounding mode for the result and is chosen from _Table 3.16_. + +_RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen from _Table 3.16d_. + +| Capability: +*ArbitraryPrecisionFloatingPointINTEL* +| 10 | 5855 | Result Type | Result | A Type | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +|===== + +[cols="11", width="100%"] +|===== +10+<|*OpArbitraryFloatRSqrtINTEL* + + +An `OpTypeInt` representing an arbitrary precision floating point number (ihc_float) is passed in as _A_. +The reciprocal of the square root of _A_ is returned as _Result_. + +_Result Type_ is an `OpTypeInt` of width `1+Eout+Mout` and is the type of _Result_. + +_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. + +_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _Result_ and _A_. +Note that the exponent values (E1, Eout) are inferred from the width of the `OpTypeInt`. + +_EnableSubnormals_ specifies whether subnormal numbers should be supported or flushed to zero before and after the operation and is chosen from _Table 3.16a_. + +_RoundingMode_ controls the rounding mode for the result and is chosen from _Table 3.16_. + +_RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen from _Table 3.16d_. + +| Capability: +*ArbitraryPrecisionFloatingPointINTEL* +| 10 | 5856 | Result Type | Result | A Type | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +|===== + +[cols="11", width="100%"] +|===== +10+<|*OpArbitraryFloatCbrtINTEL* + + +An `OpTypeInt` representing an arbitrary precision floating point number (ihc_float) is passed in as _A_. +The cube root of _A_ is returned as _Result_. + +_Result Type_ is an `OpTypeInt` of width `1+Eout+Mout` and is the type of _Result_. + +_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. + +_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _Result_ and _A_. +Note that the exponent values (E1, Eout) are inferred from the width of the `OpTypeInt`. + +_EnableSubnormals_ specifies whether subnormal numbers should be supported or flushed to zero before and after the operation and is chosen from _Table 3.16a_. + +_RoundingMode_ controls the rounding mode for the result and is chosen from _Table 3.16_. + +_RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen from _Table 3.16d_. + +| Capability: +*ArbitraryPrecisionFloatingPointINTEL* +| 10 | 5857 | Result Type | Result | A Type | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +|===== + +[cols="14", width="100%"] +|===== +13+<|*OpArbitraryFloatHypotINTEL* + + +Two `OpTypeInts` representing two arbitrary precision floating point numbers (ihc_float) are passed in as _A_ and _B_. +The hypotenuse sqrt(_A_^2 + _B_^2) is returned as _Result_. + +_Result Type_ is an `OpTypeInt` of width `1+Eout+Mout` and is the type of _Result_. + +_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. + +_B Type_ is an `OpTypeInt` of width `1+E2+M2` and is the type of _B_. + +_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _Result_, _A_, and _B_. +Note that the exponent values (E1, E2, Eout) are inferred from the width of the `OpTypeInt`. + +_EnableSubnormals_ specifies whether subnormal numbers should be supported or flushed to zero before and after the operation and is chosen from _Table 3.16a_. + +_RoundingMode_ controls the rounding mode for the result and is chosen from _Table 3.16_. + +_RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen from _Table 3.16d_. + +| Capability: +*ArbitraryPrecisionFloatingPointINTEL* +| 13 | 5858 | Result Type | Result | A Type | A | _Literal_ M1 | B Type | B | _Literal_ M2 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +|===== + +[cols="11", width="100%"] +|===== +10+<|*OpArbitraryFloatSqrtINTEL* + + +An `OpTypeInt` representing an arbitrary precision floating point number (ihc_float) is passed in as _A_. +The square root of _A_ is returned as _Result_. + +_Result Type_ is an `OpTypeInt` of width `1+Eout+Mout` and is the type of _Result_. + +_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. + +_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _Result_ and _A_. +Note that the exponent values (E1, Eout) are inferred from the width of the `OpTypeInt`. + +_EnableSubnormals_ specifies whether subnormal numbers should be supported or flushed to zero before and after the operation and is chosen from _Table 3.16a_. + +_RoundingMode_ controls the rounding mode for the result and is chosen from _Table 3.16_. + +_RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen from _Table 3.16d_. + +| Capability: +*ArbitraryPrecisionFloatingPointINTEL* +| 10 | 5859 | Result Type | Result | A Type | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +|===== + +[cols="11", width="100%"] +|===== +10+<|*OpArbitraryFloatLogINTEL* + + +An `OpTypeInt` representing an arbitrary precision floating point number (ihc_float) is passed in as _A_. +The `ln(A)` of _A_ is returned as _Result_. + +_Result Type_ is an `OpTypeInt` of width `1+Eout+Mout` and is the type of _Result_. + +_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. + +_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _Result_ and _A_. +Note that the exponent values (E1, Eout) are inferred from the width of the `OpTypeInt`. + +_EnableSubnormals_ specifies whether subnormal numbers should be supported or flushed to zero before and after the operation and is chosen from _Table 3.16a_. + +_RoundingMode_ controls the rounding mode for the result and is chosen from _Table 3.16_. + +_RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen from _Table 3.16d_. + +| Capability: +*ArbitraryPrecisionFloatingPointINTEL* +| 10 | 5860 | Result Type | Result | A Type | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +|===== + +[cols="11", width="100%"] +|===== +10+<|*OpArbitraryFloatLog2INTEL* + + +An `OpTypeInt` representing an arbitrary precision floating point number (ihc_float) is passed in as _A_. +The `log2(A)` of _A_ is returned as _Result_. + +_Result Type_ is an `OpTypeInt` of width `1+Eout+Mout` and is the type of _Result_. + +_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. + +_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _Result_ and _A_. +Note that the exponent values (E1, Eout) are inferred from the width of the `OpTypeInt`. + +_EnableSubnormals_ specifies whether subnormal numbers should be supported or flushed to zero before and after the operation and is chosen from _Table 3.16a_. + +_RoundingMode_ controls the rounding mode for the result and is chosen from _Table 3.16_. + +_RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen from _Table 3.16d_. + +| Capability: +*ArbitraryPrecisionFloatingPointINTEL* +| 10 | 5861 | Result Type | Result | A Type | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +|===== + +[cols="11", width="100%"] +|===== +10+<|*OpArbitraryFloatLog10INTEL* + + +An `OpTypeInt` representing an arbitrary precision floating point number (ihc_float) is passed in as _A_. +The `log10(A)` of _A_ is returned as _Result_. + +_Result Type_ is an `OpTypeInt` of width `1+Eout+Mout` and is the type of _Result_. + +_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. + +_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _Result_ and _A_. +Note that the exponent values (E1, Eout) are inferred from the width of the `OpTypeInt`. + +_EnableSubnormals_ specifies whether subnormal numbers should be supported or flushed to zero before and after the operation and is chosen from _Table 3.16a_. + +_RoundingMode_ controls the rounding mode for the result and is chosen from _Table 3.16_. + +_RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen from _Table 3.16d_. + +| Capability: +*ArbitraryPrecisionFloatingPointINTEL* +| 10 | 5862 | Result Type | Result | A Type | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +|===== + +[cols="11", width="100%"] +|===== +10+<|*OpArbitraryFloatLog1pINTEL* + + +An `OpTypeInt` representing an arbitrary precision floating point number (ihc_float) is passed in as _A_. +The `ln(1+A)` of _A_ is returned as _Result_. + +_Result Type_ is an `OpTypeInt` of width `1+Eout+Mout` and is the type of _Result_. + +_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. + +_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _Result_ and _A_. +Note that the exponent values (E1, Eout) are inferred from the width of the `OpTypeInt`. + +_EnableSubnormals_ specifies whether subnormal numbers should be supported or flushed to zero before and after the operation and is chosen from _Table 3.16a_. + +_RoundingMode_ controls the rounding mode for the result and is chosen from _Table 3.16_. + +_RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen from _Table 3.16d_. + +| Capability: +*ArbitraryPrecisionFloatingPointINTEL* +| 10 | 5863 | Result Type | Result | A Type | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +|===== + +[cols="11", width="100%"] +|===== +10+<|*OpArbitraryFloatExpINTEL* + + +An `OpTypeInt` representing an arbitrary precision floating point number (ihc_float) is passed in as _A_. +The `e^(A)` of _A_ is returned as _Result_. + +_Result Type_ is an `OpTypeInt` of width `1+Eout+Mout` and is the type of _Result_. + +_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. + +_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _Result_ and _A_. +Note that the exponent values (E1, Eout) are inferred from the width of the `OpTypeInt`. + +_EnableSubnormals_ specifies whether subnormal numbers should be supported or flushed to zero before and after the operation and is chosen from _Table 3.16a_. + +_RoundingMode_ controls the rounding mode for the result and is chosen from _Table 3.16_. + +_RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen from _Table 3.16d_. + +| Capability: +*ArbitraryPrecisionFloatingPointINTEL* +| 10 | 5864 | Result Type | Result | A Type | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +|===== + +[cols="11", width="100%"] +|===== +10+<|*OpArbitraryFloatExp2INTEL* + + +An `OpTypeInt` representing an arbitrary precision floating point number (ihc_float) is passed in as _A_. +The `2^(A)` of _A_ is returned as _Result_. + +_Result Type_ is an `OpTypeInt` of width `1+Eout+Mout` and is the type of _Result_. + +_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. + +_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _Result_ and _A_. +Note that the exponent values (E1, Eout) are inferred from the width of the `OpTypeInt`. + +_EnableSubnormals_ specifies whether subnormal numbers should be supported or flushed to zero before and after the operation and is chosen from _Table 3.16a_. + +_RoundingMode_ controls the rounding mode for the result and is chosen from _Table 3.16_. + +_RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen from _Table 3.16d_. + +| Capability: +*ArbitraryPrecisionFloatingPointINTEL* +| 10 | 5865 | Result Type | Result | A Type | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +|===== + +[cols="11", width="100%"] +|===== +10+<|*OpArbitraryFloatExp10INTEL* + + +An `OpTypeInt` representing an arbitrary precision floating point number (ihc_float) is passed in as _A_. +The `10^(A)` of _A_ is returned as _Result_. + +_Result Type_ is an `OpTypeInt` of width `1+Eout+Mout` and is the type of _Result_. + +_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. + +_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _Result_ and _A_. +Note that the exponent values (E1, Eout) are inferred from the width of the `OpTypeInt`. + +_EnableSubnormals_ specifies whether subnormal numbers should be supported or flushed to zero before and after the operation and is chosen from _Table 3.16a_. + +_RoundingMode_ controls the rounding mode for the result and is chosen from _Table 3.16_. + +_RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen from _Table 3.16d_. + +| Capability: +*ArbitraryPrecisionFloatingPointINTEL* +| 10 | 5866 | Result Type | Result | A Type | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +|===== + +[cols="11", width="100%"] +|===== +10+<|*OpArbitraryFloatExp1mINTEL* + + +An `OpTypeInt` representing an arbitrary precision floating point number (ihc_float) is passed in as _A_. +The `(e^A)-1` of _A_ is returned as _Result_. + +_Result Type_ is an `OpTypeInt` of width `1+Eout+Mout` and is the type of _Result_. + +_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. + +_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _Result_ and _A_. +Note that the exponent values (E1, Eout) are inferred from the width of the `OpTypeInt`. + +_EnableSubnormals_ specifies whether subnormal numbers should be supported or flushed to zero before and after the operation and is chosen from _Table 3.16a_. + +_RoundingMode_ controls the rounding mode for the result and is chosen from _Table 3.16_. + +_RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen from _Table 3.16d_. + +| Capability: +*ArbitraryPrecisionFloatingPointINTEL* +| 10 | 5867 | Result Type | Result | A Type | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +|===== + +[cols="11", width="100%"] +|===== +10+<|*OpArbitraryFloatSinINTEL* + + +An `OpTypeInt` representing an arbitrary precision floating point number (ihc_float) is passed in as _A_. +The sine of _A_ is returned as _Result_. + +_Result Type_ is an `OpTypeInt` of width `1+Eout+Mout` and is the type of _Result_. + +_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. + +_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _Result_ and _A_. +Note that the exponent values (E1, Eout) are inferred from the width of the `OpTypeInt`. + +_EnableSubnormals_ specifies whether subnormal numbers should be supported or flushed to zero before and after the operation and is chosen from _Table 3.16a_. + +_RoundingMode_ controls the rounding mode for the result and is chosen from _Table 3.16_. + +_RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen from _Table 3.16d_. + +| Capability: +*ArbitraryPrecisionFloatingPointINTEL* +| 10 | 5868 | Result Type | Result | A Type | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +|===== + +[cols="11", width="100%"] +|===== +10+<|*OpArbitraryFloatCosINTEL* + + +An `OpTypeInt` representing an arbitrary precision floating point number (ihc_float) is passed in as _A_. +The cosine of _A_ is returned as _Result_. + +_Result Type_ is an `OpTypeInt` of width `1+Eout+Mout` and is the type of _Result_. + +_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. + +_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _Result_ and _A_. +Note that the exponent values (E1, Eout) are inferred from the width of the `OpTypeInt`. + +_EnableSubnormals_ specifies whether subnormal numbers should be supported or flushed to zero before and after the operation and is chosen from _Table 3.16a_. + +_RoundingMode_ controls the rounding mode for the result and is chosen from _Table 3.16_. + +_RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen from _Table 3.16d_. + +| Capability: +*ArbitraryPrecisionFloatingPointINTEL* +| 10 | 5869 | Result Type | Result | A Type | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +|===== + +[cols="11", width="100%"] +|===== +10+<|*OpArbitraryFloatSinCosINTEL* + + +An `OpTypeInt` representing an arbitrary precision floating point number (ihc_float) is passed in as _A_. +The sine and cosine of _A_ is returned as _Result_. + +_Result Type_ is an `OpTypeInt` of width `2*(1+Eout+Mout)` and is the type of _Result_. +The _Result_ holds both the sine and cosine with the lower significant bits holding the cosine result, and the more significant bits holding the sine results. + +_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. + +_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _Result_ and _A_. +Note that the exponent values (E1, Eout) are inferred from the width of the `OpTypeInt`. + +_EnableSubnormals_ specifies whether subnormal numbers should be supported or flushed to zero before and after the operation and is chosen from _Table 3.16a_. + +_RoundingMode_ controls the rounding mode for the result and is chosen from _Table 3.16_. + +_RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen from _Table 3.16d_. + +| Capability: +*ArbitraryPrecisionFloatingPointINTEL* +| 10 | 5870 | Result Type | Result | A Type | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +|===== + +[cols="11", width="100%"] +|===== +10+<|*OpArbitraryFloatSinPiINTEL* + + +An `OpTypeInt` representing an arbitrary precision floating point number (ihc_float) is passed in as _A_. +The `sin(A*pi)` is returned as _Result_. + +_Result Type_ is an `OpTypeInt` of width `1+Eout+Mout` and is the type of _Result_. + +_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. + +_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _Result_ and _A_. +Note that the exponent values (E1, Eout) are inferred from the width of the `OpTypeInt`. + +_EnableSubnormals_ specifies whether subnormal numbers should be supported or flushed to zero before and after the operation and is chosen from _Table 3.16a_. + +_RoundingMode_ controls the rounding mode for the result and is chosen from _Table 3.16_. + +_RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen from _Table 3.16d_. + +| Capability: +*ArbitraryPrecisionFloatingPointINTEL* +| 10 | 5871 | Result Type | Result | A Type | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +|===== + +[cols="11", width="100%"] +|===== +10+<|*OpArbitraryFloatCosPiINTEL* + + +An `OpTypeInt` representing an arbitrary precision floating point number (ihc_float) is passed in as _A_. +The `cos(A*pi)` is returned as _Result_. + +_Result Type_ is an `OpTypeInt` of width `1+Eout+Mout` and is the type of _Result_. + +_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. + +_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _Result_ and _A_. +Note that the exponent values (E1, Eout) are inferred from the width of the `OpTypeInt`. + +_EnableSubnormals_ specifies whether subnormal numbers should be supported or flushed to zero before and after the operation and is chosen from _Table 3.16a_. + +_RoundingMode_ controls the rounding mode for the result and is chosen from _Table 3.16_. + +_RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen from _Table 3.16d_. + +| Capability: +*ArbitraryPrecisionFloatingPointINTEL* +| 10 | 5872 | Result Type | Result | A Type | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +|===== + +[cols="11", width="100%"] +|===== +10+<|*OpArbitraryFloatSinCosPiINTEL* + + +An `OpTypeInt` representing an arbitrary precision floating point number (ihc_float) is passed in as _A_. +The sine and cosine of `A*pi` is returned as _Result_. + +_Result Type_ is an `OpTypeInt` of width `2*(1+Eout+Mout)` and is the type of _Result_. +The _Result_ holds both the sine and cosine with the lower significant bits holding the cosine result, and the more significant bits holding the sine results. + +_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. + +_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _Result_ and _A_. +Note that the exponent values (E1, Eout) are inferred from the width of the `OpTypeInt`. + +_EnableSubnormals_ specifies whether subnormal numbers should be supported or flushed to zero before and after the operation and is chosen from _Table 3.16a_. + +_RoundingMode_ controls the rounding mode for the result and is chosen from _Table 3.16_. + +_RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen from _Table 3.16d_. + +| Capability: +*ArbitraryPrecisionFloatingPointINTEL* +| 10 | 5840 | Result Type | Result | A Type | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +|===== + +[cols="11", width="100%"] +|===== +10+<|*OpArbitraryFloatASinINTEL* + + +An `OpTypeInt` representing an arbitrary precision floating point number (ihc_float) is passed in as _A_. +The `arcsin(A)` is returned as _Result_. + +_Result Type_ is an `OpTypeInt` of width `1+Eout+Mout` and is the type of _Result_. + +_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. + +_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _Result_ and _A_. +Note that the exponent values (E1, Eout) are inferred from the width of the `OpTypeInt`. + +_EnableSubnormals_ specifies whether subnormal numbers should be supported or flushed to zero before and after the operation and is chosen from _Table 3.16a_. + +_RoundingMode_ controls the rounding mode for the result and is chosen from _Table 3.16_. + +_RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen from _Table 3.16d_. + +| Capability: +*ArbitraryPrecisionFloatingPointINTEL* +| 10 | 5873 | Result Type | Result | A Type | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +|===== + +[cols="11", width="100%"] +|===== +10+<|*OpArbitraryFloatASinPiINTEL* + + +An `OpTypeInt` representing an arbitrary precision floating point number (ihc_float) is passed in as _A_. +The `arcsin(A*pi)` is returned as _Result_. + +_Result Type_ is an `OpTypeInt` of width `1+Eout+Mout` and is the type of _Result_. + +_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. + +_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _Result_ and _A_. +Note that the exponent values (E1, Eout) are inferred from the width of the `OpTypeInt`. + +_EnableSubnormals_ specifies whether subnormal numbers should be supported or flushed to zero before and after the operation and is chosen from _Table 3.16a_. + +_RoundingMode_ controls the rounding mode for the result and is chosen from _Table 3.16_. + +_RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen from _Table 3.16d_. + +| Capability: +*ArbitraryPrecisionFloatingPointINTEL* +| 10 | 5874 | Result Type | Result | A Type | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +|===== + +[cols="11", width="100%"] +|===== +10+<|*OpArbitraryFloatACosINTEL* + + +An `OpTypeInt` representing an arbitrary precision floating point number (ihc_float) is passed in as _A_. +The `arccos(A)` is returned as _Result_. + +_Result Type_ is an `OpTypeInt` of width `1+Eout+Mout` and is the type of _Result_. + +_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. + +_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _Result_ and _A_. +Note that the exponent values (E1, Eout) are inferred from the width of the `OpTypeInt`. + +_EnableSubnormals_ specifies whether subnormal numbers should be supported or flushed to zero before and after the operation and is chosen from _Table 3.16a_. + +_RoundingMode_ controls the rounding mode for the result and is chosen from _Table 3.16_. + +_RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen from _Table 3.16d_. + +| Capability: +*ArbitraryPrecisionFloatingPointINTEL* +| 10 | 5875 | Result Type | Result | A Type | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +|===== + +[cols="11", width="100%"] +|===== +10+<|*OpArbitraryFloatACosPiINTEL* + + +An `OpTypeInt` representing an arbitrary precision floating point number (ihc_float) is passed in as _A_. +The `arccos(A*pi)` is returned as _Result_. + +_Result Type_ is an `OpTypeInt` of width `1+Eout+Mout` and is the type of _Result_. + +_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. + +_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _Result_ and _A_. +Note that the exponent values (E1, Eout) are inferred from the width of the `OpTypeInt`. + +_EnableSubnormals_ specifies whether subnormal numbers should be supported or flushed to zero before and after the operation and is chosen from _Table 3.16a_. + +_RoundingMode_ controls the rounding mode for the result and is chosen from _Table 3.16_. + +_RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen from _Table 3.16d_. + +| Capability: +*ArbitraryPrecisionFloatingPointINTEL* +| 10 | 5876 | Result Type | Result | A Type | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +|===== + +[cols="11", width="100%"] +|===== +10+<|*OpArbitraryFloatATanINTEL* + + +An `OpTypeInt` representing an arbitrary precision floating point number (ihc_float) is passed in as _A_. +The `arctan(A)` is returned as _Result_. + +_Result Type_ is an `OpTypeInt` of width `1+Eout+Mout` and is the type of _Result_. + +_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. + +_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _Result_ and _A_. +Note that the exponent values (E1, Eout) are inferred from the width of the `OpTypeInt`. + +_EnableSubnormals_ specifies whether subnormal numbers should be supported or flushed to zero before and after the operation and is chosen from _Table 3.16a_. + +_RoundingMode_ controls the rounding mode for the result and is chosen from _Table 3.16_. + +_RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen from _Table 3.16d_. + +| Capability: +*ArbitraryPrecisionFloatingPointINTEL* +| 10 | 5877 | Result Type | Result | A Type | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +|===== + +[cols="11", width="100%"] +|===== +10+<|*OpArbitraryFloatATanPiINTEL* + + +An `OpTypeInt` representing an arbitrary precision floating point number (ihc_float) is passed in as _A_. +The `arctan(A*pi)` is returned as _Result_. + +_Result Type_ is an `OpTypeInt` of width `1+Eout+Mout` and is the type of _Result_. + +_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. + +_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _Result_ and _A_. +Note that the exponent values (E1, Eout) are inferred from the width of the `OpTypeInt`. + +_EnableSubnormals_ specifies whether subnormal numbers should be supported or flushed to zero before and after the operation and is chosen from _Table 3.16a_. + +_RoundingMode_ controls the rounding mode for the result and is chosen from _Table 3.16_. + +_RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen from _Table 3.16d_. + +| Capability: +*ArbitraryPrecisionFloatingPointINTEL* +| 10 | 5878 | Result Type | Result | A Type | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +|===== + +[cols="14", width="100%"] +|===== +13+<|*OpArbitraryFloatTan2INTEL* + + +Two `OpTypeInts` representing two arbitrary precision floating point numbers (ihc_float) are passed in as _A_ and _B_. +The `arctan2(A,B) = arctan(A/B)` is returned as _Result_. + +_Result Type_ is an `OpTypeInt` of width `1+Eout+Mout` and is the type of _Result_. + +_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. + +_B Type_ is an `OpTypeInt` of width `1+E2+M2` and is the type of _B_. + +_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _Result_, _A_, and _B_. +Note that the exponent values (E1, E2, Eout) are inferred from the width of the `OpTypeInt`. + +_EnableSubnormals_ specifies whether subnormal numbers should be supported or flushed to zero before and after the operation and is chosen from _Table 3.16a_. + +_RoundingMode_ controls the rounding mode for the result and is chosen from _Table 3.16_. + +_RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen from _Table 3.16d_. + +| Capability: +*ArbitraryPrecisionFloatingPointINTEL* +| 13 | 5879 | Result Type | Result | A Type | A | _Literal_ M1 | B Type | B | _Literal_ M2 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +|===== + +[cols="14", width="100%"] +|===== +13+<|*OpArbitraryFloatPowINTEL* + + +Two `OpTypeInts` representing two arbitrary precision floating point numbers (ihc_float) are passed in as _A_ and _B_. +The value of `A^B` is returned in _Result_. + +_Result Type_ is an `OpTypeInt` of width `1+Eout+Mout` and is the type of _Result_. + +_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. + +_B Type_ is an `OpTypeInt` of width `1+E2+M2` and is the type of _B_. + +_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _Result_, _A_, and _B_. +Note that the exponent values (E1, E2, Eout) are inferred from the width of the `OpTypeInt`. + +_EnableSubnormals_ specifies whether subnormal numbers should be supported or flushed to zero before and after the operation and is chosen from _Table 3.16a_. + +_RoundingMode_ controls the rounding mode for the result and is chosen from _Table 3.16_. + +_RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen from _Table 3.16d_. + +| Capability: +*ArbitraryPrecisionFloatingPointINTEL* +| 13 | 5880 | Result Type | Result | A Type | A | _Literal_ M1 | B Type | B | _Literal_ M2 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +|===== + +[cols="14", width="100%"] +|===== +13+<|*OpArbitraryFloatPowRINTEL* + + +Two `OpTypeInts` representing two arbitrary precision floating point numbers (ihc_float) are passed in as _A_ and _B_. +The value of `A^B` is returned in _Result_. However, `A >= 0`, otherwise, the result is undefined. + +_Result Type_ is an `OpTypeInt` of width `1+Eout+Mout` and is the type of _Result_. + +_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. + +_B Type_ is an `OpTypeInt` of width `1+E2+M2` and is the type of _B_. + +_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _Result_, _A_, and _B_. +Note that the exponent values (E1, E2, Eout) are inferred from the width of the `OpTypeInt`. + +_EnableSubnormals_ specifies whether subnormal numbers should be supported or flushed to zero before and after the operation and is chosen from _Table 3.16a_. + +_RoundingMode_ controls the rounding mode for the result and is chosen from _Table 3.16_. + +_RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen from _Table 3.16d_. + +| Capability: +*ArbitraryPrecisionFloatingPointINTEL* +| 13 | 5881 | Result Type | Result | A Type | A | _Literal_ M1 | B Type | B | _Literal_ M2 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +|===== + + +[cols="13", width="100%"] +|===== +12+<|*OpArbitraryFloatPowNINTEL* + + +Two `OpTypeInts` representing arbitrary precision floating point number (ihc_float) and arbitrary precision integer number are passed in as _A_ and _B_ respectively. +The value of `A^B` is returned in _Result_ where `B` is an integer of arbitrary size. + +_Result Type_ is an `OpTypeInt` of width `1+E+M` and is the type of _Result_. + +_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. + +_B Type_ is an `OpTypeInt` of width `W` and is the type of _B_. + +_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _Result_ and _A_. +Note that the exponent values (E1, Eout) are inferred from the width of the `OpTypeInt`. + +_EnableSubnormals_ specifies whether subnormal numbers should be supported or flushed to zero before and after the operation and is chosen from _Table 3.16a_. + +_RoundingMode_ controls the rounding mode for the result and is chosen from _Table 3.16_. + +_RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen from _Table 3.16d_. + +| Capability: +*ArbitraryPrecisionFloatingPointINTEL* +| 12 | 5882 | Result Type | Result | A Type | A | _Literal_ M1 | B Type | B | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +|===== + +[cols="11", width="100%"] +|===== +10+<|*OpArbitraryFloatCastINTEL* + + +An `OpTypeInt` representing an arbitrary precision floating point number (ihc_float) is passed in as _A_. +It is type casted into an arbitrary precision floating point number with the new specification (Eout, Mout) and returned as _Result_. + +_Result Type_ is an `OpTypeInt` of width `1+Eout+Mout` and is the type of _Result_. + +_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. + +_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _Result_ and _A_. +Note that the exponent values (E1, Eout) are inferred from the width of the `OpTypeInt`. + +_EnableSubnormals_ specifies whether subnormal numbers should be supported or flushed to zero before and after the operation and is chosen from _Table 3.16a_. + +_RoundingMode_ controls the rounding mode for the result and is chosen from _Table 3.16_. + +_RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen from _Table 3.16d_. + +| Capability: +*ArbitraryPrecisionFloatingPointINTEL* +| 10 | 5841 | Result Type | Result | A Type | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +|===== + +[cols="10", width="100%"] +|===== +9+<|*OpArbitraryFloatCastFromIntINTEL* + + +An `OpTypeInt` representing an arbitrary precision integer is passed in as _A_. +It is type casted into an arbitrary precision floating point number with the new specification (Eout, Mout) and returned as _Result_. + +_Result Type_ is an `OpTypeInt` of width `1+Eout+Mout` and is the type of _Result_. + +_A Type_ is an `OpTypeInt` of width `W` and is the type of _A_. + +_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _Result_. +Note that the exponent value (Eout) is inferred from the width of the `OpTypeInt`. + +_EnableSubnormals_ specifies whether subnormal numbers should be supported or flushed to zero before and after the operation and is chosen from _Table 3.16a_. + +_RoundingMode_ controls the rounding mode for the result and is chosen from _Table 3.16_. + +_RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen from _Table 3.16d_. + +| Capability: +*ArbitraryPrecisionFloatingPointINTEL* +| 9 | 5842 | Result Type | Result | A Type | A | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +|===== + +[cols="10", width="100%"] +|===== +9+<|*OpArbitraryFloatCastToIntINTEL* + + +An `OpTypeInt` representing an arbitrary precision floating point number (ihc_float) is passed in as _A_. +It is type casted into an arbitrary precision integer with width `W` and returned as _Result_. + +_Result Type_ is an `OpTypeInt` of width `W` and is the type of _Result_. + +_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. + +_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _A_. +Note that the exponent values (E1) are inferred from the width of the `OpTypeInt`. + +_EnableSubnormals_ specifies whether subnormal numbers should be supported or flushed to zero before and after the operation and is chosen from _Table 3.16a_. + +_RoundingMode_ controls the rounding mode for the result and is chosen from _Table 3.16_. + +_RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen from _Table 3.16d_. + +| Capability: +*ArbitraryPrecisionFloatingPointINTEL* +| 9 | 5843 | Result Type | Result | A Type | A | _Literal_ M1 | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +|===== + +=== Validation Rules + +None. + +== Issues + +None. + +== Revision History + +[cols="^,<,<,<",options="header",] +|=================================================================== +|Rev |Date |Author |Changes +|A |2020-01-30 |Ajaykumar Kannan |Initial Version +|B |2020-05-22 |Ajaykumar Kannan |Addressed a number of issues +|C |2020-06-19 |Ajaykumar Kannan |Initial Public Release +|=================================================================== From af3fc0116887bc43d5fc7fc5fa95fe5b08704161 Mon Sep 17 00:00:00 2001 From: Ajaykumar Kannan Date: Mon, 22 Jun 2020 23:46:46 -0400 Subject: [PATCH 02/19] Remove the repeated note about signedness for fixed point SPIR-V spec --- ...TEL_arbitrary_precision_fixed_point.asciidoc | 17 ++++------------- 1 file changed, 4 insertions(+), 13 deletions(-) mode change 100755 => 100644 sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_fixed_point.asciidoc diff --git a/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_fixed_point.asciidoc b/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_fixed_point.asciidoc old mode 100755 new mode 100644 index 9da572e8525bd..c449a2f305252 --- a/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_fixed_point.asciidoc +++ b/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_fixed_point.asciidoc @@ -162,8 +162,10 @@ Modify Section 3.31, *Capability*, adding a row to the Capability table: 2+^| Capability ^| Implicitly Declares | 5922 | *ArbitraryPrecisionFixedPointINTEL* + -Enables arbitrary precision fixed-point math instructions -| *INTELArbitraryPrecisionIntegers* +Enables arbitrary precision fixed-point math instructions. + + +Note that this fixed-point type does not hold information about the sign in the type, but the information is rather encoded into the operations performed on this type. +| *INTELArbitraryPrecisionIntegers*, *Kernel* |==== === Instructions @@ -183,7 +185,6 @@ _Input Type_ is an `OpTypeInt` of width _W_ and is the type of _Input_. _S_ is an `OpTypeBool` that indicates if the input and output are signed or unsigned. A value of `1` indicates that the two types are signed. -Note that the operation does not use the signedness capabilities of `OpTypeInt`. _I_ is an `OpTypeInt` that refers to the location of the fixed-point relative to the MSB of the input. @@ -211,7 +212,6 @@ _Input Type_ is an `OpTypeInt` of width _W_ and is the type of _Input_. _S_ is an `OpTypeBool` that indicates if the input and output are signed or unsigned. A value of `1` indicates that the two types are signed. -Note that the operation does not use the signedness capabilities of `OpTypeInt`. _I_ is an `OpTypeInt` that refers to the location of the fixed-point relative to the MSB of the input. @@ -240,7 +240,6 @@ _Input Type_ is an `OpTypeInt` of width _W_ and is the type of _Input_. _S_ is an `OpTypeBool` that indicates if the input and output are signed or unsigned. A value of `1` indicates that the two types are signed. -Note that the operation does not use the signedness capabilities of `OpTypeInt`. _I_ is an `OpTypeInt` that refers to the location of the fixed-point relative to the MSB of the input. @@ -268,7 +267,6 @@ _Result Type_ is an `OpTypeInt` of width _rW_ and is the type of _Result_. _S_ is an `OpTypeBool` that indicates if the input and output are signed or unsigned. A value of `1` indicates that the two types are signed. -Note that the operation does not use the signedness capabilities of `OpTypeInt`. _I_ is an `OpTypeInt` that refers to the location of the fixed-point relative to the MSB of the input type. @@ -296,7 +294,6 @@ _Input Type_ is an `OpTypeInt` of width _W_ and is the type of _Input_. _S_ is an `OpTypeBool` that indicates if the input and output are signed or unsigned. A value of `1` indicates that the two types are signed. -Note that the operation does not use the signedness capabilities of `OpTypeInt`. _I_ is an `OpTypeInt` that refers to the location of the fixed-point relative to the MSB. @@ -325,7 +322,6 @@ The lower significant bits (`rW`) of the _Result_ are used to hold the cosine va _S_ is an `OpTypeBool` that indicates if the input and output are signed or unsigned. A value of `1` indicates that the two types are signed. -Note that the operation does not use the signedness capabilities of `OpTypeInt`. _I_ is an `OpTypeInt` that refers to the location of the fixed-point relative to the MSB. @@ -353,7 +349,6 @@ _Input Type_ is an `OpTypeInt` of width _W_ and is the type of _Input_. _S_ is an `OpTypeBool` that indicates if the input and output are signed or unsigned. A value of `1` indicates that the two types are signed. -Note that the operation does not use the signedness capabilities of `OpTypeInt`. _I_ is an `OpTypeInt` that refers to the location of the fixed-point relative to the MSB. @@ -381,7 +376,6 @@ _Input Type_ is an `OpTypeInt` of width _W_ and is the type of _Input_. _S_ is an `OpTypeBool` that indicates if the input and output are signed or unsigned. A value of `1` indicates that the two types are signed. -Note that the operation does not use the signedness capabilities of `OpTypeInt`. _I_ is an `OpTypeInt` that refers to the location of the fixed-point relative to the MSB. @@ -411,7 +405,6 @@ The lower significant bits (`rW`) of the _Result_ are used to hold the cosine va _S_ is an `OpTypeBool` that indicates if the input and output are signed or unsigned. A value of `1` indicates that the two types are signed. -Note that the operation does not use the signedness capabilities of `OpTypeInt`. _I_ is an `OpTypeInt` that refers to the location of the fixed-point relative to the MSB. @@ -439,7 +432,6 @@ _Input Type_ is an `OpTypeInt` of width _W_ and is the type of _Input_. _S_ is an `OpTypeBool` that indicates if the input and output are signed or unsigned. A value of `1` indicates that the two types are signed. -Note that the operation does not use the signedness capabilities of `OpTypeInt`. _I_ is an `OpTypeInt` that refers to the location of the fixed-point relative to the MSB. @@ -467,7 +459,6 @@ _Input Type_ is an `OpTypeInt` of width _W_ and is the type of _Input_. _S_ is an `OpTypeBool` that indicates if the input and output are signed or unsigned. A value of `1` indicates that the two types are signed. -Note that the operation does not use the signedness capabilities of `OpTypeInt`. _I_ is an `OpTypeInt` that refers to the location of the fixed-point relative to the MSB. From d2af2dd3f29917da07bbe0dc96e1314d5cc116ad Mon Sep 17 00:00:00 2001 From: Ajaykumar Kannan Date: Sun, 19 Jul 2020 20:56:23 -0400 Subject: [PATCH 03/19] Update sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_floating_point.asciidoc Co-authored-by: Mikhail Lychkov <51128024+mlychkov@users.noreply.github.com> --- .../SPIRV/SPV_INTEL_arbitrary_precision_floating_point.asciidoc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_floating_point.asciidoc b/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_floating_point.asciidoc index c00c817d7f55b..805da3b8f95de 100755 --- a/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_floating_point.asciidoc +++ b/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_floating_point.asciidoc @@ -1166,7 +1166,7 @@ _RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen Two `OpTypeInts` representing arbitrary precision floating point number (ihc_float) and arbitrary precision integer number are passed in as _A_ and _B_ respectively. The value of `A^B` is returned in _Result_ where `B` is an integer of arbitrary size. -_Result Type_ is an `OpTypeInt` of width `1+E+M` and is the type of _Result_. +_Result Type_ is an `OpTypeInt` of width `1+Eout+Mout` and is the type of _Result_. _A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. From ea7397d70949c9d3add23c39ccbeb966630ae02f Mon Sep 17 00:00:00 2001 From: Ajaykumar Kannan Date: Sun, 19 Jul 2020 20:57:41 -0400 Subject: [PATCH 04/19] Update sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_floating_point.asciidoc Co-authored-by: Mikhail Lychkov <51128024+mlychkov@users.noreply.github.com> --- .../SPIRV/SPV_INTEL_arbitrary_precision_floating_point.asciidoc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_floating_point.asciidoc b/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_floating_point.asciidoc index 805da3b8f95de..7ef2080db29fc 100755 --- a/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_floating_point.asciidoc +++ b/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_floating_point.asciidoc @@ -1248,7 +1248,7 @@ _Result Type_ is an `OpTypeInt` of width `W` and is the type of _Result_. _A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. _E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _A_. -Note that the exponent values (E1) are inferred from the width of the `OpTypeInt`. +Note that the exponent value (E1) is inferred from the width of the `OpTypeInt`. _EnableSubnormals_ specifies whether subnormal numbers should be supported or flushed to zero before and after the operation and is chosen from _Table 3.16a_. From c332d354aed669b764f46c701991856b1b0f21de Mon Sep 17 00:00:00 2001 From: Ajaykumar Kannan Date: Sun, 19 Jul 2020 20:59:29 -0400 Subject: [PATCH 05/19] Update sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_floating_point.asciidoc Co-authored-by: Mikhail Lychkov <51128024+mlychkov@users.noreply.github.com> --- .../SPIRV/SPV_INTEL_arbitrary_precision_floating_point.asciidoc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_floating_point.asciidoc b/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_floating_point.asciidoc index 7ef2080db29fc..f2b799ad3df14 100755 --- a/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_floating_point.asciidoc +++ b/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_floating_point.asciidoc @@ -1222,7 +1222,7 @@ _Result Type_ is an `OpTypeInt` of width `1+Eout+Mout` and is the type of _Resul _A Type_ is an `OpTypeInt` of width `W` and is the type of _A_. -_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _Result_. +_Eout_ and _Mout_ contain the width of the exponent and the mantissa of the floating point type of _Result_. Note that the exponent value (Eout) is inferred from the width of the `OpTypeInt`. _EnableSubnormals_ specifies whether subnormal numbers should be supported or flushed to zero before and after the operation and is chosen from _Table 3.16a_. From e8be93774c514f9862704a5baa333ca9256e1173 Mon Sep 17 00:00:00 2001 From: Ajaykumar Kannan Date: Sun, 19 Jul 2020 20:59:38 -0400 Subject: [PATCH 06/19] Update sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_floating_point.asciidoc Co-authored-by: Mikhail Lychkov <51128024+mlychkov@users.noreply.github.com> --- .../SPIRV/SPV_INTEL_arbitrary_precision_floating_point.asciidoc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_floating_point.asciidoc b/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_floating_point.asciidoc index f2b799ad3df14..fa9448213a7eb 100755 --- a/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_floating_point.asciidoc +++ b/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_floating_point.asciidoc @@ -1247,7 +1247,7 @@ _Result Type_ is an `OpTypeInt` of width `W` and is the type of _Result_. _A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. -_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _A_. +_E1_ and _M1_ contain the width of the exponent and the mantissa of the floating point type of _A_. Note that the exponent value (E1) is inferred from the width of the `OpTypeInt`. _EnableSubnormals_ specifies whether subnormal numbers should be supported or flushed to zero before and after the operation and is chosen from _Table 3.16a_. From 47588692fddf76fa4e20bef5db4997d0dc7c1601 Mon Sep 17 00:00:00 2001 From: Ajaykumar Kannan Date: Sun, 19 Jul 2020 23:37:44 -0400 Subject: [PATCH 07/19] Remove A Type and B type for inputs for the arbitrary floating point built-in functions --- ...rbitrary_precision_floating_point.asciidoc | 459 +++++++----------- 1 file changed, 169 insertions(+), 290 deletions(-) diff --git a/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_floating_point.asciidoc b/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_floating_point.asciidoc index fa9448213a7eb..4d2da98e6191c 100755 --- a/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_floating_point.asciidoc +++ b/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_floating_point.asciidoc @@ -16,7 +16,7 @@ Ajaykumar Kannan, Intel == Notice -Copyright (c) 2020 Intel Corporation. All rights reserved. +Copyright (c) 2020 Intel Corporation. All rights reserved. == Status @@ -224,19 +224,15 @@ Allows the use of various operations for arbitrary precision floating-point math In Section 3.32.13, *Arithmetic Instructions*, add the following instructions: -[cols="14", width="100%"] +[cols="12", width="100%"] |===== -13+<|*OpArbitraryFloatAddINTEL* + +11+<|*OpArbitraryFloatAddINTEL* + Two `OpTypeInts` representing two arbitrary precision floating point numbers (ihc_float) are passed in as _A_ and _B_ and the result of `A+B` is returned in _Result_. _Result Type_ is an `OpTypeInt` of width `1+Eout+Mout` and is the type of _Result_. -_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. - -_B Type_ is an `OpTypeInt` of width `1+E2+M2` and is the type of _B_. - -_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _Result_, _A_, and _B_. +_M*_ contains the width of the mantissa of the floating point types within _Result_, _A_, and _B_. Note that the exponent values (E1, E2, Eout) are inferred from the width of the `OpTypeInt`. _EnableSubnormals_ specifies whether subnormal numbers should be supported or flushed to zero before and after the operation and is chosen from _Table 3.16a_. @@ -247,22 +243,18 @@ _RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen | Capability: *ArbitraryPrecisionFloatingPointINTEL* -| 13 | 5846 | Result Type | Result | A Type | A | _Literal_ M1 | B Type | B | _Literal_ M2 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +| 11 | 5846 | Result Type | Result | A | _Literal_ M1 | B | _Literal_ M2 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy |===== -[cols="14", width="100%"] +[cols="12", width="100%"] |===== -13+<|*OpArbitraryFloatSubINTEL* + +11+<|*OpArbitraryFloatSubINTEL* + Two `OpTypeInts` representing two arbitrary precision floating point numbers (ihc_float) are passed in as _A_ and _B_ and the result of `A-B` is returned in _Result_. _Result Type_ is an `OpTypeInt` of width `1+Eout+Mout` and is the type of _Result_. -_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. - -_B Type_ is an `OpTypeInt` of width `1+E2+M2` and is the type of _B_. - -_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _Result_, _A_, and _B_. +_M* contains the width of the mantissa of the floating point types within _Result_, _A_, and _B_. Note that the exponent values (E1, E2, Eout) are inferred from the width of the `OpTypeInt`. _EnableSubnormals_ specifies whether subnormal numbers should be supported or flushed to zero before and after the operation and is chosen from _Table 3.16a_. @@ -273,22 +265,18 @@ _RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen | Capability: *ArbitraryPrecisionFloatingPointINTEL* -| 13 | 5847 | Result Type | Result | A Type | A | _Literal_ M1 | B Type | B | _Literal_ M2 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +| 11 | 5847 | Result Type | Result | A | _Literal_ M1 | B | _Literal_ M2 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy |===== -[cols="14", width="100%"] +[cols="12", width="100%"] |===== -13+<|*OpArbitraryFloatMulINTEL* + +11+<|*OpArbitraryFloatMulINTEL* + Two `OpTypeInts` representing two arbitrary precision floating point numbers (ihc_float) are passed in as _A_ and _B_ and the result of `A*B` is returned in _Result_. _Result Type_ is an `OpTypeInt` of width `1+Eout+Mout` and is the type of _Result_. -_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. - -_B Type_ is an `OpTypeInt` of width `1+E2+M2` and is the type of _B_. - -_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _Result_, _A_, and _B_. +_M* contains the width of the mantissa of the floating point types within _Result_, _A_, and _B_. Note that the exponent values (E1, E2, Eout) are inferred from the width of the `OpTypeInt`. _EnableSubnormals_ specifies whether subnormal numbers should be supported or flushed to zero before and after the operation and is chosen from _Table 3.16a_. @@ -299,22 +287,18 @@ _RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen | Capability: *ArbitraryPrecisionFloatingPointINTEL* -| 13 | 5848 | Result Type | Result | A Type | A | _Literal_ M1 | B Type | B | _Literal_ M2 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +| 11 | 5848 | Result Type | Result | A | _Literal_ M1 | B | _Literal_ M2 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy |===== -[cols="14", width="100%"] +[cols="12", width="100%"] |===== -13+<|*OpArbitraryFloatDivINTEL* + +11+<|*OpArbitraryFloatDivINTEL* + Two `OpTypeInts` representing two arbitrary precision floating point numbers (ihc_float) are passed in as _A_ and _B_ and the result of `A/B` is returned in _Result_. _Result Type_ is an `OpTypeInt` of width `1+Eout+Mout` and is the type of _Result_. -_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. - -_B Type_ is an `OpTypeInt` of width `1+E2+M2` and is the type of _B_. - -_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _Result_, _A_, and _B_. +_M* contains the width of the mantissa of the floating point types within _Result_, _A_, and _B_. Note that the exponent values (E1, E2, Eout) are inferred from the width of the `OpTypeInt`. _EnableSubnormals_ specifies whether subnormal numbers should be supported or flushed to zero before and after the operation and is chosen from _Table 3.16a_. @@ -325,141 +309,109 @@ _RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen | Capability: *ArbitraryPrecisionFloatingPointINTEL* -| 13 | 5849 | Result Type | Result | A Type | A | _Literal_ M1 | B Type | B | _Literal_ M2 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +| 11 | 5849 | Result Type | Result | A | _Literal_ M1 | B | _Literal_ M2 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy |===== -[cols="10", width="100%"] +[cols="8", width="100%"] |===== -9+<|*OpArbitraryFloatGTINTEL* + +7+<|*OpArbitraryFloatGTINTEL* + Two `OpTypeInts` representing two arbitrary precision floating point numbers (ihc_float) are passed in as _A_ and _B_. The two numbers are compared and a value of `true` is returned in _Result_ if `A > B`. Otherwise, a value of `false` is returned. -_Result Type_ must be a Boolean type. - -_Result_ is of type `OpTypeBool`. - -_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. - -_B Type_ is an `OpTypeInt` of width `1+E2+M2` and is the type of _B_. +_Result Type_ must be a Boolean. -_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _A_ and _B_. +_M* contains the width of the mantissa of the floating point types within _A_ and _B_. Note that the exponent values (E1, E2) are inferred from the width of the `OpTypeInt`. | Capability: *ArbitraryPrecisionFloatingPointINTEL* -| 9 | 5850 | Result Type | Result | A Type | A | _Literal_ M1 | B Type | B | _Literal_ M2 +| 7 | 5850 | Result Type | Result | A | _Literal_ M1 | B | _Literal_ M2 |===== -[cols="10", width="100%"] +[cols="8", width="100%"] |===== -9+<|*OpArbitraryFloatGEINTEL* + +7+<|*OpArbitraryFloatGEINTEL* + Two `OpTypeInts` representing two arbitrary precision floating point numbers (ihc_float) are passed in as _A_ and _B_. The two numbers are compared and a value of `true` is returned in _Result_ if `A >= B`. Otherwise, a value of `false` is returned. -_Result Type_ must be a Boolean type. - -_Result_ is of type `OpTypeBool`. - -_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. +_Result Type_ must be a Boolean. -_B Type_ is an `OpTypeInt` of width `1+E2+M2` and is the type of _B_. - -_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _A_ and _B_. +_M* contains the width of the mantissa of the floating point types within _A_ and _B_. Note that the exponent values (E1, E2) are inferred from the width of the `OpTypeInt`. | Capability: *ArbitraryPrecisionFloatingPointINTEL* -| 9 | 5851 | Result Type | Result | A Type | A | _Literal_ M1 | B Type | B | _Literal_ M2 +| 7 | 5851 | Result Type | Result | A | _Literal_ M1 | B | _Literal_ M2 |===== -[cols="10", width="100%"] +[cols="8", width="100%"] |===== -9+<|*OpArbitraryFloatLTINTEL* + +7+<|*OpArbitraryFloatLTINTEL* + Two `OpTypeInts` representing two arbitrary precision floating point numbers (ihc_float) are passed in as _A_ and _B_. The two numbers are compared and a value of `true` is returned in _Result_ if `A < B`. Otherwise, a value of `false` is returned. -_Result Type_ must be a Boolean type. - -_Result_ is of type `OpTypeBool`. - -_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. +_Result Type_ must be a Boolean. -_B Type_ is an `OpTypeInt` of width `1+E2+M2` and is the type of _B_. - -_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _A_ and _B_. +_M* contains the width of the mantissa of the floating point types within _A_ and _B_. Note that the exponent values (E1, E2) are inferred from the width of the `OpTypeInt`. | Capability: *ArbitraryPrecisionFloatingPointINTEL* -| 9 | 5852 | Result Type | Result | A Type | A | _Literal_ M1 | B Type | B | _Literal_ M2 +| 7 | 5852 | Result Type | Result | A | _Literal_ M1 | B | _Literal_ M2 |===== -[cols="10", width="100%"] +[cols="8", width="100%"] |===== -9+<|*OpArbitraryFloatLEINTEL* + +7+<|*OpArbitraryFloatLEINTEL* + Two `OpTypeInts` representing two arbitrary precision floating point numbers (ihc_float) are passed in as _A_ and _B_. The two numbers are compared and a value of `true` is returned in _Result_ if `A \<= B`. Otherwise, a value of `false` is returned. -_Result Type_ must be a Boolean type. - -_Result_ is of type `OpTypeBool`. - -_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. +_Result Type_ must be a Boolean. -_B Type_ is an `OpTypeInt` of width `1+E2+M2` and is the type of _B_. - -_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _A_ and _B_. +_M* contains the width of the mantissa of the floating point types within _A_ and _B_. Note that the exponent values (E1, E2) are inferred from the width of the `OpTypeInt`. | Capability: *ArbitraryPrecisionFloatingPointINTEL* -| 9 | 5853 | Result Type | Result | A Type | A | _Literal_ M1 | B Type | B | _Literal_ M2 +| 7 | 5853 | Result Type | Result | A | _Literal_ M1 | B | _Literal_ M2 |===== -[cols="10", width="100%"] +[cols="8", width="100%"] |===== -9+<|*OpArbitraryFloatEQINTEL* + +7+<|*OpArbitraryFloatEQINTEL* + Two `OpTypeInts` representing two arbitrary precision floating point numbers (ihc_float) are passed in as _A_ and _B_. The two numbers are compared and a value of `true` is returned in _Result_ if `A == B`. Otherwise, a value of `false` is returned. -_Result Type_ must be a Boolean type. - -_Result_ is of type `OpTypeBool`. - -_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. +_Result Type_ must be a Boolean. -_B Type_ is an `OpTypeInt` of width `1+E2+M2` and is the type of _B_. - -_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _A_ and _B_. +_M* contains the width of the mantissa of the floating point types within _A_ and _B_. Note that the exponent values (E1, E2) are inferred from the width of the `OpTypeInt`. | Capability: *ArbitraryPrecisionFloatingPointINTEL* -| 9 | 5854 | Result Type | Result | A Type | A | _Literal_ M1 | B Type | B | _Literal_ M2 +| 7 | 5854 | Result Type | Result | A | _Literal_ M1 | B | _Literal_ M2 |===== -[cols="11", width="100%"] +[cols="10", width="100%"] |===== -10+<|*OpArbitraryFloatRecipINTEL* + +9+<|*OpArbitraryFloatRecipINTEL* + An `OpTypeInt` representing an arbitrary precision floating point number (ihc_float) is passed in as _A_. The reciprocal of _A_ is returned as _Result_. _Result Type_ is an `OpTypeInt` of width `1+Eout+Mout` and is the type of _Result_. -_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. - -_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _Result_ and _A_. +_M* contains the width of the mantissa of the floating point types within _Result_ and _A_. Note that the exponent values (E1, Eout) are inferred from the width of the `OpTypeInt`. _EnableSubnormals_ specifies whether subnormal numbers should be supported or flushed to zero before and after the operation and is chosen from _Table 3.16a_. @@ -470,21 +422,19 @@ _RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen | Capability: *ArbitraryPrecisionFloatingPointINTEL* -| 10 | 5855 | Result Type | Result | A Type | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +| 9 | 5855 | Result Type | Result | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy |===== -[cols="11", width="100%"] +[cols="10", width="100%"] |===== -10+<|*OpArbitraryFloatRSqrtINTEL* + +9+<|*OpArbitraryFloatRSqrtINTEL* + An `OpTypeInt` representing an arbitrary precision floating point number (ihc_float) is passed in as _A_. The reciprocal of the square root of _A_ is returned as _Result_. _Result Type_ is an `OpTypeInt` of width `1+Eout+Mout` and is the type of _Result_. -_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. - -_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _Result_ and _A_. +_M* contains the width of the mantissa of the floating point types within _Result_ and _A_. Note that the exponent values (E1, Eout) are inferred from the width of the `OpTypeInt`. _EnableSubnormals_ specifies whether subnormal numbers should be supported or flushed to zero before and after the operation and is chosen from _Table 3.16a_. @@ -495,21 +445,19 @@ _RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen | Capability: *ArbitraryPrecisionFloatingPointINTEL* -| 10 | 5856 | Result Type | Result | A Type | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +| 9 | 5856 | Result Type | Result | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy |===== -[cols="11", width="100%"] +[cols="10", width="100%"] |===== -10+<|*OpArbitraryFloatCbrtINTEL* + +9+<|*OpArbitraryFloatCbrtINTEL* + An `OpTypeInt` representing an arbitrary precision floating point number (ihc_float) is passed in as _A_. The cube root of _A_ is returned as _Result_. _Result Type_ is an `OpTypeInt` of width `1+Eout+Mout` and is the type of _Result_. -_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. - -_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _Result_ and _A_. +_M* contains the width of the mantissa of the floating point types within _Result_ and _A_. Note that the exponent values (E1, Eout) are inferred from the width of the `OpTypeInt`. _EnableSubnormals_ specifies whether subnormal numbers should be supported or flushed to zero before and after the operation and is chosen from _Table 3.16a_. @@ -520,23 +468,19 @@ _RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen | Capability: *ArbitraryPrecisionFloatingPointINTEL* -| 10 | 5857 | Result Type | Result | A Type | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +| 9 | 5857 | Result Type | Result | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy |===== -[cols="14", width="100%"] +[cols="12", width="100%"] |===== -13+<|*OpArbitraryFloatHypotINTEL* + +11+<|*OpArbitraryFloatHypotINTEL* + Two `OpTypeInts` representing two arbitrary precision floating point numbers (ihc_float) are passed in as _A_ and _B_. The hypotenuse sqrt(_A_^2 + _B_^2) is returned as _Result_. _Result Type_ is an `OpTypeInt` of width `1+Eout+Mout` and is the type of _Result_. -_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. - -_B Type_ is an `OpTypeInt` of width `1+E2+M2` and is the type of _B_. - -_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _Result_, _A_, and _B_. +_M* contains the width of the mantissa of the floating point types within _Result_, _A_, and _B_. Note that the exponent values (E1, E2, Eout) are inferred from the width of the `OpTypeInt`. _EnableSubnormals_ specifies whether subnormal numbers should be supported or flushed to zero before and after the operation and is chosen from _Table 3.16a_. @@ -547,21 +491,19 @@ _RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen | Capability: *ArbitraryPrecisionFloatingPointINTEL* -| 13 | 5858 | Result Type | Result | A Type | A | _Literal_ M1 | B Type | B | _Literal_ M2 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +| 11 | 5858 | Result Type | Result | A | _Literal_ M1 | B | _Literal_ M2 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy |===== -[cols="11", width="100%"] +[cols="10", width="100%"] |===== -10+<|*OpArbitraryFloatSqrtINTEL* + +9+<|*OpArbitraryFloatSqrtINTEL* + An `OpTypeInt` representing an arbitrary precision floating point number (ihc_float) is passed in as _A_. The square root of _A_ is returned as _Result_. _Result Type_ is an `OpTypeInt` of width `1+Eout+Mout` and is the type of _Result_. -_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. - -_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _Result_ and _A_. +_M* contains the width of the mantissa of the floating point types within _Result_ and _A_. Note that the exponent values (E1, Eout) are inferred from the width of the `OpTypeInt`. _EnableSubnormals_ specifies whether subnormal numbers should be supported or flushed to zero before and after the operation and is chosen from _Table 3.16a_. @@ -572,21 +514,19 @@ _RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen | Capability: *ArbitraryPrecisionFloatingPointINTEL* -| 10 | 5859 | Result Type | Result | A Type | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +| 9 | 5859 | Result Type | Result | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy |===== -[cols="11", width="100%"] +[cols="10", width="100%"] |===== -10+<|*OpArbitraryFloatLogINTEL* + +9+<|*OpArbitraryFloatLogINTEL* + An `OpTypeInt` representing an arbitrary precision floating point number (ihc_float) is passed in as _A_. The `ln(A)` of _A_ is returned as _Result_. _Result Type_ is an `OpTypeInt` of width `1+Eout+Mout` and is the type of _Result_. -_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. - -_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _Result_ and _A_. +_M* contains the width of the mantissa of the floating point types within _Result_ and _A_. Note that the exponent values (E1, Eout) are inferred from the width of the `OpTypeInt`. _EnableSubnormals_ specifies whether subnormal numbers should be supported or flushed to zero before and after the operation and is chosen from _Table 3.16a_. @@ -597,21 +537,19 @@ _RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen | Capability: *ArbitraryPrecisionFloatingPointINTEL* -| 10 | 5860 | Result Type | Result | A Type | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +| 9 | 5860 | Result Type | Result | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy |===== -[cols="11", width="100%"] +[cols="10", width="100%"] |===== -10+<|*OpArbitraryFloatLog2INTEL* + +9+<|*OpArbitraryFloatLog2INTEL* + An `OpTypeInt` representing an arbitrary precision floating point number (ihc_float) is passed in as _A_. The `log2(A)` of _A_ is returned as _Result_. _Result Type_ is an `OpTypeInt` of width `1+Eout+Mout` and is the type of _Result_. -_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. - -_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _Result_ and _A_. +_M* contains the width of the mantissa of the floating point types within _Result_ and _A_. Note that the exponent values (E1, Eout) are inferred from the width of the `OpTypeInt`. _EnableSubnormals_ specifies whether subnormal numbers should be supported or flushed to zero before and after the operation and is chosen from _Table 3.16a_. @@ -622,21 +560,19 @@ _RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen | Capability: *ArbitraryPrecisionFloatingPointINTEL* -| 10 | 5861 | Result Type | Result | A Type | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +| 9 | 5861 | Result Type | Result | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy |===== -[cols="11", width="100%"] +[cols="10", width="100%"] |===== -10+<|*OpArbitraryFloatLog10INTEL* + +9+<|*OpArbitraryFloatLog10INTEL* + An `OpTypeInt` representing an arbitrary precision floating point number (ihc_float) is passed in as _A_. The `log10(A)` of _A_ is returned as _Result_. _Result Type_ is an `OpTypeInt` of width `1+Eout+Mout` and is the type of _Result_. -_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. - -_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _Result_ and _A_. +_M* contains the width of the mantissa of the floating point types within _Result_ and _A_. Note that the exponent values (E1, Eout) are inferred from the width of the `OpTypeInt`. _EnableSubnormals_ specifies whether subnormal numbers should be supported or flushed to zero before and after the operation and is chosen from _Table 3.16a_. @@ -647,21 +583,19 @@ _RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen | Capability: *ArbitraryPrecisionFloatingPointINTEL* -| 10 | 5862 | Result Type | Result | A Type | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +| 9 | 5862 | Result Type | Result | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy |===== -[cols="11", width="100%"] +[cols="10", width="100%"] |===== -10+<|*OpArbitraryFloatLog1pINTEL* + +9+<|*OpArbitraryFloatLog1pINTEL* + An `OpTypeInt` representing an arbitrary precision floating point number (ihc_float) is passed in as _A_. The `ln(1+A)` of _A_ is returned as _Result_. _Result Type_ is an `OpTypeInt` of width `1+Eout+Mout` and is the type of _Result_. -_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. - -_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _Result_ and _A_. +_M* contains the width of the mantissa of the floating point types within _Result_ and _A_. Note that the exponent values (E1, Eout) are inferred from the width of the `OpTypeInt`. _EnableSubnormals_ specifies whether subnormal numbers should be supported or flushed to zero before and after the operation and is chosen from _Table 3.16a_. @@ -672,21 +606,19 @@ _RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen | Capability: *ArbitraryPrecisionFloatingPointINTEL* -| 10 | 5863 | Result Type | Result | A Type | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +| 9 | 5863 | Result Type | Result | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy |===== -[cols="11", width="100%"] +[cols="10", width="100%"] |===== -10+<|*OpArbitraryFloatExpINTEL* + +9+<|*OpArbitraryFloatExpINTEL* + An `OpTypeInt` representing an arbitrary precision floating point number (ihc_float) is passed in as _A_. The `e^(A)` of _A_ is returned as _Result_. _Result Type_ is an `OpTypeInt` of width `1+Eout+Mout` and is the type of _Result_. -_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. - -_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _Result_ and _A_. +_M* contains the width of the mantissa of the floating point types within _Result_ and _A_. Note that the exponent values (E1, Eout) are inferred from the width of the `OpTypeInt`. _EnableSubnormals_ specifies whether subnormal numbers should be supported or flushed to zero before and after the operation and is chosen from _Table 3.16a_. @@ -697,21 +629,19 @@ _RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen | Capability: *ArbitraryPrecisionFloatingPointINTEL* -| 10 | 5864 | Result Type | Result | A Type | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +| 9 | 5864 | Result Type | Result | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy |===== -[cols="11", width="100%"] +[cols="10", width="100%"] |===== -10+<|*OpArbitraryFloatExp2INTEL* + +9+<|*OpArbitraryFloatExp2INTEL* + An `OpTypeInt` representing an arbitrary precision floating point number (ihc_float) is passed in as _A_. The `2^(A)` of _A_ is returned as _Result_. _Result Type_ is an `OpTypeInt` of width `1+Eout+Mout` and is the type of _Result_. -_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. - -_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _Result_ and _A_. +_M* contains the width of the mantissa of the floating point types within _Result_ and _A_. Note that the exponent values (E1, Eout) are inferred from the width of the `OpTypeInt`. _EnableSubnormals_ specifies whether subnormal numbers should be supported or flushed to zero before and after the operation and is chosen from _Table 3.16a_. @@ -722,21 +652,19 @@ _RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen | Capability: *ArbitraryPrecisionFloatingPointINTEL* -| 10 | 5865 | Result Type | Result | A Type | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +| 9 | 5865 | Result Type | Result | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy |===== -[cols="11", width="100%"] +[cols="10", width="100%"] |===== -10+<|*OpArbitraryFloatExp10INTEL* + +9+<|*OpArbitraryFloatExp10INTEL* + An `OpTypeInt` representing an arbitrary precision floating point number (ihc_float) is passed in as _A_. The `10^(A)` of _A_ is returned as _Result_. _Result Type_ is an `OpTypeInt` of width `1+Eout+Mout` and is the type of _Result_. -_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. - -_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _Result_ and _A_. +_M* contains the width of the mantissa of the floating point types within _Result_ and _A_. Note that the exponent values (E1, Eout) are inferred from the width of the `OpTypeInt`. _EnableSubnormals_ specifies whether subnormal numbers should be supported or flushed to zero before and after the operation and is chosen from _Table 3.16a_. @@ -747,21 +675,19 @@ _RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen | Capability: *ArbitraryPrecisionFloatingPointINTEL* -| 10 | 5866 | Result Type | Result | A Type | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +| 9 | 5866 | Result Type | Result | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy |===== -[cols="11", width="100%"] +[cols="10", width="100%"] |===== -10+<|*OpArbitraryFloatExp1mINTEL* + +9+<|*OpArbitraryFloatExp1mINTEL* + An `OpTypeInt` representing an arbitrary precision floating point number (ihc_float) is passed in as _A_. The `(e^A)-1` of _A_ is returned as _Result_. _Result Type_ is an `OpTypeInt` of width `1+Eout+Mout` and is the type of _Result_. -_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. - -_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _Result_ and _A_. +_M* contains the width of the mantissa of the floating point types within _Result_ and _A_. Note that the exponent values (E1, Eout) are inferred from the width of the `OpTypeInt`. _EnableSubnormals_ specifies whether subnormal numbers should be supported or flushed to zero before and after the operation and is chosen from _Table 3.16a_. @@ -772,21 +698,19 @@ _RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen | Capability: *ArbitraryPrecisionFloatingPointINTEL* -| 10 | 5867 | Result Type | Result | A Type | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +| 9 | 5867 | Result Type | Result | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy |===== -[cols="11", width="100%"] +[cols="10", width="100%"] |===== -10+<|*OpArbitraryFloatSinINTEL* + +9+<|*OpArbitraryFloatSinINTEL* + An `OpTypeInt` representing an arbitrary precision floating point number (ihc_float) is passed in as _A_. The sine of _A_ is returned as _Result_. _Result Type_ is an `OpTypeInt` of width `1+Eout+Mout` and is the type of _Result_. -_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. - -_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _Result_ and _A_. +_M* contains the width of the mantissa of the floating point types within _Result_ and _A_. Note that the exponent values (E1, Eout) are inferred from the width of the `OpTypeInt`. _EnableSubnormals_ specifies whether subnormal numbers should be supported or flushed to zero before and after the operation and is chosen from _Table 3.16a_. @@ -797,21 +721,19 @@ _RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen | Capability: *ArbitraryPrecisionFloatingPointINTEL* -| 10 | 5868 | Result Type | Result | A Type | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +| 9 | 5868 | Result Type | Result | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy |===== -[cols="11", width="100%"] +[cols="10", width="100%"] |===== -10+<|*OpArbitraryFloatCosINTEL* + +9+<|*OpArbitraryFloatCosINTEL* + An `OpTypeInt` representing an arbitrary precision floating point number (ihc_float) is passed in as _A_. The cosine of _A_ is returned as _Result_. _Result Type_ is an `OpTypeInt` of width `1+Eout+Mout` and is the type of _Result_. -_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. - -_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _Result_ and _A_. +_M* contains the width of the mantissa of the floating point types within _Result_ and _A_. Note that the exponent values (E1, Eout) are inferred from the width of the `OpTypeInt`. _EnableSubnormals_ specifies whether subnormal numbers should be supported or flushed to zero before and after the operation and is chosen from _Table 3.16a_. @@ -822,12 +744,12 @@ _RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen | Capability: *ArbitraryPrecisionFloatingPointINTEL* -| 10 | 5869 | Result Type | Result | A Type | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +| 9 | 5869 | Result Type | Result | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy |===== -[cols="11", width="100%"] +[cols="10", width="100%"] |===== -10+<|*OpArbitraryFloatSinCosINTEL* + +9+<|*OpArbitraryFloatSinCosINTEL* + An `OpTypeInt` representing an arbitrary precision floating point number (ihc_float) is passed in as _A_. The sine and cosine of _A_ is returned as _Result_. @@ -835,9 +757,7 @@ The sine and cosine of _A_ is returned as _Result_. _Result Type_ is an `OpTypeInt` of width `2*(1+Eout+Mout)` and is the type of _Result_. The _Result_ holds both the sine and cosine with the lower significant bits holding the cosine result, and the more significant bits holding the sine results. -_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. - -_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _Result_ and _A_. +_M* contains the width of the mantissa of the floating point types within _Result_ and _A_. Note that the exponent values (E1, Eout) are inferred from the width of the `OpTypeInt`. _EnableSubnormals_ specifies whether subnormal numbers should be supported or flushed to zero before and after the operation and is chosen from _Table 3.16a_. @@ -848,21 +768,19 @@ _RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen | Capability: *ArbitraryPrecisionFloatingPointINTEL* -| 10 | 5870 | Result Type | Result | A Type | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +| 9 | 5870 | Result Type | Result | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy |===== -[cols="11", width="100%"] +[cols="10", width="100%"] |===== -10+<|*OpArbitraryFloatSinPiINTEL* + +9+<|*OpArbitraryFloatSinPiINTEL* + An `OpTypeInt` representing an arbitrary precision floating point number (ihc_float) is passed in as _A_. The `sin(A*pi)` is returned as _Result_. _Result Type_ is an `OpTypeInt` of width `1+Eout+Mout` and is the type of _Result_. -_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. - -_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _Result_ and _A_. +_M* contains the width of the mantissa of the floating point types within _Result_ and _A_. Note that the exponent values (E1, Eout) are inferred from the width of the `OpTypeInt`. _EnableSubnormals_ specifies whether subnormal numbers should be supported or flushed to zero before and after the operation and is chosen from _Table 3.16a_. @@ -873,21 +791,19 @@ _RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen | Capability: *ArbitraryPrecisionFloatingPointINTEL* -| 10 | 5871 | Result Type | Result | A Type | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +| 9 | 5871 | Result Type | Result | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy |===== -[cols="11", width="100%"] +[cols="10", width="100%"] |===== -10+<|*OpArbitraryFloatCosPiINTEL* + +9+<|*OpArbitraryFloatCosPiINTEL* + An `OpTypeInt` representing an arbitrary precision floating point number (ihc_float) is passed in as _A_. The `cos(A*pi)` is returned as _Result_. _Result Type_ is an `OpTypeInt` of width `1+Eout+Mout` and is the type of _Result_. -_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. - -_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _Result_ and _A_. +_M* contains the width of the mantissa of the floating point types within _Result_ and _A_. Note that the exponent values (E1, Eout) are inferred from the width of the `OpTypeInt`. _EnableSubnormals_ specifies whether subnormal numbers should be supported or flushed to zero before and after the operation and is chosen from _Table 3.16a_. @@ -898,12 +814,12 @@ _RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen | Capability: *ArbitraryPrecisionFloatingPointINTEL* -| 10 | 5872 | Result Type | Result | A Type | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +| 9 | 5872 | Result Type | Result | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy |===== -[cols="11", width="100%"] +[cols="10", width="100%"] |===== -10+<|*OpArbitraryFloatSinCosPiINTEL* + +9+<|*OpArbitraryFloatSinCosPiINTEL* + An `OpTypeInt` representing an arbitrary precision floating point number (ihc_float) is passed in as _A_. The sine and cosine of `A*pi` is returned as _Result_. @@ -911,9 +827,7 @@ The sine and cosine of `A*pi` is returned as _Result_. _Result Type_ is an `OpTypeInt` of width `2*(1+Eout+Mout)` and is the type of _Result_. The _Result_ holds both the sine and cosine with the lower significant bits holding the cosine result, and the more significant bits holding the sine results. -_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. - -_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _Result_ and _A_. +_M* contains the width of the mantissa of the floating point types within _Result_ and _A_. Note that the exponent values (E1, Eout) are inferred from the width of the `OpTypeInt`. _EnableSubnormals_ specifies whether subnormal numbers should be supported or flushed to zero before and after the operation and is chosen from _Table 3.16a_. @@ -924,21 +838,19 @@ _RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen | Capability: *ArbitraryPrecisionFloatingPointINTEL* -| 10 | 5840 | Result Type | Result | A Type | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +| 9 | 5840 | Result Type | Result | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy |===== -[cols="11", width="100%"] +[cols="10", width="100%"] |===== -10+<|*OpArbitraryFloatASinINTEL* + +9+<|*OpArbitraryFloatASinINTEL* + An `OpTypeInt` representing an arbitrary precision floating point number (ihc_float) is passed in as _A_. The `arcsin(A)` is returned as _Result_. _Result Type_ is an `OpTypeInt` of width `1+Eout+Mout` and is the type of _Result_. -_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. - -_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _Result_ and _A_. +_M* contains the width of the mantissa of the floating point types within _Result_ and _A_. Note that the exponent values (E1, Eout) are inferred from the width of the `OpTypeInt`. _EnableSubnormals_ specifies whether subnormal numbers should be supported or flushed to zero before and after the operation and is chosen from _Table 3.16a_. @@ -949,21 +861,19 @@ _RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen | Capability: *ArbitraryPrecisionFloatingPointINTEL* -| 10 | 5873 | Result Type | Result | A Type | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +| 9 | 5873 | Result Type | Result | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy |===== -[cols="11", width="100%"] +[cols="10", width="100%"] |===== -10+<|*OpArbitraryFloatASinPiINTEL* + +9+<|*OpArbitraryFloatASinPiINTEL* + An `OpTypeInt` representing an arbitrary precision floating point number (ihc_float) is passed in as _A_. The `arcsin(A*pi)` is returned as _Result_. _Result Type_ is an `OpTypeInt` of width `1+Eout+Mout` and is the type of _Result_. -_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. - -_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _Result_ and _A_. +_M* contains the width of the mantissa of the floating point types within _Result_ and _A_. Note that the exponent values (E1, Eout) are inferred from the width of the `OpTypeInt`. _EnableSubnormals_ specifies whether subnormal numbers should be supported or flushed to zero before and after the operation and is chosen from _Table 3.16a_. @@ -974,21 +884,19 @@ _RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen | Capability: *ArbitraryPrecisionFloatingPointINTEL* -| 10 | 5874 | Result Type | Result | A Type | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +| 9 | 5874 | Result Type | Result | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy |===== -[cols="11", width="100%"] +[cols="10", width="100%"] |===== -10+<|*OpArbitraryFloatACosINTEL* + +9+<|*OpArbitraryFloatACosINTEL* + An `OpTypeInt` representing an arbitrary precision floating point number (ihc_float) is passed in as _A_. The `arccos(A)` is returned as _Result_. _Result Type_ is an `OpTypeInt` of width `1+Eout+Mout` and is the type of _Result_. -_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. - -_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _Result_ and _A_. +_M* contains the width of the mantissa of the floating point types within _Result_ and _A_. Note that the exponent values (E1, Eout) are inferred from the width of the `OpTypeInt`. _EnableSubnormals_ specifies whether subnormal numbers should be supported or flushed to zero before and after the operation and is chosen from _Table 3.16a_. @@ -999,21 +907,19 @@ _RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen | Capability: *ArbitraryPrecisionFloatingPointINTEL* -| 10 | 5875 | Result Type | Result | A Type | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +| 9 | 5875 | Result Type | Result | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy |===== -[cols="11", width="100%"] +[cols="10", width="100%"] |===== -10+<|*OpArbitraryFloatACosPiINTEL* + +9+<|*OpArbitraryFloatACosPiINTEL* + An `OpTypeInt` representing an arbitrary precision floating point number (ihc_float) is passed in as _A_. The `arccos(A*pi)` is returned as _Result_. _Result Type_ is an `OpTypeInt` of width `1+Eout+Mout` and is the type of _Result_. -_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. - -_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _Result_ and _A_. +_M* contains the width of the mantissa of the floating point types within _Result_ and _A_. Note that the exponent values (E1, Eout) are inferred from the width of the `OpTypeInt`. _EnableSubnormals_ specifies whether subnormal numbers should be supported or flushed to zero before and after the operation and is chosen from _Table 3.16a_. @@ -1024,21 +930,19 @@ _RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen | Capability: *ArbitraryPrecisionFloatingPointINTEL* -| 10 | 5876 | Result Type | Result | A Type | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +| 9 | 5876 | Result Type | Result | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy |===== -[cols="11", width="100%"] +[cols="10", width="100%"] |===== -10+<|*OpArbitraryFloatATanINTEL* + +9+<|*OpArbitraryFloatATanINTEL* + An `OpTypeInt` representing an arbitrary precision floating point number (ihc_float) is passed in as _A_. The `arctan(A)` is returned as _Result_. _Result Type_ is an `OpTypeInt` of width `1+Eout+Mout` and is the type of _Result_. -_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. - -_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _Result_ and _A_. +_M* contains the width of the mantissa of the floating point types within _Result_ and _A_. Note that the exponent values (E1, Eout) are inferred from the width of the `OpTypeInt`. _EnableSubnormals_ specifies whether subnormal numbers should be supported or flushed to zero before and after the operation and is chosen from _Table 3.16a_. @@ -1049,21 +953,19 @@ _RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen | Capability: *ArbitraryPrecisionFloatingPointINTEL* -| 10 | 5877 | Result Type | Result | A Type | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +| 9 | 5877 | Result Type | Result | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy |===== -[cols="11", width="100%"] +[cols="10", width="100%"] |===== -10+<|*OpArbitraryFloatATanPiINTEL* + +9+<|*OpArbitraryFloatATanPiINTEL* + An `OpTypeInt` representing an arbitrary precision floating point number (ihc_float) is passed in as _A_. The `arctan(A*pi)` is returned as _Result_. _Result Type_ is an `OpTypeInt` of width `1+Eout+Mout` and is the type of _Result_. -_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. - -_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _Result_ and _A_. +_M* contains the width of the mantissa of the floating point types within _Result_ and _A_. Note that the exponent values (E1, Eout) are inferred from the width of the `OpTypeInt`. _EnableSubnormals_ specifies whether subnormal numbers should be supported or flushed to zero before and after the operation and is chosen from _Table 3.16a_. @@ -1074,23 +976,19 @@ _RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen | Capability: *ArbitraryPrecisionFloatingPointINTEL* -| 10 | 5878 | Result Type | Result | A Type | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +| 9 | 5878 | Result Type | Result | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy |===== -[cols="14", width="100%"] +[cols="12", width="100%"] |===== -13+<|*OpArbitraryFloatTan2INTEL* + +11+<|*OpArbitraryFloatTan2INTEL* + Two `OpTypeInts` representing two arbitrary precision floating point numbers (ihc_float) are passed in as _A_ and _B_. The `arctan2(A,B) = arctan(A/B)` is returned as _Result_. _Result Type_ is an `OpTypeInt` of width `1+Eout+Mout` and is the type of _Result_. -_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. - -_B Type_ is an `OpTypeInt` of width `1+E2+M2` and is the type of _B_. - -_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _Result_, _A_, and _B_. +_M* contains the width of the mantissa of the floating point types within _Result_, _A_, and _B_. Note that the exponent values (E1, E2, Eout) are inferred from the width of the `OpTypeInt`. _EnableSubnormals_ specifies whether subnormal numbers should be supported or flushed to zero before and after the operation and is chosen from _Table 3.16a_. @@ -1101,23 +999,19 @@ _RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen | Capability: *ArbitraryPrecisionFloatingPointINTEL* -| 13 | 5879 | Result Type | Result | A Type | A | _Literal_ M1 | B Type | B | _Literal_ M2 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +| 11 | 5879 | Result Type | Result | A | _Literal_ M1 | B | _Literal_ M2 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy |===== -[cols="14", width="100%"] +[cols="12", width="100%"] |===== -13+<|*OpArbitraryFloatPowINTEL* + +11+<|*OpArbitraryFloatPowINTEL* + Two `OpTypeInts` representing two arbitrary precision floating point numbers (ihc_float) are passed in as _A_ and _B_. The value of `A^B` is returned in _Result_. _Result Type_ is an `OpTypeInt` of width `1+Eout+Mout` and is the type of _Result_. -_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. - -_B Type_ is an `OpTypeInt` of width `1+E2+M2` and is the type of _B_. - -_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _Result_, _A_, and _B_. +_M* contains the width of the mantissa of the floating point types within _Result_, _A_, and _B_. Note that the exponent values (E1, E2, Eout) are inferred from the width of the `OpTypeInt`. _EnableSubnormals_ specifies whether subnormal numbers should be supported or flushed to zero before and after the operation and is chosen from _Table 3.16a_. @@ -1128,23 +1022,19 @@ _RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen | Capability: *ArbitraryPrecisionFloatingPointINTEL* -| 13 | 5880 | Result Type | Result | A Type | A | _Literal_ M1 | B Type | B | _Literal_ M2 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +| 11 | 5880 | Result Type | Result | A | _Literal_ M1 | B | _Literal_ M2 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy |===== -[cols="14", width="100%"] +[cols="12", width="100%"] |===== -13+<|*OpArbitraryFloatPowRINTEL* + +11+<|*OpArbitraryFloatPowRINTEL* + Two `OpTypeInts` representing two arbitrary precision floating point numbers (ihc_float) are passed in as _A_ and _B_. The value of `A^B` is returned in _Result_. However, `A >= 0`, otherwise, the result is undefined. _Result Type_ is an `OpTypeInt` of width `1+Eout+Mout` and is the type of _Result_. -_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. - -_B Type_ is an `OpTypeInt` of width `1+E2+M2` and is the type of _B_. - -_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _Result_, _A_, and _B_. +_M* contains the width of the mantissa of the floating point types within _Result_, _A_, and _B_. Note that the exponent values (E1, E2, Eout) are inferred from the width of the `OpTypeInt`. _EnableSubnormals_ specifies whether subnormal numbers should be supported or flushed to zero before and after the operation and is chosen from _Table 3.16a_. @@ -1155,24 +1045,19 @@ _RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen | Capability: *ArbitraryPrecisionFloatingPointINTEL* -| 13 | 5881 | Result Type | Result | A Type | A | _Literal_ M1 | B Type | B | _Literal_ M2 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +| 11 | 5881 | Result Type | Result | A | _Literal_ M1 | B | _Literal_ M2 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy |===== - -[cols="13", width="100%"] +[cols="11", width="100%"] |===== -12+<|*OpArbitraryFloatPowNINTEL* + +10+<|*OpArbitraryFloatPowNINTEL* + Two `OpTypeInts` representing arbitrary precision floating point number (ihc_float) and arbitrary precision integer number are passed in as _A_ and _B_ respectively. The value of `A^B` is returned in _Result_ where `B` is an integer of arbitrary size. _Result Type_ is an `OpTypeInt` of width `1+Eout+Mout` and is the type of _Result_. -_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. - -_B Type_ is an `OpTypeInt` of width `W` and is the type of _B_. - -_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _Result_ and _A_. +_M* contains the width of the mantissa of the floating point types within _Result_ and _A_. Note that the exponent values (E1, Eout) are inferred from the width of the `OpTypeInt`. _EnableSubnormals_ specifies whether subnormal numbers should be supported or flushed to zero before and after the operation and is chosen from _Table 3.16a_. @@ -1183,21 +1068,19 @@ _RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen | Capability: *ArbitraryPrecisionFloatingPointINTEL* -| 12 | 5882 | Result Type | Result | A Type | A | _Literal_ M1 | B Type | B | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +| 10 | 5882 | Result Type | Result | A | _Literal_ M1 | B | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy |===== -[cols="11", width="100%"] +[cols="10", width="100%"] |===== -10+<|*OpArbitraryFloatCastINTEL* + +9+<|*OpArbitraryFloatCastINTEL* + An `OpTypeInt` representing an arbitrary precision floating point number (ihc_float) is passed in as _A_. It is type casted into an arbitrary precision floating point number with the new specification (Eout, Mout) and returned as _Result_. _Result Type_ is an `OpTypeInt` of width `1+Eout+Mout` and is the type of _Result_. -_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. - -_E*_ and _M*_ contain the width of the exponent and the mantissa of the floating point types within _Result_ and _A_. +_M* contains the width of the mantissa of the floating point types within _Result_ and _A_. Note that the exponent values (E1, Eout) are inferred from the width of the `OpTypeInt`. _EnableSubnormals_ specifies whether subnormal numbers should be supported or flushed to zero before and after the operation and is chosen from _Table 3.16a_. @@ -1208,20 +1091,18 @@ _RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen | Capability: *ArbitraryPrecisionFloatingPointINTEL* -| 10 | 5841 | Result Type | Result | A Type | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +| 9 | 5841 | Result Type | Result | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy |===== -[cols="10", width="100%"] +[cols="9", width="100%"] |===== -9+<|*OpArbitraryFloatCastFromIntINTEL* + +8+<|*OpArbitraryFloatCastFromIntINTEL* + An `OpTypeInt` representing an arbitrary precision integer is passed in as _A_. It is type casted into an arbitrary precision floating point number with the new specification (Eout, Mout) and returned as _Result_. _Result Type_ is an `OpTypeInt` of width `1+Eout+Mout` and is the type of _Result_. -_A Type_ is an `OpTypeInt` of width `W` and is the type of _A_. - _Eout_ and _Mout_ contain the width of the exponent and the mantissa of the floating point type of _Result_. Note that the exponent value (Eout) is inferred from the width of the `OpTypeInt`. @@ -1233,20 +1114,18 @@ _RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen | Capability: *ArbitraryPrecisionFloatingPointINTEL* -| 9 | 5842 | Result Type | Result | A Type | A | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +| 8 | 5842 | Result Type | Result | A | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy |===== -[cols="10", width="100%"] +[cols="9", width="100%"] |===== -9+<|*OpArbitraryFloatCastToIntINTEL* + +8+<|*OpArbitraryFloatCastToIntINTEL* + An `OpTypeInt` representing an arbitrary precision floating point number (ihc_float) is passed in as _A_. It is type casted into an arbitrary precision integer with width `W` and returned as _Result_. _Result Type_ is an `OpTypeInt` of width `W` and is the type of _Result_. -_A Type_ is an `OpTypeInt` of width `1+E1+M1` and is the type of _A_. - _E1_ and _M1_ contain the width of the exponent and the mantissa of the floating point type of _A_. Note that the exponent value (E1) is inferred from the width of the `OpTypeInt`. @@ -1258,7 +1137,7 @@ _RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen | Capability: *ArbitraryPrecisionFloatingPointINTEL* -| 9 | 5843 | Result Type | Result | A Type | A | _Literal_ M1 | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +| 8 | 5843 | Result Type | Result | A | _Literal_ M1 | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy |===== === Validation Rules @@ -1276,5 +1155,5 @@ None. |Rev |Date |Author |Changes |A |2020-01-30 |Ajaykumar Kannan |Initial Version |B |2020-05-22 |Ajaykumar Kannan |Addressed a number of issues -|C |2020-06-19 |Ajaykumar Kannan |Initial Public Release +|C |2020-07-19 |Ajaykumar Kannan |Initial Public Release |=================================================================== From 2686ad93fec2c6782cf7d518cca48c73436c5af5 Mon Sep 17 00:00:00 2001 From: Ajaykumar Kannan Date: Sun, 19 Jul 2020 23:51:16 -0400 Subject: [PATCH 08/19] Added Kernel capability as an implictly declared to arbitrary floating point functions --- .../SPV_INTEL_arbitrary_precision_floating_point.asciidoc | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_floating_point.asciidoc b/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_floating_point.asciidoc index 4d2da98e6191c..50eedac59e6ba 100755 --- a/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_floating_point.asciidoc +++ b/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_floating_point.asciidoc @@ -47,6 +47,7 @@ The datatype is additionally described with two parameters: * _M_: represents the number of mantissa bits The total width of the type is `E+M+1` where the last bit is used to represent the sign. +Note that the signedness capabilities of `OpTypeInt` are not used for any of the operations. The data layout is shown below: `[ S (sign bit) ][ E (Exponent) ][ M (Mantissa) ]` @@ -217,7 +218,7 @@ Modify Section 3.31, *Capability*, adding a row to the Capability table: Allows the use of various operations for arbitrary precision floating-point math -| *ArbitraryPrecisionIntegersINTEL* | +| *ArbitraryPrecisionIntegersINTEL*, *Kernel* | |==== === Instructions From 6c45d517afd8b9edaf78e818ccc51fe13496dc70 Mon Sep 17 00:00:00 2001 From: Ajaykumar Kannan Date: Mon, 20 Jul 2020 00:31:06 -0400 Subject: [PATCH 09/19] Updated the literals statements for the fixed point arbitrary math operations --- ...L_arbitrary_precision_fixed_point.asciidoc | 110 +++++++++--------- 1 file changed, 55 insertions(+), 55 deletions(-) diff --git a/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_fixed_point.asciidoc b/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_fixed_point.asciidoc index c449a2f305252..64cef4c69447a 100644 --- a/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_fixed_point.asciidoc +++ b/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_fixed_point.asciidoc @@ -183,16 +183,16 @@ _Result Type_ is an `OpTypeInt` of width _rW_ and is the type of _Result_. _Input Type_ is an `OpTypeInt` of width _W_ and is the type of _Input_. -_S_ is an `OpTypeBool` that indicates if the input and output are signed or unsigned. +_S_ is an integer literal, treated as a boolean, that indicates if the input and output are signed or unsigned. A value of `1` indicates that the two types are signed. -_I_ is an `OpTypeInt` that refers to the location of the fixed-point relative to the MSB of the input. +_I_ is an integer literal that refers to the location of the fixed-point relative to the MSB of the input. -_rI_ is an `OpTypeInt` that refers to the location of the fixed-point relative to the MSB of the result. +_rI_ is an integer literal that refers to the location of the fixed-point relative to the MSB of the result. -_Q_ is an `OpTypeInt` chosen from _Table 3.16b_ that indicates the Quantization Mode of this operation. +_Q_ is an integer literal chosen from _Table 3.16b_ that indicates the Quantization Mode of this operation. -_O_ is an `OpTypeInt` chosen from _Table 3.16c_ that indicates the Overflow Mode of this operation. +_O_ is an integer literal chosen from _Table 3.16c_ that indicates the Overflow Mode of this operation. | Capability: *ArbitraryPrecisionFixedPointINTEL* @@ -210,16 +210,16 @@ _Result Type_ is an `OpTypeInt` of width _rW_ and is the type of _Result_. _Input Type_ is an `OpTypeInt` of width _W_ and is the type of _Input_. -_S_ is an `OpTypeBool` that indicates if the input and output are signed or unsigned. +_S_ is an integer literal, treated as a boolean, that indicates if the input and output are signed or unsigned. A value of `1` indicates that the two types are signed. -_I_ is an `OpTypeInt` that refers to the location of the fixed-point relative to the MSB of the input. +_I_ is an integer literal that refers to the location of the fixed-point relative to the MSB of the input. -_rI_ is an `OpTypeInt` that refers to the location of the fixed-point relative to the MSB of the result. +_rI_ is an integer literal that refers to the location of the fixed-point relative to the MSB of the result. -_Q_ is an `OpTypeInt` chosen from _Table 3.16b_ that indicates the Quantization Mode of this operation. +_Q_ is an integer literal chosen from _Table 3.16b_ that indicates the Quantization Mode of this operation. -_O_ is an `OpTypeInt` chosen from _Table 3.16c_ that indicates the Overflow Mode of this operation. +_O_ is an integer literal chosen from _Table 3.16c_ that indicates the Overflow Mode of this operation. | Capability: *ArbitraryPrecisionFixedPointINTEL* @@ -238,16 +238,16 @@ _Result Type_ is an `OpTypeInt` of width _rW_ and is the type of _Result_. _Input Type_ is an `OpTypeInt` of width _W_ and is the type of _Input_. -_S_ is an `OpTypeBool` that indicates if the input and output are signed or unsigned. +_S_ is an integer literal, treated as a boolean, that indicates if the input and output are signed or unsigned. A value of `1` indicates that the two types are signed. -_I_ is an `OpTypeInt` that refers to the location of the fixed-point relative to the MSB of the input. +_I_ is an integer literal that refers to the location of the fixed-point relative to the MSB of the input. -_rI_ is an `OpTypeInt` that refers to the location of the fixed-point relative to the MSB of the result. +_rI_ is an integer literal that refers to the location of the fixed-point relative to the MSB of the result. -_Q_ is an `OpTypeInt` chosen from _Table 3.16b_ that indicates the Quantization Mode of this operation. +_Q_ is an integer literal chosen from _Table 3.16b_ that indicates the Quantization Mode of this operation. -_O_ is an `OpTypeInt` chosen from _Table 3.16c_ that indicates the Overflow Mode of this operation. +_O_ is an integer literal chosen from _Table 3.16c_ that indicates the Overflow Mode of this operation. | Capability: *ArbitraryPrecisionFixedPointINTEL* @@ -265,16 +265,16 @@ _Input Type_ is an `OpTypeInt` of width _W_ and is the type of _Input_. _Result Type_ is an `OpTypeInt` of width _rW_ and is the type of _Result_. -_S_ is an `OpTypeBool` that indicates if the input and output are signed or unsigned. +_S_ is an integer literal, treated as a boolean, that indicates if the input and output are signed or unsigned. A value of `1` indicates that the two types are signed. -_I_ is an `OpTypeInt` that refers to the location of the fixed-point relative to the MSB of the input type. +_I_ is an integer literal that refers to the location of the fixed-point relative to the MSB of the input type. -_rI_ is an `OpTypeInt` that refers to the location of the fixed-point relative to the MSB of the result type. +_rI_ is an integer literal that refers to the location of the fixed-point relative to the MSB of the result type. -_Q_ is an `OpTypeInt` chosen from _Table 3.16b_ that indicates the Quantization Mode of this operation. +_Q_ is an integer literal chosen from _Table 3.16b_ that indicates the Quantization Mode of this operation. -_O_ is an `OpTypeInt` chosen from _Table 3.16c_ that indicates the Overflow Mode of this operation. +_O_ is an integer literal chosen from _Table 3.16c_ that indicates the Overflow Mode of this operation. | Capability: *ArbitraryPrecisionFixedPointINTEL* @@ -292,16 +292,16 @@ _Result Type_ is an `OpTypeInt` of width _rW_ and is the type of _Result_. _Input Type_ is an `OpTypeInt` of width _W_ and is the type of _Input_. -_S_ is an `OpTypeBool` that indicates if the input and output are signed or unsigned. +_S_ is an integer literal, treated as a boolean, that indicates if the input and output are signed or unsigned. A value of `1` indicates that the two types are signed. -_I_ is an `OpTypeInt` that refers to the location of the fixed-point relative to the MSB. +_I_ is an integer literal that refers to the location of the fixed-point relative to the MSB. -_rI_ is an `OpTypeInt` that refers to the location of the fixed-point relative to the MSB of the result type. +_rI_ is an integer literal that refers to the location of the fixed-point relative to the MSB of the result type. -_Q_ is an `OpTypeInt` chosen from _Table 3.16b_ that indicates the Quantization Mode of this operation. +_Q_ is an integer literal chosen from _Table 3.16b_ that indicates the Quantization Mode of this operation. -_O_ is an `OpTypeInt` chosen from _Table 3.16c_ that indicates the Overflow Mode of this operation. +_O_ is an integer literal chosen from _Table 3.16c_ that indicates the Overflow Mode of this operation. | Capability: *ArbitraryPrecisionFixedPointINTEL* @@ -320,16 +320,16 @@ _Input Type_ is an `OpTypeInt` of width _W_ and is the type of _Input_. _Result Type_ is an `OpTypeInt` of `2 * rW` and is the type of _Result_. The lower significant bits (`rW`) of the _Result_ are used to hold the cosine value, and the more significant bits (`rW`) are used to hold the sine value. -_S_ is an `OpTypeBool` that indicates if the input and output are signed or unsigned. +_S_ is an integer literal, treated as a boolean, that indicates if the input and output are signed or unsigned. A value of `1` indicates that the two types are signed. -_I_ is an `OpTypeInt` that refers to the location of the fixed-point relative to the MSB. +_I_ is an integer literal that refers to the location of the fixed-point relative to the MSB. -_rI_ is an `OpTypeInt` that refers to the location of the fixed-point relative to the MSB of the result type. +_rI_ is an integer literal that refers to the location of the fixed-point relative to the MSB of the result type. -_Q_ is an `OpTypeInt` chosen from _Table 3.16b_ that indicates the Quantization Mode of this operation. +_Q_ is an integer literal chosen from _Table 3.16b_ that indicates the Quantization Mode of this operation. -_O_ is an `OpTypeInt` chosen from _Table 3.16c_ that indicates the Overflow Mode of this operation. +_O_ is an integer literal chosen from _Table 3.16c_ that indicates the Overflow Mode of this operation. | Capability: *ArbitraryPrecisionFixedPointINTEL* @@ -347,16 +347,16 @@ _Result Type_ is an `OpTypeInt` of width _rW_ and is the type of _Result_. _Input Type_ is an `OpTypeInt` of width _W_ and is the type of _Input_. -_S_ is an `OpTypeBool` that indicates if the input and output are signed or unsigned. +_S_ is an integer literal, treated as a boolean, that indicates if the input and output are signed or unsigned. A value of `1` indicates that the two types are signed. -_I_ is an `OpTypeInt` that refers to the location of the fixed-point relative to the MSB. +_I_ is an integer literal that refers to the location of the fixed-point relative to the MSB. -_rI_ is an `OpTypeInt` that refers to the location of the fixed-point relative to the MSB of the result type. +_rI_ is an integer literal that refers to the location of the fixed-point relative to the MSB of the result type. -_Q_ is an `OpTypeInt` chosen from _Table 3.16b_ that indicates the Quantization Mode of this operation. +_Q_ is an integer literal chosen from _Table 3.16b_ that indicates the Quantization Mode of this operation. -_O_ is an `OpTypeInt` chosen from _Table 3.16c_ that indicates the Overflow Mode of this operation. +_O_ is an integer literal chosen from _Table 3.16c_ that indicates the Overflow Mode of this operation. | Capability: *ArbitraryPrecisionFixedPointINTEL* @@ -374,16 +374,16 @@ _Result Type_ is an `OpTypeInt` of width _rW_ and is the type of _Result_. _Input Type_ is an `OpTypeInt` of width _W_ and is the type of _Input_. -_S_ is an `OpTypeBool` that indicates if the input and output are signed or unsigned. +_S_ is an integer literal, treated as a boolean, that indicates if the input and output are signed or unsigned. A value of `1` indicates that the two types are signed. -_I_ is an `OpTypeInt` that refers to the location of the fixed-point relative to the MSB. +_I_ is an integer literal that refers to the location of the fixed-point relative to the MSB. -_rI_ is an `OpTypeInt` that refers to the location of the fixed-point relative to the MSB of the result type. +_rI_ is an integer literal that refers to the location of the fixed-point relative to the MSB of the result type. -_Q_ is an `OpTypeInt` chosen from _Table 3.16b_ that indicates the Quantization Mode of this operation. +_Q_ is an integer literal chosen from _Table 3.16b_ that indicates the Quantization Mode of this operation. -_O_ is an `OpTypeInt` chosen from _Table 3.16c_ that indicates the Overflow Mode of this operation. +_O_ is an integer literal chosen from _Table 3.16c_ that indicates the Overflow Mode of this operation. | Capability: *ArbitraryPrecisionFixedPointINTEL* @@ -403,16 +403,16 @@ _Input Type_ is an `OpTypeInt` of width _W_ and is the type of _Input_. _Result Type_ is an `OpTypeInt` of twice the width of `rW` and is the type of _Result_. The lower significant bits (`rW`) of the _Result_ are used to hold the cosine value, and the more significant bits (`rW`) are used to hold the sine value. -_S_ is an `OpTypeBool` that indicates if the input and output are signed or unsigned. +_S_ is an integer literal, treated as a boolean, that indicates if the input and output are signed or unsigned. A value of `1` indicates that the two types are signed. -_I_ is an `OpTypeInt` that refers to the location of the fixed-point relative to the MSB. +_I_ is an integer literal that refers to the location of the fixed-point relative to the MSB. -_rI_ is an `OpTypeInt` that refers to the location of the fixed-point relative to the MSB of the result type. +_rI_ is an integer literal that refers to the location of the fixed-point relative to the MSB of the result type. -_Q_ is an `OpTypeInt` chosen from _Table 3.16b_ that indicates the Quantization Mode of this operation. +_Q_ is an integer literal chosen from _Table 3.16b_ that indicates the Quantization Mode of this operation. -_O_ is an `OpTypeInt` chosen from _Table 3.16c_ that indicates the Overflow Mode of this operation. +_O_ is an integer literal chosen from _Table 3.16c_ that indicates the Overflow Mode of this operation. | Capability: *ArbitraryPrecisionFixedPointINTEL* @@ -430,16 +430,16 @@ _Result Type_ is an `OpTypeInt` of width _rW_ and is the type of _Result_. _Input Type_ is an `OpTypeInt` of width _W_ and is the type of _Input_. -_S_ is an `OpTypeBool` that indicates if the input and output are signed or unsigned. +_S_ is an integer literal, treated as a boolean, that indicates if the input and output are signed or unsigned. A value of `1` indicates that the two types are signed. -_I_ is an `OpTypeInt` that refers to the location of the fixed-point relative to the MSB. +_I_ is an integer literal that refers to the location of the fixed-point relative to the MSB. -_rI_ is an `OpTypeInt` that refers to the location of the fixed-point relative to the MSB of the result type. +_rI_ is an integer literal that refers to the location of the fixed-point relative to the MSB of the result type. -_Q_ is an `OpTypeInt` chosen from _Table 3.16b_ that indicates the Quantization Mode of this operation. +_Q_ is an integer literal chosen from _Table 3.16b_ that indicates the Quantization Mode of this operation. -_O_ is an `OpTypeInt` chosen from _Table 3.16c_ that indicates the Overflow Mode of this operation. +_O_ is an integer literal chosen from _Table 3.16c_ that indicates the Overflow Mode of this operation. | Capability: *ArbitraryPrecisionFixedPointINTEL* @@ -457,16 +457,16 @@ _Result Type_ is an `OpTypeInt` of width _rW_ and is the type of _Result_. _Input Type_ is an `OpTypeInt` of width _W_ and is the type of _Input_. -_S_ is an `OpTypeBool` that indicates if the input and output are signed or unsigned. +_S_ is an integer literal, treated as a boolean, that indicates if the input and output are signed or unsigned. A value of `1` indicates that the two types are signed. -_I_ is an `OpTypeInt` that refers to the location of the fixed-point relative to the MSB. +_I_ is an integer literal that refers to the location of the fixed-point relative to the MSB. -_rI_ is an `OpTypeInt` that refers to the location of the fixed-point relative to the MSB of the result type. +_rI_ is an integer literal that refers to the location of the fixed-point relative to the MSB of the result type. -_Q_ is an `OpTypeInt` chosen from _Table 3.16b_ that indicates the Quantization Mode of this operation. +_Q_ is an integer literal chosen from _Table 3.16b_ that indicates the Quantization Mode of this operation. -_O_ is an `OpTypeInt` chosen from _Table 3.16c_ that indicates the Overflow Mode of this operation. +_O_ is an integer literal chosen from _Table 3.16c_ that indicates the Overflow Mode of this operation. | Capability: *ArbitraryPrecisionFixedPointINTEL* From 0af7d0bcf017aa5a09878855549d484eea5c4505 Mon Sep 17 00:00:00 2001 From: Ajaykumar Kannan Date: Mon, 20 Jul 2020 10:39:01 -0400 Subject: [PATCH 10/19] Removed input types from the fixed point SPIR-V functions to keep it consistent with the floating point types --- ...L_arbitrary_precision_fixed_point.asciidoc | 88 +++++++------------ 1 file changed, 33 insertions(+), 55 deletions(-) diff --git a/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_fixed_point.asciidoc b/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_fixed_point.asciidoc index 64cef4c69447a..da12a0987330f 100644 --- a/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_fixed_point.asciidoc +++ b/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_fixed_point.asciidoc @@ -172,17 +172,15 @@ Note that this fixed-point type does not hold information about the sign in the In Section 3.32.13, *Arithmetic Instructions*, add the following instructions: -[cols="11", width="100%"] +[cols="10", width="100%"] |===== -10+<|*OpFixedSqrtINTEL* + +9+<|*OpFixedSqrtINTEL* + An `OpTypeInt` representing an arbitrary precision fixed point number (ac_fixed) is passed in as the _Input_ and the square root of the value is returned in _Result_. The behavior of this function is undefined for input values < 0. _Result Type_ is an `OpTypeInt` of width _rW_ and is the type of _Result_. -_Input Type_ is an `OpTypeInt` of width _W_ and is the type of _Input_. - _S_ is an integer literal, treated as a boolean, that indicates if the input and output are signed or unsigned. A value of `1` indicates that the two types are signed. @@ -197,19 +195,17 @@ _O_ is an integer literal chosen from _Table 3.16c_ that indicates the Overflow | Capability: *ArbitraryPrecisionFixedPointINTEL* -| 10 | 5923 | Result Type | Result | Input Type | Input | _Literal_ S | _Literal_ I | _Literal_ rI | _Literal_ Q | _Literal_ O +| 9 | 5923 | Result Type | Result | Input | _Literal_ S | _Literal_ I | _Literal_ rI | _Literal_ Q | _Literal_ O |===== -[cols="11", width="100%"] +[cols="10", width="100%"] |===== -10+<|*OpFixedRecipINTEL* + +9+<|*OpFixedRecipINTEL* + An `OpTypeInt` representing an arbitrary precision fixed point number (ac_fixed) is passed in as the _Input_ and the reciprocal (`1/Input`) of the value is returned in _Result_. _Result Type_ is an `OpTypeInt` of width _rW_ and is the type of _Result_. -_Input Type_ is an `OpTypeInt` of width _W_ and is the type of _Input_. - _S_ is an integer literal, treated as a boolean, that indicates if the input and output are signed or unsigned. A value of `1` indicates that the two types are signed. @@ -224,20 +220,18 @@ _O_ is an integer literal chosen from _Table 3.16c_ that indicates the Overflow | Capability: *ArbitraryPrecisionFixedPointINTEL* -| 10 | 5924 | Result Type | Result | Input Type | Input | _Literal_ S | _Literal_ I | _Literal_ rI | _Literal_ Q | _Literal_ O +| 9 | 5924 | Result Type | Result | Input | _Literal_ S | _Literal_ I | _Literal_ rI | _Literal_ Q | _Literal_ O |===== -[cols="11", width="100%"] +[cols="10", width="100%"] |===== -10+<|*OpFixedRsqrtINTEL* + +9+<|*OpFixedRsqrtINTEL* + An `OpTypeInt` representing an arbitrary precision fixed point number (ac_fixed) is passed in as the _Input_ and the reciprocal square root (`1/sqrt(Input)`) of the value is returned in _Result_. The behavior of this function is undefined for input values < 0. _Result Type_ is an `OpTypeInt` of width _rW_ and is the type of _Result_. -_Input Type_ is an `OpTypeInt` of width _W_ and is the type of _Input_. - _S_ is an integer literal, treated as a boolean, that indicates if the input and output are signed or unsigned. A value of `1` indicates that the two types are signed. @@ -252,17 +246,15 @@ _O_ is an integer literal chosen from _Table 3.16c_ that indicates the Overflow | Capability: *ArbitraryPrecisionFixedPointINTEL* -| 10 | 5925 | Result Type | Result | Input Type | Input | _Literal_ S | _Literal_ I | _Literal_ rI | _Literal_ Q | _Literal_ O +| 9 | 5925 | Result Type | Result | Input | _Literal_ S | _Literal_ I | _Literal_ rI | _Literal_ Q | _Literal_ O |===== -[cols="11", width="100%"] +[cols="10", width="100%"] |===== -10+<|*OpFixedSinINTEL* + +9+<|*OpFixedSinINTEL* + An `OpTypeInt` representing an arbitrary precision fixed point number (ac_fixed) is passed in as the _Input_ and the sine of the value is returned in _Result_. -_Input Type_ is an `OpTypeInt` of width _W_ and is the type of _Input_. - _Result Type_ is an `OpTypeInt` of width _rW_ and is the type of _Result_. _S_ is an integer literal, treated as a boolean, that indicates if the input and output are signed or unsigned. @@ -279,19 +271,17 @@ _O_ is an integer literal chosen from _Table 3.16c_ that indicates the Overflow | Capability: *ArbitraryPrecisionFixedPointINTEL* -| 10 | 5926 | Result Type | Result | Input Type| Input | _Literal_ S | _Literal_ I | _Literal_ rI | _Literal_ Q | _Literal_ O +| 9 | 5926 | Result Type | Result | Input | _Literal_ S | _Literal_ I | _Literal_ rI | _Literal_ Q | _Literal_ O |===== -[cols="11", width="100%"] +[cols="10", width="100%"] |===== -10+<|*OpFixedCosINTEL* + +9+<|*OpFixedCosINTEL* + An `OpTypeInt` representing an arbitrary precision fixed point number (ac_fixed) is passed in as the _Input_ and the cosine of the value is returned in _Result_. _Result Type_ is an `OpTypeInt` of width _rW_ and is the type of _Result_. -_Input Type_ is an `OpTypeInt` of width _W_ and is the type of _Input_. - _S_ is an integer literal, treated as a boolean, that indicates if the input and output are signed or unsigned. A value of `1` indicates that the two types are signed. @@ -306,17 +296,15 @@ _O_ is an integer literal chosen from _Table 3.16c_ that indicates the Overflow | Capability: *ArbitraryPrecisionFixedPointINTEL* -| 10 | 5927 | Result Type | Result | Input Type| Input | _Literal_ S | _Literal_ I | _Literal_ rI | _Literal_ Q | _Literal_ O +| 9 | 5927 | Result Type | Result | Input | _Literal_ S | _Literal_ I | _Literal_ rI | _Literal_ Q | _Literal_ O |===== -[cols="11", width="100%"] +[cols="10", width="100%"] |===== -10+<|*OpFixedSinCosINTEL* + +9+<|*OpFixedSinCosINTEL* + An `OpTypeInt` representing an arbitrary precision fixed point number (ac_fixed) is passed in as the _Input_ and both the sine and cosine of the value are returned in _Result_. -_Input Type_ is an `OpTypeInt` of width _W_ and is the type of _Input_. - _Result Type_ is an `OpTypeInt` of `2 * rW` and is the type of _Result_. The lower significant bits (`rW`) of the _Result_ are used to hold the cosine value, and the more significant bits (`rW`) are used to hold the sine value. @@ -334,19 +322,17 @@ _O_ is an integer literal chosen from _Table 3.16c_ that indicates the Overflow | Capability: *ArbitraryPrecisionFixedPointINTEL* -| 10 | 5928 | Result Type | Result | Input Type| Input | _Literal_ S | _Literal_ I | _Literal_ rI | _Literal_ Q | _Literal_ O +| 9 | 5928 | Result Type | Result | Input | _Literal_ S | _Literal_ I | _Literal_ rI | _Literal_ Q | _Literal_ O |===== -[cols="11", width="100%"] +[cols="10", width="100%"] |===== -10+<|*OpFixedSinPiINTEL* + +9+<|*OpFixedSinPiINTEL* + An `OpTypeInt` representing an arbitrary precision fixed point number (ac_fixed) is passed in as the _Input_ and the sine of pi * value is returned in _Result_. _Result Type_ is an `OpTypeInt` of width _rW_ and is the type of _Result_. -_Input Type_ is an `OpTypeInt` of width _W_ and is the type of _Input_. - _S_ is an integer literal, treated as a boolean, that indicates if the input and output are signed or unsigned. A value of `1` indicates that the two types are signed. @@ -361,19 +347,17 @@ _O_ is an integer literal chosen from _Table 3.16c_ that indicates the Overflow | Capability: *ArbitraryPrecisionFixedPointINTEL* -| 10 | 5929 | Result Type | Result | Input Type| Input | _Literal_ S | _Literal_ I | _Literal_ rI | _Literal_ Q | _Literal_ O +| 9 | 5929 | Result Type | Result | Input | _Literal_ S | _Literal_ I | _Literal_ rI | _Literal_ Q | _Literal_ O |===== -[cols="11", width="100%"] +[cols="10", width="100%"] |===== -10+<|*OpFixedCosPiINTEL* + +9+<|*OpFixedCosPiINTEL* + An `OpTypeInt` representing an arbitrary precision fixed point number (ac_fixed) is passed in as the _Input_ and the cosine of pi * value is returned in _Result_. _Result Type_ is an `OpTypeInt` of width _rW_ and is the type of _Result_. -_Input Type_ is an `OpTypeInt` of width _W_ and is the type of _Input_. - _S_ is an integer literal, treated as a boolean, that indicates if the input and output are signed or unsigned. A value of `1` indicates that the two types are signed. @@ -388,18 +372,16 @@ _O_ is an integer literal chosen from _Table 3.16c_ that indicates the Overflow | Capability: *ArbitraryPrecisionFixedPointINTEL* -| 10 | 5930 | Result Type | Result | Input Type| Input | _Literal_ S | _Literal_ I | _Literal_ rI | _Literal_ Q | _Literal_ O +| 9 | 5930 | Result Type | Result | Input | _Literal_ S | _Literal_ I | _Literal_ rI | _Literal_ Q | _Literal_ O |===== -[cols="11", width="100%"] +[cols="10", width="100%"] |===== -10+<|*OpFixedSinCosPiINTEL* + +9+<|*OpFixedSinCosPiINTEL* + An `OpTypeInt` representing an arbitrary precision fixed point number (ac_fixed) is passed in as the _Input_ and both the sine and cosine of pi * value are returned in _Result_. -_Input Type_ is an `OpTypeInt` of width _W_ and is the type of _Input_. - _Result Type_ is an `OpTypeInt` of twice the width of `rW` and is the type of _Result_. The lower significant bits (`rW`) of the _Result_ are used to hold the cosine value, and the more significant bits (`rW`) are used to hold the sine value. @@ -417,19 +399,17 @@ _O_ is an integer literal chosen from _Table 3.16c_ that indicates the Overflow | Capability: *ArbitraryPrecisionFixedPointINTEL* -| 10 | 5931 | Result Type | Input Type | Result | Input | _Literal_ S | _Literal_ I | _Literal_ rI | _Literal_ Q | _Literal_ O +| 9 | 5931 | Result Type | Result | Input | _Literal_ S | _Literal_ I | _Literal_ rI | _Literal_ Q | _Literal_ O |===== -[cols="11", width="100%"] +[cols="10", width="100%"] |===== -10+<|*OpFixedLogINTEL* + +9+<|*OpFixedLogINTEL* + An `OpTypeInt` representing an arbitrary precision fixed point number (ac_fixed) is passed in as the _Input_ and the log of the value is returned in _Result_. _Result Type_ is an `OpTypeInt` of width _rW_ and is the type of _Result_. -_Input Type_ is an `OpTypeInt` of width _W_ and is the type of _Input_. - _S_ is an integer literal, treated as a boolean, that indicates if the input and output are signed or unsigned. A value of `1` indicates that the two types are signed. @@ -444,19 +424,17 @@ _O_ is an integer literal chosen from _Table 3.16c_ that indicates the Overflow | Capability: *ArbitraryPrecisionFixedPointINTEL* -| 10 | 5932 | Result Type | Result | Input Type| Input | _Literal_ S | _Literal_ I | _Literal_ rI | _Literal_ Q | _Literal_ O +| 9 | 5932 | Result Type | Result | Input | _Literal_ S | _Literal_ I | _Literal_ rI | _Literal_ Q | _Literal_ O |===== -[cols="11", width="100%"] +[cols="10", width="100%"] |===== -10+<|*OpFixedExpINTEL* + +9+<|*OpFixedExpINTEL* + An `OpTypeInt` representing an arbitrary precision fixed point number (ac_fixed) is passed in as the _Input_ and the exp of the value is returned in _Result_. _Result Type_ is an `OpTypeInt` of width _rW_ and is the type of _Result_. -_Input Type_ is an `OpTypeInt` of width _W_ and is the type of _Input_. - _S_ is an integer literal, treated as a boolean, that indicates if the input and output are signed or unsigned. A value of `1` indicates that the two types are signed. @@ -471,7 +449,7 @@ _O_ is an integer literal chosen from _Table 3.16c_ that indicates the Overflow | Capability: *ArbitraryPrecisionFixedPointINTEL* -| 10 | 5933 | Result Type | Result | Input Type| Input | _Literal_ S | _Literal_ I | _Literal_ rI | _Literal_ Q | _Literal_ O +| 9 | 5933 | Result Type | Result | Input | _Literal_ S | _Literal_ I | _Literal_ rI | _Literal_ Q | _Literal_ O |===== === Validation Rules From 11297782556ac84839775ea6a17aad29590d7068 Mon Sep 17 00:00:00 2001 From: Ajaykumar Kannan Date: Tue, 11 Aug 2020 23:06:45 -0400 Subject: [PATCH 11/19] Update sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_floating_point.asciidoc Co-authored-by: Alexey Sachkov --- .../SPIRV/SPV_INTEL_arbitrary_precision_floating_point.asciidoc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_floating_point.asciidoc b/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_floating_point.asciidoc index 50eedac59e6ba..9ef7a800bf886 100755 --- a/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_floating_point.asciidoc +++ b/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_floating_point.asciidoc @@ -321,7 +321,7 @@ Two `OpTypeInts` representing two arbitrary precision floating point numbers (ih The two numbers are compared and a value of `true` is returned in _Result_ if `A > B`. Otherwise, a value of `false` is returned. -_Result Type_ must be a Boolean. +_Result Type_ must be a Boolean type. _M* contains the width of the mantissa of the floating point types within _A_ and _B_. Note that the exponent values (E1, E2) are inferred from the width of the `OpTypeInt`. From b60cace0ae2a98dae0e11dfe4297bfb0d744f051 Mon Sep 17 00:00:00 2001 From: Ajaykumar Kannan Date: Mon, 9 Nov 2020 12:58:55 -0500 Subject: [PATCH 12/19] Update sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_floating_point.asciidoc Co-authored-by: Dmitry --- .../SPIRV/SPV_INTEL_arbitrary_precision_floating_point.asciidoc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_floating_point.asciidoc b/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_floating_point.asciidoc index 9ef7a800bf886..af5cd391670b8 100755 --- a/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_floating_point.asciidoc +++ b/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_floating_point.asciidoc @@ -982,7 +982,7 @@ _RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen [cols="12", width="100%"] |===== -11+<|*OpArbitraryFloatTan2INTEL* + +11+<|*OpArbitraryFloatATan2INTEL* + Two `OpTypeInts` representing two arbitrary precision floating point numbers (ihc_float) are passed in as _A_ and _B_. The `arctan2(A,B) = arctan(A/B)` is returned as _Result_. From 2fd4805cd79275fbb72fc517eac1abeaf6da2500 Mon Sep 17 00:00:00 2001 From: Ajaykumar Kannan Date: Mon, 9 Nov 2020 13:07:06 -0500 Subject: [PATCH 13/19] Fix FloatExpm1: should be exponent minus 1 --- .../SPIRV/SPV_INTEL_arbitrary_precision_floating_point.asciidoc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_floating_point.asciidoc b/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_floating_point.asciidoc index af5cd391670b8..bf5c57edc7220 100755 --- a/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_floating_point.asciidoc +++ b/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_floating_point.asciidoc @@ -681,7 +681,7 @@ _RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen [cols="10", width="100%"] |===== -9+<|*OpArbitraryFloatExp1mINTEL* + +9+<|*OpArbitraryFloatExpm1INTEL* + An `OpTypeInt` representing an arbitrary precision floating point number (ihc_float) is passed in as _A_. The `(e^A)-1` of _A_ is returned as _Result_. From e557fd8a834723d7386a0ec6f8f8fb98a944623a Mon Sep 17 00:00:00 2001 From: Abhishek Tiwari Date: Thu, 11 Feb 2021 14:51:23 -0800 Subject: [PATCH 14/19] add sign info to cast functions Signed-off-by: Abhishek Tiwari --- ...L_arbitrary_precision_floating_point.asciidoc | 16 ++++++++++------ 1 file changed, 10 insertions(+), 6 deletions(-) diff --git a/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_floating_point.asciidoc b/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_floating_point.asciidoc index bf5c57edc7220..0800c33c881ed 100755 --- a/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_floating_point.asciidoc +++ b/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_floating_point.asciidoc @@ -223,7 +223,7 @@ Allows the use of various operations for arbitrary precision floating-point math === Instructions -In Section 3.32.13, *Arithmetic Instructions*, add the following instructions: +In Section 3.37.13, *Arithmetic Instructions*, add the following instructions: [cols="12", width="100%"] |===== @@ -1099,14 +1099,16 @@ _RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen |===== 8+<|*OpArbitraryFloatCastFromIntINTEL* + -An `OpTypeInt` representing an arbitrary precision integer is passed in as _A_. -It is type casted into an arbitrary precision floating point number with the new specification (Eout, Mout) and returned as _Result_. +An `OpTypeInt` representing an arbitrary precision integer of signedness `FromSign` is passed in as _A_. +It is type casted into an arbitrary precision floating point number with the new specification (Eout, Mout) and sign `FromSign`. The result of the cast operation is returned as _Result_. _Result Type_ is an `OpTypeInt` of width `1+Eout+Mout` and is the type of _Result_. _Eout_ and _Mout_ contain the width of the exponent and the mantissa of the floating point type of _Result_. Note that the exponent value (Eout) is inferred from the width of the `OpTypeInt`. +`FromSign` is used to set the sign of _Result_. + _EnableSubnormals_ specifies whether subnormal numbers should be supported or flushed to zero before and after the operation and is chosen from _Table 3.16a_. _RoundingMode_ controls the rounding mode for the result and is chosen from _Table 3.16_. @@ -1115,7 +1117,7 @@ _RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen | Capability: *ArbitraryPrecisionFloatingPointINTEL* -| 8 | 5842 | Result Type | Result | A | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +| 8 | 5842 | Result Type | Result | A | _Literal_ Mout | _Literal_ FromSign | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy |===== [cols="9", width="100%"] @@ -1123,13 +1125,15 @@ _RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen 8+<|*OpArbitraryFloatCastToIntINTEL* + An `OpTypeInt` representing an arbitrary precision floating point number (ihc_float) is passed in as _A_. -It is type casted into an arbitrary precision integer with width `W` and returned as _Result_. +It is type casted into an arbitrary precision integer with width `W`, sign `ToSign` and returned as _Result_. _Result Type_ is an `OpTypeInt` of width `W` and is the type of _Result_. _E1_ and _M1_ contain the width of the exponent and the mantissa of the floating point type of _A_. Note that the exponent value (E1) is inferred from the width of the `OpTypeInt`. +`ToSign` is used to set the sign of _Result_. + _EnableSubnormals_ specifies whether subnormal numbers should be supported or flushed to zero before and after the operation and is chosen from _Table 3.16a_. _RoundingMode_ controls the rounding mode for the result and is chosen from _Table 3.16_. @@ -1138,7 +1142,7 @@ _RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen | Capability: *ArbitraryPrecisionFloatingPointINTEL* -| 8 | 5843 | Result Type | Result | A | _Literal_ M1 | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +| 8 | 5843 | Result Type | Result | A | _Literal_ M1 | _Literal_ ToSign | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy |===== === Validation Rules From 75ab1062f9664dfe6b676a2a6aa0bd328c9fbdf9 Mon Sep 17 00:00:00 2001 From: "Kannan, Ajaykumar" Date: Wed, 19 May 2021 02:14:32 -0400 Subject: [PATCH 15/19] Fixed the number of columns in the floating point doc --- ...INTEL_arbitrary_precision_floating_point.asciidoc | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_floating_point.asciidoc b/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_floating_point.asciidoc index 0800c33c881ed..b43d004503bbd 100755 --- a/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_floating_point.asciidoc +++ b/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_floating_point.asciidoc @@ -1095,9 +1095,9 @@ _RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen | 9 | 5841 | Result Type | Result | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy |===== -[cols="9", width="100%"] +[cols="10", width="100%"] |===== -8+<|*OpArbitraryFloatCastFromIntINTEL* + +9+<|*OpArbitraryFloatCastFromIntINTEL* + An `OpTypeInt` representing an arbitrary precision integer of signedness `FromSign` is passed in as _A_. It is type casted into an arbitrary precision floating point number with the new specification (Eout, Mout) and sign `FromSign`. The result of the cast operation is returned as _Result_. @@ -1117,12 +1117,12 @@ _RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen | Capability: *ArbitraryPrecisionFloatingPointINTEL* -| 8 | 5842 | Result Type | Result | A | _Literal_ Mout | _Literal_ FromSign | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +| 9 | 5842 | Result Type | Result | A | _Literal_ Mout | _Literal_ FromSign | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy |===== -[cols="9", width="100%"] +[cols="10", width="100%"] |===== -8+<|*OpArbitraryFloatCastToIntINTEL* + +9+<|*OpArbitraryFloatCastToIntINTEL* + An `OpTypeInt` representing an arbitrary precision floating point number (ihc_float) is passed in as _A_. It is type casted into an arbitrary precision integer with width `W`, sign `ToSign` and returned as _Result_. @@ -1142,7 +1142,7 @@ _RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen | Capability: *ArbitraryPrecisionFloatingPointINTEL* -| 8 | 5843 | Result Type | Result | A | _Literal_ M1 | _Literal_ ToSign | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +| 9 | 5843 | Result Type | Result | A | _Literal_ M1 | _Literal_ ToSign | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy |===== === Validation Rules From 4f33a3ce417245a66733e88452b3da41ba3a77a5 Mon Sep 17 00:00:00 2001 From: Ajaykumar Kannan Date: Wed, 19 May 2021 02:20:13 -0400 Subject: [PATCH 16/19] Update sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_floating_point.asciidoc Co-authored-by: Alexey Sachkov --- .../SPIRV/SPV_INTEL_arbitrary_precision_floating_point.asciidoc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_floating_point.asciidoc b/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_floating_point.asciidoc index b43d004503bbd..dd045e3a304b2 100755 --- a/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_floating_point.asciidoc +++ b/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_floating_point.asciidoc @@ -234,7 +234,7 @@ Two `OpTypeInts` representing two arbitrary precision floating point numbers (ih _Result Type_ is an `OpTypeInt` of width `1+Eout+Mout` and is the type of _Result_. _M*_ contains the width of the mantissa of the floating point types within _Result_, _A_, and _B_. -Note that the exponent values (E1, E2, Eout) are inferred from the width of the `OpTypeInt`. +Note that the exponent values (E1, E2, Eout) are inferred from the width of the `OpTypeInt` used to represent corresponding arguments (_A_, _B_, _Result_) _EnableSubnormals_ specifies whether subnormal numbers should be supported or flushed to zero before and after the operation and is chosen from _Table 3.16a_. From 72d9680799657ebfb9d7bf00ce4819834811bbed Mon Sep 17 00:00:00 2001 From: "Kannan, Ajaykumar" Date: Wed, 19 May 2021 02:33:19 -0400 Subject: [PATCH 17/19] Re-phrased what values indicate signedness in fixed_point --- ...L_arbitrary_precision_fixed_point.asciidoc | 22 +++++++++---------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_fixed_point.asciidoc b/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_fixed_point.asciidoc index da12a0987330f..57daac20e54d2 100644 --- a/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_fixed_point.asciidoc +++ b/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_fixed_point.asciidoc @@ -182,7 +182,7 @@ The behavior of this function is undefined for input values < 0. _Result Type_ is an `OpTypeInt` of width _rW_ and is the type of _Result_. _S_ is an integer literal, treated as a boolean, that indicates if the input and output are signed or unsigned. -A value of `1` indicates that the two types are signed. +A non-zero value indicates that the two types are signed. _I_ is an integer literal that refers to the location of the fixed-point relative to the MSB of the input. @@ -207,7 +207,7 @@ An `OpTypeInt` representing an arbitrary precision fixed point number (ac_fixed) _Result Type_ is an `OpTypeInt` of width _rW_ and is the type of _Result_. _S_ is an integer literal, treated as a boolean, that indicates if the input and output are signed or unsigned. -A value of `1` indicates that the two types are signed. +A non-zero value indicates that the two types are signed. _I_ is an integer literal that refers to the location of the fixed-point relative to the MSB of the input. @@ -233,7 +233,7 @@ The behavior of this function is undefined for input values < 0. _Result Type_ is an `OpTypeInt` of width _rW_ and is the type of _Result_. _S_ is an integer literal, treated as a boolean, that indicates if the input and output are signed or unsigned. -A value of `1` indicates that the two types are signed. +A non-zero value indicates that the two types are signed. _I_ is an integer literal that refers to the location of the fixed-point relative to the MSB of the input. @@ -258,7 +258,7 @@ An `OpTypeInt` representing an arbitrary precision fixed point number (ac_fixed) _Result Type_ is an `OpTypeInt` of width _rW_ and is the type of _Result_. _S_ is an integer literal, treated as a boolean, that indicates if the input and output are signed or unsigned. -A value of `1` indicates that the two types are signed. +A non-zero value indicates that the two types are signed. _I_ is an integer literal that refers to the location of the fixed-point relative to the MSB of the input type. @@ -283,7 +283,7 @@ An `OpTypeInt` representing an arbitrary precision fixed point number (ac_fixed) _Result Type_ is an `OpTypeInt` of width _rW_ and is the type of _Result_. _S_ is an integer literal, treated as a boolean, that indicates if the input and output are signed or unsigned. -A value of `1` indicates that the two types are signed. +A non-zero value indicates that the two types are signed. _I_ is an integer literal that refers to the location of the fixed-point relative to the MSB. @@ -309,7 +309,7 @@ _Result Type_ is an `OpTypeInt` of `2 * rW` and is the type of _Result_. The lower significant bits (`rW`) of the _Result_ are used to hold the cosine value, and the more significant bits (`rW`) are used to hold the sine value. _S_ is an integer literal, treated as a boolean, that indicates if the input and output are signed or unsigned. -A value of `1` indicates that the two types are signed. +A non-zero value indicates that the two types are signed. _I_ is an integer literal that refers to the location of the fixed-point relative to the MSB. @@ -334,7 +334,7 @@ An `OpTypeInt` representing an arbitrary precision fixed point number (ac_fixed) _Result Type_ is an `OpTypeInt` of width _rW_ and is the type of _Result_. _S_ is an integer literal, treated as a boolean, that indicates if the input and output are signed or unsigned. -A value of `1` indicates that the two types are signed. +A non-zero value indicates that the two types are signed. _I_ is an integer literal that refers to the location of the fixed-point relative to the MSB. @@ -359,7 +359,7 @@ An `OpTypeInt` representing an arbitrary precision fixed point number (ac_fixed) _Result Type_ is an `OpTypeInt` of width _rW_ and is the type of _Result_. _S_ is an integer literal, treated as a boolean, that indicates if the input and output are signed or unsigned. -A value of `1` indicates that the two types are signed. +A non-zero value indicates that the two types are signed. _I_ is an integer literal that refers to the location of the fixed-point relative to the MSB. @@ -386,7 +386,7 @@ _Result Type_ is an `OpTypeInt` of twice the width of `rW` and is the type of _R The lower significant bits (`rW`) of the _Result_ are used to hold the cosine value, and the more significant bits (`rW`) are used to hold the sine value. _S_ is an integer literal, treated as a boolean, that indicates if the input and output are signed or unsigned. -A value of `1` indicates that the two types are signed. +A non-zero value indicates that the two types are signed. _I_ is an integer literal that refers to the location of the fixed-point relative to the MSB. @@ -411,7 +411,7 @@ An `OpTypeInt` representing an arbitrary precision fixed point number (ac_fixed) _Result Type_ is an `OpTypeInt` of width _rW_ and is the type of _Result_. _S_ is an integer literal, treated as a boolean, that indicates if the input and output are signed or unsigned. -A value of `1` indicates that the two types are signed. +A non-zero value indicates that the two types are signed. _I_ is an integer literal that refers to the location of the fixed-point relative to the MSB. @@ -436,7 +436,7 @@ An `OpTypeInt` representing an arbitrary precision fixed point number (ac_fixed) _Result Type_ is an `OpTypeInt` of width _rW_ and is the type of _Result_. _S_ is an integer literal, treated as a boolean, that indicates if the input and output are signed or unsigned. -A value of `1` indicates that the two types are signed. +A non-zero value indicates that the two types are signed. _I_ is an integer literal that refers to the location of the fixed-point relative to the MSB. From f61dbcc4ac9bd607ba1f865f827d462658cde900 Mon Sep 17 00:00:00 2001 From: "Kannan, Ajaykumar" Date: Wed, 19 May 2021 02:44:40 -0400 Subject: [PATCH 18/19] Added validation rules for floating_point --- .../SPV_INTEL_arbitrary_precision_floating_point.asciidoc | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_floating_point.asciidoc b/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_floating_point.asciidoc index dd045e3a304b2..1e177d5b57b24 100755 --- a/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_floating_point.asciidoc +++ b/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_floating_point.asciidoc @@ -1147,7 +1147,8 @@ _RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen === Validation Rules -None. +* `M*`` literal arguments can't contains values that exceed width of OpTypeInt of corresponding argument minus 1 +* `M*`` literal should contain value more than zero == Issues From 3155570719f642eada299ac758212766fb48c8e0 Mon Sep 17 00:00:00 2001 From: Mikhail Lychkov Date: Fri, 17 Dec 2021 14:39:17 +0300 Subject: [PATCH 19/19] Add argument SignOfB to OpArbitraryFloatPowNINTEL --- ...INTEL_arbitrary_precision_floating_point.asciidoc | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-) diff --git a/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_floating_point.asciidoc b/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_floating_point.asciidoc index 1e177d5b57b24..f7684debaceea 100755 --- a/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_floating_point.asciidoc +++ b/sycl/doc/extensions/SPIRV/SPV_INTEL_arbitrary_precision_floating_point.asciidoc @@ -1049,18 +1049,20 @@ _RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen | 11 | 5881 | Result Type | Result | A | _Literal_ M1 | B | _Literal_ M2 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy |===== -[cols="11", width="100%"] +[cols="12", width="100%"] |===== -10+<|*OpArbitraryFloatPowNINTEL* + +11+<|*OpArbitraryFloatPowNINTEL* + -Two `OpTypeInts` representing arbitrary precision floating point number (ihc_float) and arbitrary precision integer number are passed in as _A_ and _B_ respectively. -The value of `A^B` is returned in _Result_ where `B` is an integer of arbitrary size. +Two `OpTypeInts` representing arbitrary precision floating point number (ihc_float) and arbitrary precision integer number of signedness _SignOfB_ are passed in as _A_ and _B_ respectively. +The value of `A^B` is returned in _Result_ where `B` is a signed or unsigned integer of arbitrary size. _Result Type_ is an `OpTypeInt` of width `1+Eout+Mout` and is the type of _Result_. _M* contains the width of the mantissa of the floating point types within _Result_ and _A_. Note that the exponent values (E1, Eout) are inferred from the width of the `OpTypeInt`. +_SignOfB_ specifies whether _B_ is signed or unsigned. + _EnableSubnormals_ specifies whether subnormal numbers should be supported or flushed to zero before and after the operation and is chosen from _Table 3.16a_. _RoundingMode_ controls the rounding mode for the result and is chosen from _Table 3.16_. @@ -1069,7 +1071,7 @@ _RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen | Capability: *ArbitraryPrecisionFloatingPointINTEL* -| 10 | 5882 | Result Type | Result | A | _Literal_ M1 | B | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +| 11 | 5882 | Result Type | Result | A | _Literal_ M1 | B | _Literal_ SignOfB | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy |===== [cols="10", width="100%"]