diff --git a/sycl/doc/design/spirv-extensions/SPV_INTEL_arbitrary_precision_fixed_point.asciidoc b/sycl/doc/design/spirv-extensions/SPV_INTEL_arbitrary_precision_fixed_point.asciidoc new file mode 100644 index 0000000000000..57daac20e54d2 --- /dev/null +++ b/sycl/doc/design/spirv-extensions/SPV_INTEL_arbitrary_precision_fixed_point.asciidoc @@ -0,0 +1,470 @@ += 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. + + +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 + +In Section 3.32.13, *Arithmetic Instructions*, add the following instructions: + +[cols="10", width="100%"] +|===== +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_. + +_S_ is an integer literal, treated as a boolean, that indicates if the input and output are signed or unsigned. +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. + +_rI_ is an integer literal that refers to the location of the fixed-point relative to the MSB of the result. + +_Q_ is an integer literal chosen from _Table 3.16b_ that indicates the Quantization Mode of this operation. + +_O_ is an integer literal chosen from _Table 3.16c_ that indicates the Overflow Mode of this operation. + +| Capability: +*ArbitraryPrecisionFixedPointINTEL* + +| 9 | 5923 | Result Type | Result | Input | _Literal_ S | _Literal_ I | _Literal_ rI | _Literal_ Q | _Literal_ O +|===== + +[cols="10", width="100%"] +|===== +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_. + +_S_ is an integer literal, treated as a boolean, that indicates if the input and output are signed or unsigned. +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. + +_rI_ is an integer literal that refers to the location of the fixed-point relative to the MSB of the result. + +_Q_ is an integer literal chosen from _Table 3.16b_ that indicates the Quantization Mode of this operation. + +_O_ is an integer literal chosen from _Table 3.16c_ that indicates the Overflow Mode of this operation. + +| Capability: +*ArbitraryPrecisionFixedPointINTEL* + +| 9 | 5924 | Result Type | Result | Input | _Literal_ S | _Literal_ I | _Literal_ rI | _Literal_ Q | _Literal_ O +|===== + +[cols="10", width="100%"] +|===== +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_. + +_S_ is an integer literal, treated as a boolean, that indicates if the input and output are signed or unsigned. +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. + +_rI_ is an integer literal that refers to the location of the fixed-point relative to the MSB of the result. + +_Q_ is an integer literal chosen from _Table 3.16b_ that indicates the Quantization Mode of this operation. + +_O_ is an integer literal chosen from _Table 3.16c_ that indicates the Overflow Mode of this operation. + +| Capability: +*ArbitraryPrecisionFixedPointINTEL* + +| 9 | 5925 | Result Type | Result | Input | _Literal_ S | _Literal_ I | _Literal_ rI | _Literal_ Q | _Literal_ O +|===== + +[cols="10", width="100%"] +|===== +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_. + +_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 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. + +_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 integer literal chosen from _Table 3.16b_ that indicates the Quantization Mode of this operation. + +_O_ is an integer literal chosen from _Table 3.16c_ that indicates the Overflow Mode of this operation. + +| Capability: +*ArbitraryPrecisionFixedPointINTEL* + +| 9 | 5926 | Result Type | Result | Input | _Literal_ S | _Literal_ I | _Literal_ rI | _Literal_ Q | _Literal_ O +|===== + +[cols="10", width="100%"] +|===== +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_. + +_S_ is an integer literal, treated as a boolean, that indicates if the input and output are signed or unsigned. +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. + +_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 integer literal chosen from _Table 3.16b_ that indicates the Quantization Mode of this operation. + +_O_ is an integer literal chosen from _Table 3.16c_ that indicates the Overflow Mode of this operation. + +| Capability: +*ArbitraryPrecisionFixedPointINTEL* + +| 9 | 5927 | Result Type | Result | Input | _Literal_ S | _Literal_ I | _Literal_ rI | _Literal_ Q | _Literal_ O +|===== + +[cols="10", width="100%"] +|===== +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_. + +_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 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. + +_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 integer literal chosen from _Table 3.16b_ that indicates the Quantization Mode of this operation. + +_O_ is an integer literal chosen from _Table 3.16c_ that indicates the Overflow Mode of this operation. + +| Capability: +*ArbitraryPrecisionFixedPointINTEL* + +| 9 | 5928 | Result Type | Result | Input | _Literal_ S | _Literal_ I | _Literal_ rI | _Literal_ Q | _Literal_ O +|===== + +[cols="10", width="100%"] +|===== +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_. + +_S_ is an integer literal, treated as a boolean, that indicates if the input and output are signed or unsigned. +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. + +_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 integer literal chosen from _Table 3.16b_ that indicates the Quantization Mode of this operation. + +_O_ is an integer literal chosen from _Table 3.16c_ that indicates the Overflow Mode of this operation. + +| Capability: +*ArbitraryPrecisionFixedPointINTEL* + +| 9 | 5929 | Result Type | Result | Input | _Literal_ S | _Literal_ I | _Literal_ rI | _Literal_ Q | _Literal_ O +|===== + +[cols="10", width="100%"] +|===== +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_. + +_S_ is an integer literal, treated as a boolean, that indicates if the input and output are signed or unsigned. +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. + +_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 integer literal chosen from _Table 3.16b_ that indicates the Quantization Mode of this operation. + +_O_ is an integer literal chosen from _Table 3.16c_ that indicates the Overflow Mode of this operation. + +| Capability: +*ArbitraryPrecisionFixedPointINTEL* + +| 9 | 5930 | Result Type | Result | Input | _Literal_ S | _Literal_ I | _Literal_ rI | _Literal_ Q | _Literal_ O +|===== + + +[cols="10", width="100%"] +|===== +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_. + +_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 integer literal, treated as a boolean, that indicates if the input and output are signed or unsigned. +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. + +_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 integer literal chosen from _Table 3.16b_ that indicates the Quantization Mode of this operation. + +_O_ is an integer literal chosen from _Table 3.16c_ that indicates the Overflow Mode of this operation. + +| Capability: +*ArbitraryPrecisionFixedPointINTEL* + +| 9 | 5931 | Result Type | Result | Input | _Literal_ S | _Literal_ I | _Literal_ rI | _Literal_ Q | _Literal_ O +|===== + +[cols="10", width="100%"] +|===== +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_. + +_S_ is an integer literal, treated as a boolean, that indicates if the input and output are signed or unsigned. +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. + +_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 integer literal chosen from _Table 3.16b_ that indicates the Quantization Mode of this operation. + +_O_ is an integer literal chosen from _Table 3.16c_ that indicates the Overflow Mode of this operation. + +| Capability: +*ArbitraryPrecisionFixedPointINTEL* + +| 9 | 5932 | Result Type | Result | Input | _Literal_ S | _Literal_ I | _Literal_ rI | _Literal_ Q | _Literal_ O +|===== + +[cols="10", width="100%"] +|===== +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_. + +_S_ is an integer literal, treated as a boolean, that indicates if the input and output are signed or unsigned. +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. + +_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 integer literal chosen from _Table 3.16b_ that indicates the Quantization Mode of this operation. + +_O_ is an integer literal chosen from _Table 3.16c_ that indicates the Overflow Mode of this operation. + +| Capability: +*ArbitraryPrecisionFixedPointINTEL* + +| 9 | 5933 | Result Type | Result | 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/design/spirv-extensions/SPV_INTEL_arbitrary_precision_floating_point.asciidoc b/sycl/doc/design/spirv-extensions/SPV_INTEL_arbitrary_precision_floating_point.asciidoc new file mode 100755 index 0000000000000..f7684debaceea --- /dev/null +++ b/sycl/doc/design/spirv-extensions/SPV_INTEL_arbitrary_precision_floating_point.asciidoc @@ -0,0 +1,1167 @@ += 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. +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) ]` + +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*, *Kernel* | +|==== + +=== Instructions + +In Section 3.37.13, *Arithmetic Instructions*, add the following instructions: + +[cols="12", width="100%"] +|===== +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_. + +_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` 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_. + +_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* +| 11 | 5846 | Result Type | Result | A | _Literal_ M1 | B | _Literal_ M2 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +|===== + +[cols="12", width="100%"] +|===== +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_. + +_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_. + +_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* +| 11 | 5847 | Result Type | Result | A | _Literal_ M1 | B | _Literal_ M2 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +|===== + +[cols="12", width="100%"] +|===== +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_. + +_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_. + +_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* +| 11 | 5848 | Result Type | Result | A | _Literal_ M1 | B | _Literal_ M2 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +|===== + +[cols="12", width="100%"] +|===== +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_. + +_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_. + +_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* +| 11 | 5849 | Result Type | Result | A | _Literal_ M1 | B | _Literal_ M2 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +|===== + +[cols="8", width="100%"] +|===== +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. + +_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* +| 7 | 5850 | Result Type | Result | A | _Literal_ M1 | B | _Literal_ M2 +|===== + +[cols="8", width="100%"] +|===== +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. + +_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* +| 7 | 5851 | Result Type | Result | A | _Literal_ M1 | B | _Literal_ M2 +|===== + +[cols="8", width="100%"] +|===== +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. + +_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* +| 7 | 5852 | Result Type | Result | A | _Literal_ M1 | B | _Literal_ M2 +|===== + +[cols="8", width="100%"] +|===== +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. + +_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* +| 7 | 5853 | Result Type | Result | A | _Literal_ M1 | B | _Literal_ M2 +|===== + +[cols="8", width="100%"] +|===== +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. + +_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* +| 7 | 5854 | Result Type | Result | A | _Literal_ M1 | B | _Literal_ M2 +|===== + +[cols="10", width="100%"] +|===== +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_. + +_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_. + +_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 | 5855 | Result Type | Result | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +|===== + +[cols="10", width="100%"] +|===== +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_. + +_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_. + +_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 | 5856 | Result Type | Result | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +|===== + +[cols="10", width="100%"] +|===== +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_. + +_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_. + +_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 | 5857 | Result Type | Result | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +|===== + +[cols="12", width="100%"] +|===== +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_. + +_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_. + +_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* +| 11 | 5858 | Result Type | Result | A | _Literal_ M1 | B | _Literal_ M2 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +|===== + +[cols="10", width="100%"] +|===== +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_. + +_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_. + +_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 | 5859 | Result Type | Result | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +|===== + +[cols="10", width="100%"] +|===== +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_. + +_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_. + +_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 | 5860 | Result Type | Result | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +|===== + +[cols="10", width="100%"] +|===== +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_. + +_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_. + +_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 | 5861 | Result Type | Result | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +|===== + +[cols="10", width="100%"] +|===== +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_. + +_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_. + +_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 | 5862 | Result Type | Result | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +|===== + +[cols="10", width="100%"] +|===== +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_. + +_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_. + +_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 | 5863 | Result Type | Result | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +|===== + +[cols="10", width="100%"] +|===== +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_. + +_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_. + +_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 | 5864 | Result Type | Result | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +|===== + +[cols="10", width="100%"] +|===== +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_. + +_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_. + +_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 | 5865 | Result Type | Result | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +|===== + +[cols="10", width="100%"] +|===== +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_. + +_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_. + +_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 | 5866 | Result Type | Result | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +|===== + +[cols="10", width="100%"] +|===== +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_. + +_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`. + +_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 | 5867 | Result Type | Result | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +|===== + +[cols="10", width="100%"] +|===== +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_. + +_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_. + +_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 | 5868 | Result Type | Result | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +|===== + +[cols="10", width="100%"] +|===== +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_. + +_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_. + +_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 | 5869 | Result Type | Result | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +|===== + +[cols="10", width="100%"] +|===== +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_. + +_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. + +_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_. + +_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 | 5870 | Result Type | Result | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +|===== + +[cols="10", width="100%"] +|===== +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_. + +_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_. + +_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 | 5871 | Result Type | Result | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +|===== + +[cols="10", width="100%"] +|===== +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_. + +_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_. + +_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 | 5872 | Result Type | Result | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +|===== + +[cols="10", width="100%"] +|===== +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_. + +_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. + +_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_. + +_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 | 5840 | Result Type | Result | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +|===== + +[cols="10", width="100%"] +|===== +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_. + +_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_. + +_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 | 5873 | Result Type | Result | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +|===== + +[cols="10", width="100%"] +|===== +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_. + +_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_. + +_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 | 5874 | Result Type | Result | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +|===== + +[cols="10", width="100%"] +|===== +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_. + +_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_. + +_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 | 5875 | Result Type | Result | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +|===== + +[cols="10", width="100%"] +|===== +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_. + +_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_. + +_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 | 5876 | Result Type | Result | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +|===== + +[cols="10", width="100%"] +|===== +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_. + +_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_. + +_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 | 5877 | Result Type | Result | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +|===== + +[cols="10", width="100%"] +|===== +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_. + +_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_. + +_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 | 5878 | Result Type | Result | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +|===== + +[cols="12", width="100%"] +|===== +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_. + +_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`. + +_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* +| 11 | 5879 | Result Type | Result | A | _Literal_ M1 | B | _Literal_ M2 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +|===== + +[cols="12", width="100%"] +|===== +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_. + +_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_. + +_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* +| 11 | 5880 | Result Type | Result | A | _Literal_ M1 | B | _Literal_ M2 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +|===== + +[cols="12", width="100%"] +|===== +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_. + +_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_. + +_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* +| 11 | 5881 | Result Type | Result | A | _Literal_ M1 | B | _Literal_ M2 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +|===== + +[cols="12", width="100%"] +|===== +11+<|*OpArbitraryFloatPowNINTEL* + + +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_. + +_RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen from _Table 3.16d_. + +| Capability: +*ArbitraryPrecisionFloatingPointINTEL* +| 11 | 5882 | Result Type | Result | A | _Literal_ M1 | B | _Literal_ SignOfB | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +|===== + +[cols="10", width="100%"] +|===== +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_. + +_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_. + +_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 | 5841 | Result Type | Result | A | _Literal_ M1 | _Literal_ Mout | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +|===== + +[cols="10", width="100%"] +|===== +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_. + +_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_. + +_RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen from _Table 3.16d_. + +| Capability: +*ArbitraryPrecisionFloatingPointINTEL* +| 9 | 5842 | Result Type | Result | A | _Literal_ Mout | _Literal_ FromSign | _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`, 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_. + +_RoundingAccuracy_ controls the accuracy of the rounding operation and is chosen from _Table 3.16d_. + +| Capability: +*ArbitraryPrecisionFloatingPointINTEL* +| 9 | 5843 | Result Type | Result | A | _Literal_ M1 | _Literal_ ToSign | _Literal_ EnableSubnormals | _Literal_ RoundingMode | _Literal_ RoundingAccuracy +|===== + +=== Validation Rules + +* `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 + +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-07-19 |Ajaykumar Kannan |Initial Public Release +|===================================================================