Oracle Developer Studio compilers provide intrinsic types and functions to support special features that SPARC64X, SPARC64X+, and SPARC64 XII have, namely, SIMD data and Decimal Floating-Point numbers.
You must specify both -xarch=[sparcace|sparcaceplus|sparcace2] and -m64 options to compile source files which use these intrinsics.
The SIMD data provided by SPARC64X, SPARC64X+, and SPARC64 XII can hold a pair of double or unsigned long long values. The compiler has a few intrinsic types and functions to handle these data.
Prototypes declared in the sparcace_types.h header file support the following two SIMD data types that SPARC64X, SPARC64X+, and SPARC64 XII provide:
a pair of double-precision floating-point numbers
a pair of signed/unsigned 64-bit integers
SIMD data type
is handled as a basic type, not aggregate; it has no internal structures. You need to use a intrinsic function to get a part of the data.
can be modified with type modifiers: const and/or volatile.
can be specified with storage class specifiers: auto, static, register, extern and/or typedef.
can be elements of an aggregate: array, struct and/or union.
SIMD data type variables can be any of the following:
a formal parameter of a function
an actual argument of a function call
the return value of a function
lhs or rhs of assignment operator "="
the operand of address operator "&"
the operand of sizeof operator
the operand of typeof operator
Literal syntax is not supported for SIMD data types; you can build a SIMD data type constant with a proper intrinsic function.
Up to the first 8 SIMD arguments are passed via floating-point registers. The first halves of SIMD arguments occupy %d0, %d4, %d8, ..., %d28. The second halves of SIMD arguments occupy %d256, %d260, %d264, ..., %d284. If there are nine or more SIMD arguments, they are passed via the stack area.
The first half of a SIMD return value appears in %d0. The second half appears in %d256.
A SIMD type value should be stored at a 16 byte-aligned address in order to be loaded/stored with SIMD load(ldd,s)/store(std,s).
The list below describes the intrinsic functions declared in sparcace_types.h header file. Each intrinsic functions is followed by parentheses, which is not part of prototype, indicates on which CPU the intrinsic function is first available.
All intrinsic functions are forward-compatible to newer CPU. For example, an intrinsic function indicating sparc64x intrinsic is also available on sparc64xplus and sparc64xii.
This function returns an __m128i type value which has exactly the same bit pattern of the parameter.
This function returns an __m128d type value which has exactly the same bit pattern of the parameter.
This function extracts a double-precision floating-point number from the __m128d type data passed as the first parameter. The value extracted is controlled by the second parameter. The second parameter must be an integer and must be a constant of 0 or 1.
This function extracts an unsigned long long type number from the __m128i type data passed as the first parameter. The value extracted is controlled by the second parameter. The second parameter must be an integer and must be a constant of 0 or 1.
This function produces an __m128d result which has the absolute value of the parameter.
This function executes addition to produce an __m128d result.
This function performs bitwise AND operation between the first parameter and the second parameter to produce an __m128d result.
This function performs bitwise AND operation between the first parameter and the second parameter to produce an __m128i result.
This function performs bitwise AND operation between the first parameter inverted and the second parameter to produce an __m128d result.
This function performs bitwise AND operation between the first parameter inverted and the second parameter to produce an __m128i result.
This function performs bitwise AND operation between the first parameter and the bitwise inversion of the second parameter to produce an __m128d result.
This function performs bitwise AND operation between the first parameter and the bitwise inversion of the second parameter to produce an __m128i result.
This function compares each double-precision floating-point number of the first parameter to the corresponding double-precision floating-point number of the second parameter. All the bits of the corresponding double-precision floating-point number of the __m128d result are set to 1 if the first one is equal to the second one.
This function compares each double-precision floating-point number of the first parameter to the corresponding double-precision floating-point number of the second parameter. All the bits of the corresponding double-precision floating-point number of the __m128d result are set to 1 if the first one is equal to the second one. An Exception will be raised if unordered.
This function compares each double-precision floating-point number of the first parameter to the corresponding double-precision floating-point number of the second parameter. All the bits of the corresponding double-precision floating-point number of the __m128d result are set to 1 if the first one is greater than or equal to the second one. An Exception will be raised if unordered.
This function compares each double-precision floating-point number of the first parameter to the corresponding double-precision floating-point number of the second parameter. All the bits of the corresponding double-precision floating-point number of the __m128d result are set to 1 if the first one is greater than the second one. An Exception will be raised if unordered.
This function compares each double-precision floating-point number of the first parameter to the corresponding double-precision floating-point number of the second parameter. All the bits of the corresponding double-precision floating-point number of the __m128d result are set to 1 if the first one is less than or equal to the second one. An Exception will be raised if unordered.
This function compares each double-precision floating-point number of the first parameter to the corresponding double-precision floating-point number of the second parameter. All the bits of the corresponding double-precision floating-point number of the __m128d result are set to 1 if the first one is less than the second one. An Exception will be raised if unordered.
This function compares each double-precision floating-point number of the first parameter to the corresponding double-precision floating-point number of the second parameter. All the bits of the corresponding double-precision floating-point number of the __m128d result are set to 1 if the first one is not equal to the second one.
This function compares each double-precision floating-point number of the first parameter to the corresponding double-precision floating-point number of the second parameter. All the bits of the corresponding double-precision floating-point number of the __m128d result are set to 1 if the first one is not equal to the second one. An Exception will be raised if unordered.
This function executes two double-precision divisions serially and produce an __m128d result of the first parameter divided by the second.
This function converts each of a pair of double-precision floating-point numbers to signed long long integers to produce an __m128i result.
The first and second parameters contain a pair of packs and each of them contains, in turn, two 32-bit integers. This function look up each of four 32-bit integers in the second parameter, then if the MSB of the 32-bit integer is 1, puts 0x0000000 to the corresponding 32-bit integer of the return value. If the MSB is 0, then look up the two LSB of the 32-bit integer and select one of the four 32-bit integer of the first parameter and put it to the return value.
The first and second parameters contain a pair of 64-bit integers. This function look up each of two 64-bit integers in the second parameter, then if the MSB of the 64-bit integer is 1, puts 0x00000000000000 to the corresponding 64-bit integer of the return value. if the MSB is 0, then look up the LSB of the 64-bit integer and select one of the two 64-bit integer of the first parameter and put it to the return value.
This function first builds an __m128d value by copying the double-precision floating-point number the first parameter holds, then executes (a * b + c) operation with the pairs of D-P F-P numbers in the first, second and third parameters to produce an __m128d result.
This function first builds an __m128d value by copying the double-precision floating-point number the first parameter holds, then swaps a pair of D-P F-P numbers the second parameter holds, finally executes (a * b + c) operation with the pairs of D-P F-P numbers in the first, second and third parameters to produce an __m128d result.
This function executes (a * b + c) operation with the pairs of double-precision floating-point numbers in the first, second and third parameters to produce an __m128d result.
This function first builds an __m128d value by copying the double-precision floating-point number the first parameter holds, then executes operations with the pairs of D-P F-P numbers in the first, second and third parameters to produce an __m128d result. The operations are (a * b + c) for basic side and (-(a * b) + c) for extend side.
This function first builds an __m128d value by copying the double-precision floating-point number the first parameter holds, then swaps a pair of D-P F-P numbers the second parameter holds, finally executes operations with the pairs of D-P F-P numbers in the first, second and third parameters to produce an __m128d result. The operations are (a * b + c) for basic side and (-(a * b) + c) for extend side.
This function executes operations with the pairs of double-precision floating-point numbers in the first, second and third parameters to produce an __m128d result. The operations are (a * b + c) for basic side and (-(a * b) + c) for extend side.
This function first swaps pairs of double-precision floating-point numbers the first and second parameters hold, then executes operations with the pairs of D-P F-P numbers in the first, second and third parameters to produce an __m128d result. The operations are (a * b + c) for basic side and (-(a * b) + c) for extend side.
This function first swaps a pair of double-precision floating-point numbers the first parameter holds, then executes operations with the pairs of D-P F-P numbers in the first, second and third parameters to produce an __m128d result. The operations are (a * b + c) for basic side and (-(a * b) + c) for extend side.
This function first swaps a pair of double-precision floating-point numbers the second parameter holds, then executes operations with the pairs of D-P F-P numbers in the first, second and third parameters to produce an __m128d result. The operations are (a * b + c) for basic side and (-(a * b) + c) for extend side.
This function first swaps pairs of double-precision floating-point numbers the first and second parameters hold, then executes (a * b + c) operation with the pairs of D-P F-P numbers in the first, second and third parameters to produce an __m128d result.
This function first swaps a pair of double-precision floating-point numbers the first parameter holds, then executes (a * b + c) operation with the pairs of D-P F-P numbers in the first, second and third parameters to produce an __m128d result.
This function first swaps a pair of double-precision floating-point numbers the second parameter holds, then executes (a * b + c) operation with the pairs of D-P F-P numbers in the first, second and third parameters to produce an __m128d result.
This function produces an __m128d result by copying the maximum values of each double-precision floating-point number of the first parameter or the ones of the second parameter.
This function produces an __m128d result by copying the minimum values of each double-precision floating-point number of the first parameter or the ones of the second parameter.
This function first builds an __m128d value by copying the double-precision floating-point number the first parameter holds, then executes (a * b - c) operation with the pairs of D-P F-P numbers in the first, second and third parameters to produce an __m128d result.
This function first builds an __m128d value by copying the double-precision floating-point number the first parameter holds, then swaps a pair of D-P F-P numbers the second parameter holds, finally executes (a * b - c) operation with the pairs of D-P F-P numbers in the first, second and third parameters to produce an __m128d result.
This function executes (a * b - c) with the pairs of double-precision floating-point numbers in the first, second and third parameters to produce an __m128d result.
This function first builds an __m128d value by copying the double-precision floating-point number the first parameter holds, then executes operations with the pairs of D-P F-P numbers in the first, second and third parameters to produce an __m128d result. The operations are (a * b - c) for basic side and (-(a * b) - c) for extend side.
This function first builds an __m128d value by copying the double-precision floating-point number the first parameter holds, then swaps a pair of D-P F-P numbers the second parameter holds, finally executes operations with the pairs of D-P F-P numbers in the first, second and third parameters to produce an __m128d result. The operations are (a * b - c) for basic side and (-(a * b) - c) for extend side.
This function executes operations with the pairs of double-precision floating-point numbers in the first, second and third parameters to produce an __m128d result. The operations are (a * b - c) for basic side and (-(a * b) - c) for extend side.
This function first swaps pairs of double-precision floating-point numbers the first and second parameters hold, then executes operations with the pairs of D-P F-P numbers in the first, second and third parameters to produce an __m128d result. The operations are (a * b - c) for basic side and (-(a * b) - c) for extend side.
This function first swaps a pair of double-precision floating-point numbers the first parameter holds, then executes operations with the pairs of D-P F-P numbers in the first, second and third parameters to produce an __m128d result. The operations are (a * b - c) for basic side and (-(a * b) - c) for extend side.
This function first swaps a pair of double-precision floating-point numbers the second parameter holds, then executes operations with the pairs of D-P F-P numbers in the first, second and third parameters to produce an __m128d result. The operations are (a * b - c) for basic side and (-(a * b) - c) for extend side.
This function first swaps pairs of double-precision floating-point numbers the first and second parameters hold, then executes (a * b - c) operation with the pairs of D-P F-P numbers in the first, second and third parameters to produce an __m128d result.
This function first swaps a pair of double-precision floating-point numbers the first parameter holds, then executes (a * b - c) operation with the pairs of D-P F-P numbers in the first, second and third parameters to produce an __m128d result.
This function first swaps a pair of double-precision floating-point numbers the second parameter holds, then executes (a * b - c) operation with the pairs of D-P F-P numbers in the first, second and third parameters to produce an __m128d result.
This function executes multiplication to produce an __m128d result.
This function executes -(a - b) operation with the pairs of double-precision floating-point numbers in the first and second parameters to produce an __m128d result.
This function performs bitwise NAND operation between the first parameter and the second parameter to produce an __m128d result.
This function performs bitwise NAND operation between the first parameter and the second parameter to produce an __m128i result.
This function negates the value of the parameter.
This function first builds an __m128d value by copying the double-precision floating-point number the first parameter holds, then executes -(a * b + c) operation with the pairs of D-P F-P numbers in the first, second and third parameters to produce an __m128d result.
This function first builds an __m128d value by copying the double-precision floating-point number the first parameter holds, then swaps a pair of D-P F-P numbers the second parameter holds, finally executes -(a * b + c) operation with the pairs of D-P F-P numbers in the first, second and third parameters to produce an __m128d result.
This function executes -(a * b + c) with the pairs of double-precision floating-point numbers in the first, second and third parameters to produce an __m128d result.
This function first builds an __m128d value by copying the double-precision floating-point number the first parameter holds, then executes operations with the pairs of D-P F-P numbers in the first, second and third parameters to produce an __m128d result. The operations are -(a * b + c) for basic side and -(-(a * b) + c) for extend side.
This function first builds an __m128d value by copying the double-precision floating-point number the first parameter holds, then swaps a pair of D-P F-P numbers the second parameter holds, finally executes operations with the pairs of D-P F-P numbers in the first, second and third parameters to produce an __m128d result. The operations are -(a * b + c) for basic side and -(-(a * b) + c) for extend side.
This function executes operations with the pairs of double-precision floating-point numbers in the first, second and third parameters to produce an __m128d result. The operations are -(a * b + c) for basic side and -(-(a * b) + c) for extend side.
This function first swaps pairs of double-precision floating-point numbers the first and second parameters hold, then executes operations with the pairs of D-P F-P numbers in the first, second and third parameters to produce an __m128d result. The operations are -(a * b + c) for basic side and -(-(a * b) + c) for extend side.
This function first swaps a pair of double-precision floating-point numbers the first parameter holds, then executes operations with the pairs of D-P F-P numbers in the first, second and third parameters to produce an __m128d result. The operations are -(a * b + c) for basic side and -(-(a * b) + c) for extend side.
This function first swaps a pair of double-precision floating-point numbers the second parameter holds, then executes operations with the pairs of D-P F-P numbers in the first, second and third parameters to produce an __m128d result. The operations are -(a * b + c) for basic side and -(-(a * b) + c) for extend side.
This function first swaps pairs of double-precision floating-point numbers the first and second parameters hold, then executes -(a * b + c) operation with the pairs of D-P F-P numbers in the first, second and third parameters to produce an __m128d result.
This function first swaps a pair of double-precision floating-point numbers the first parameter holds, then executes -(a * b + c) operation with the pairs of D-P F-P numbers in the first, second and third parameters to produce an __m128d result.
This function first swaps a pair of double-precision floating-point numbers the second parameter holds, then executes -(a * b + c) operation with the pairs of D-P F-P numbers in the first, second and third parameters to produce an __m128d result.
This function first builds an __m128d value by copying the double-precision floating-point number the first parameter holds, then executes -(a * b - c) operation with the pairs of D-P F-P numbers in the first, second and third parameters to produce an __m128d result.
This function first builds an __m128d value by copying the double-precision floating-point number the first parameter holds, then swaps a pair of D-P F-P numbers the second parameter holds, finally executes -(a * b - c) operation with the pairs of D-P F-P numbers in the first, second and third parameters to produce an __m128d result.
This function executes -(a * b - c) with the pairs of double-precision floating-point numbers in the first, second and third parameters to produce an __m128d result.
This function first builds an __m128d value by copying the double-precision floating-point number the first parameter holds, then executes operations with the pairs of D-P F-P numbers in the first, second and third parameters to produce an __m128d result. The operations are -(a * b - c) for basic side and -(-(a * b) - c) for extend side.
This function first builds an __m128d value by copying the double-precision floating-point number the first parameter holds, then swaps a pair of D-P F-P numbers the second parameter holds, finally executes operations with the pairs of D-P F-P numbers in the first, second and third parameters to produce an __m128d result. The operations are -(a * b - c) for basic side and -(-(a * b) - c) for extend side.
This function executes operations with the pairs of double-precision floating-point numbers in the first, second and third parameters to produce an __m128d result. The operations are -(a * b - c) for basic side and -(-(a * b) - c) for extend side.
This function first swaps pairs of double-precision floating-point numbers the first and second parameters hold, then executes operations with the pairs of D-P F-P numbers in the first, second and third parameters to produce an __m128d result. The operations are -(a * b - c) for basic side and -(-(a * b) - c) for extend side.
This function first swaps a pair of double-precision floating-point numbers the first parameter holds, then executes operations with the pairs of D-P F-P numbers in the first, second and third parameters to produce an __m128d result. The operations are -(a * b - c) for basic side and -(-(a * b) - c) for extend side.
This function first swaps a pair of double-precision floating-point numbers the second parameter holds, then executes operations with the pairs of D-P F-P numbers in the first, second and third parameters to produce an __m128d result. The operations are -(a * b - c) for basic side and -(-(a * b) - c) for extend side.
This function first swaps pairs of double-precision floating-point numbers the first and second parameters hold, then executes -(a * b - c) operation with the pairs of D-P F-P numbers in the first, second and third parameters to produce an __m128d result.
This function first swaps a pair of double-precision floating-point numbers the first parameter holds, then executes -(a * b - c) operation with the pairs of D-P F-P numbers in the first, second and third parameters to produce an __m128d result.
This function first swaps a pair of double-precision floating-point numbers the second parameter holds, then executes -(a * b - c) operation with the pairs of D-P F-P numbers in the first, second and third parameters to produce an __m128d result.
This function executes -(a * b) operation with the pairs of double-precision floating-point numbers in the first and second parameters to produce an __m128d result.
This function performs bitwise NOR operation between the first parameter and the second parameter to produce an __m128d result.
This function performs bitwise NOR operation between the first parameter and the second parameter to produce an __m128i result.
This function performs bitwise inversion operation of the first parameter to produce an __m128d result.
This function performs bitwise inversion operation of the first parameter to produce an __m128i result.
This function performs bitwise inversion operation of the first parameter to produce an __m128d result.
This function performs bitwise inversion operation of the first parameter to produce an __m128i result.
This function produces an __m128d result whose bits are all 1.
This function produces an __m128i result whose bits are all 1.
This function performs bitwise OR operation between the first parameter and the second parameter to produce an __m128d result.
This function performs bitwise OR operation between the first parameter and the second parameter to produce an __m128i result.
This function performs bitwise OR operation between the first parameter inverted and the second parameter to produce an __m128d result.
This function performs bitwise OR operation between the first parameter inverted and the second parameter to produce an __m128i result.
This function performs bitwise OR operation between the first parameter and the bitwise inversion of the second parameter to produce an __m128d result.
This function performs bitwise OR operation between the first parameter and the bitwise inversion of the second parameter to produce an __m128i result.
This function adds a pair of 16-byte unsigned integers, whose high-order 8 bytes are given as the first parameter and the low-order 8 bytes are given as the second parameter, with 8-byte unsigned integers given as the third parameter. Only the high-order 8 bytes of the produced pair of 16-byte unsigned integers are returned as an __m128i result.
The first and second parameters contain a pair of packs and each of them contains, in turn, four 16-bit integers. This function adds every 16-bit integer in the packs of the first parameter with the corresponding 16-bit integer in the second parameter, then put the resulting 16-bit integer into the corresponding part of the resulting __m128i value.
The first and second parameters contain a pair of packs and each of them contains, in turn, two 32-bit integers. This function adds every 32-bit integer in the packs of the first parameter with the corresponding 32-bit integer in the second parameter, then put the resulting 32-bit integer into the corresponding part of the resulting __m128i value.
This function produces an __m128i result by adding each unsigned long long type number of the first parameter and the unsigned long long type number of the second parameter.
The first and second parameters contain a pair of packs and each of them contains, in turn, eight 8-bit integers. This function adds every 8-bit integer in the packs of the first parameter with the corresponding 8-bit integer in the second parameter and return the resulting pair of packs.
The first and second parameters contain a pair of packs and each of them contains, in turn, four 16-bit signed integers. This function compares every 16-bit signed integer in the packs of the first parameter with the corresponding 16-bit signed integer in the second parameter, then if the 16-bit signed integer in the first parameter is grater than its counterpart, set 0xFFFF to the corresponding 16-bit integer of the resulting __m128i value, otherwise set 0 to the corresponding 16-bit integer of the resulting __m128i value.
The first and second parameters contain a pair of packs and each of them contains, in turn, four 16-bit signed integers. This function compares every 16-bit signed integer in the packs of the first parameter with the corresponding 16-bit signed integer, then if the 16-bit signed integer in the first parameter is greater than its counterpart, set 1 of the corresponding bit of the resulting __m128i value.
The first and second parameters contain a pair of packs and each of them contains, in turn, four 16-bit signed integers. And the third parameter contains a pair of 64-bit integers. This function first shift-rights the pair of 64-bit integers of the third parameter by 4 bits, then compares every 16-bit signed integer in the packs of the first parameter with the corresponding 16-bit signed integer in the second parameter, then if the 16-bit signed integer in the first parameter is grater than its counterpart, set 1 of the corresponding bit of the most significant 4 bits of the third parameter.
The first and second parameters contain a pair of packs and each of them contains, in turn, two 32-bit signed integers. This function compares every 32-bit signed integer in the packs of the first parameter with the corresponding 32-bit signed integer in the second parameter, then if the 32-bit signed integer in the first parameter is grater than its counterpart, set 0xFFFFFFFF to the corresponding 32-bit integer of the resulting __m128i value, otherwise set 0 to the corresponding 32-bit integer of the resulting __m128i value.
The first and second parameters contain a pair of packs and each of them contains, in turn, two 32-bit signed integers. This function compares every 32-bit signed integer in the packs of the first parameter with the corresponding 32-bit signed integer, then if the 32-bit signed integer in the first parameter is less than or equal to its counterpart, set 1 of the corresponding bit of the resulting __m128i value.
The first and second parameters contain a pair of packs and each of them contains, in turn, two 32-bit signed integers. And the third parameter contains a pair of 64-bit integers. This function first shift-rights the pair of 64-bit integers of the third parameter by 2 bits, then compares every 32-bit signed integer in the packs of the first parameter with the corresponding 32-bit signed integer in the second parameter, then if the 32-bit signed integer in the first parameter is grater than or equal to its counterpart, set 1 of the corresponding bit of the most significant 2 bits of the third parameter.
The first and second parameters contain a pair of packs and each of them contains, in turn, sixteen 4-bit signed integers. This function compares every 4-bit signed integer in the packs of the first parameter with the corresponding 4-bit signed integer in the second parameter, then if the 4-bit signed integer in the first parameter is grater than its counterpart, set 0xF to the corresponding 4-bit integer of the resulting __m128i value, otherwise set 0 to the corresponding 4-bit integer of the resulting __m128i value.
The first and second parameters contain a pair of packs and each of them contains, in turn, sixteen 4-bit signed integers. This function compares every 4-bit signed integer in the packs of the first parameter with the corresponding 4-bit signed integer in the second parameter, then if the 4-bit signed integer in the first parameter is greater than its counterpart, set 1 of the corresponding bit of the resulting __m128i value.
The first and second parameters contain a pair of packs and each of them contains, in turn, sixteen 4-bit signed integers. And the third parameter contains a pair of 64-bit integers. This function first shift-rights the pair of 64-bit integers of the third parameter by 16 bits, then compares every 4-bit signed integer in the packs of the first parameter with the corresponding 4-bit signed integer in the second parameter, then if the 4-bit signed integer in the first parameter is greater than its counterpart, set 1 of the corresponding bit of the most significant 16 bits of the third parameter.
The first and second parameters contain a pair 64-bit signed integers. This function compares each 64-bit signed integer of the first parameter with the corresponding 64-bit signed integer in the second parameter, then if the 64-bit signed integer in the first parameter is grater than its counterpart, set 0xFFFFFFFFFFFFFFFF to the corresponding 64-bit integer of the resulting __m128i value, otherwise set 0 to the corresponding 64-bit integer of the resulting __m128i value.
This function compares each signed long long type number of the first parameter to the corresponding signed long long type number of the second parameter. The MSB of the corresponding signed long long type number of the __m128i result is set to 1 if the first one is greater than the second one. Bit 0 to bit 62 are set to 0.
The first and second parameters contain a pair of 64-bit signed integers. And the third parameter contains a pair of 64-bit integers. This function first shift-rights the pair of 64-bit integers of the third parameter by 1 bit, then compares every 64-bit signed integer of the first parameter with the corresponding 64-bit signed integer in the second parameter, then if the 64-bit signed integer in the first parameter is greater than its counterpart, set 1 of the corresponding bit of the most significant bit of the third parameter.
The first and second parameters contain a pair of packs and each of them contains, in turn, eight 8-bit signed integers. This function compares every 8-bit signed integer in the packs of the first parameter with the corresponding 8-bit signed integer in the second parameter, then if the 8-bit signed integer in the first parameter is grater than its counterpart, set 0xFF to the corresponding 8-bit integer of the resulting __m128i value, otherwise set 0 to the corresponding 8-bit integer of the resulting __m128i value.
The first and second parameters contain a pair of packs and each of them contains, in turn, eight 8-bit signed integers. This function compares every 8-bit signed integer in the packs of the first parameter with the corresponding 8-bit signed integer in the second parameter, then if the 8-bit signed integer in the first parameter is grater than its counterpart, set 0xFF to the corresponding 8-bit integer of the resulting __m128i value, otherwise set 0 to the corresponding 8-bit integer of the resulting __m128i value.
The first and second parameters contain a pair of packs and each of them contains, in turn, eight 8-bit signed integers. And the third parameter contains a pair of 64-bit integers. This function first shift-rights the pair of 64-bit integers of the third parameter by 8 bits, then compares every 8-bit signed integer in the packs of the first parameter with the corresponding 8-bit signed integer in the second parameter, then if the 8-bit signed integer in the first parameter is greater than its counterpart, set 1 of the corresponding bit of the most significant 8 bits of the third parameter.
The first and second parameters contain a pair of packs and each of them contains, in turn, four 16-bit signed integers. This function compares every 16-bit signed integer in the packs of the first parameter with the corresponding 16-bit signed integer in the second parameter, then if the 16-bit signed integer in the first parameter is lesser than or equal to its counterpart, set 0xFFFF to the corresponding 16-bit integer of the resulting __m128i value, otherwise set 0 to the corresponding 16-bit integer of the resulting __m128i value.
The first and second parameters contain a pair of packs and each of them contains, in turn, four 16-bit signed integers. This function compares every 16-bit signed integer in the packs of the first parameter with the corresponding 16-bit signed integer, then if the 16-bit signed integer in the first parameter is less than or equal to its counterpart, set 1 of the corresponding bit of the resulting __m128i value.
The first and second parameters contain a pair of packs and each of them contains, in turn, four 16-bit signed integers. And the third parameter contains a pair of 64-bit integers. This function first shift-rights the pair of 64-bit integers of the third parameter by 4 bits, then compares every 16-bit signed integer in the packs of the first parameter with the corresponding 16-bit signed integer in the second parameter, then if the 16-bit signed integer in the first parameter is lesser than or equal to its counterpart, set 1 of the corresponding bit of the most significant 4 bits of the third parameter.
The first and second parameters contain a pair of packs and each of them contains, in turn, two 32-bit signed integers. This function compares every 32-bit signed integer in the packs of the first parameter with the corresponding 32-bit signed integer in the second parameter, then if the 32-bit signed integer in the first parameter is lesser than or equal to its counterpart, set 0xFFFFFFFF to the corresponding 32-bit integer of the resulting __m128i value, otherwise set 0 to the corresponding 32-bit integer of the resulting __m128i value.
The first and second parameters contain a pair of packs and each of them contains, in turn, two 32-bit signed integers. This function compares every 32-bit signed integer in the packs of the first parameter with the corresponding 32-bit signed integer, then if the 32-bit signed integer in the first parameter is less than or equal to its counterpart, set 1 of the corresponding bit of the resulting __m128i value.
The first and second parameters contain a pair of packs and each of them contains, in turn, two 32-bit signed integers. And the third parameter contains a pair of 64-bit integers. This function first shift-rights the pair of 64-bit integers of the third parameter by 2 bits, then compares every 32-bit signed integer in the packs of the first parameter with the corresponding 32-bit signed integer in the second parameter, then if the 32-bit signed integer in the first parameter is lesser than or equal to its counterpart, set 1 of the corresponding bit of the most significant 2 bits of the third parameter.
The first and second parameters contain a pair of packs and each of them contains, in turn, sixteen 4-bit signed integers. This function compares every 4-bit signed integer in the packs of the first parameter with the corresponding 4-bit signed integer in the second parameter, then if the 4-bit signed integer in the first parameter is lesser than or equal to its counterpart, set 0xF to the corresponding 4-bit integer of the resulting __m128i value, otherwise set 0 to the corresponding 4-bit integer of the resulting __m128i value.
The first and second parameters contain a pair of packs and each of them contains, in turn, sixteen 4-bit signed integers. This function compares every 4-bit signed integer in the packs of the first parameter with the corresponding 4-bit signed integer in the second parameter, then if the 4-bit signed integer in the first parameter is lesser than or equal to its counterpart, set 1 of the corresponding bit of the resulting __m128i value.
The first and second parameters contain a pair of packs and each of them contains, in turn, sixteen 4-bit signed integers. And the third parameter contains a pair of 64-bit integers. This function first shift-rights the pair of 64-bit integers of the third parameter by 16 bits, then compares every 4-bit signed integer in the packs of the first parameter with the corresponding 4-bit signed integer in the second parameter, then if the 4-bit signed integer in the first parameter is lesser than or equal to its counterpart, set 1 of the corresponding bit of the most significant 16 bits of the third parameter.
The first and second parameters contain a pair 64-bit signed integers. This function compares each 64-bit signed integer of the first parameter with the corresponding 64-bit signed integer in the second parameter, then if the 64-bit signed integer in the first parameter is lesser than or equal to its counterpart, set 0xFFFFFFFFFFFFFFFF to the corresponding 64-bit integer of the resulting __m128i value, otherwise set 0 to the corresponding 64-bit integer of the resulting __m128i value.
This function compares each signed long long type number of the first parameter to the corresponding signed long long type number of the second parameter. The MSB of the corresponding signed long long type number of the __m128i result is set to 1 if the first one is less than or equal to the second one. Bit 0 to bit 62 are set to 0.
The first and second parameters contain a pair of 64-bit signed integers. And the third parameter contains a pair of 64-bit integers. This function first shift-rights the pair of 64-bit integers of the third parameter by 1 bit, then compares every 64-bit signed integer of the first parameter with the corresponding 64-bit signed integer in the second parameter, then if the 64-bit signed integer in the first parameter is lesser than or equal to its counterpart, set 1 of the corresponding bit of the most significant bit of the third parameter.
The first and second parameters contain a pair of packs and each of them contains, in turn, eight 8-bit signed integers. This function compares every 8-bit signed integer in the packs of the first parameter with the corresponding 8-bit signed integer in the second parameter, then if the 8-bit signed integer in the first parameter is lesser than or equal to its counterpart, set 0xFF to the corresponding 8-bit integer of the resulting __m128i value, otherwise set 0 to the corresponding 8-bit integer of the resulting __m128i value.
The first and second parameters contain a pair of packs and each of them contains, in turn, eight 8-bit signed integers. This function compares every 8-bit signed integer in the packs of the first parameter with the corresponding 8-bit signed integer in the second parameter, then if the 8-bit signed integer in the first parameter is lesser than or equal to its counterpart, set 0xFF to the corresponding 8-bit integer of the resulting __m128i value, otherwise set 0 to the corresponding 8-bit integer of the resulting __m128i value.
The first and second parameters contain a pair of packs and each of them contains, in turn, eight 8-bit signed integers. And the third parameter contains a pair of 64-bit integers. This function first shift-rights the pair of 64-bit integers of the third parameter by 8 bits, then compares every 8-bit signed integer in the packs of the first parameter with the corresponding 8-bit signed integer in the second parameter, then if the 8-bit signed integer in the first parameter is lesser than or equal to its counterpart, set 1 of the corresponding bit of the most significant 8 bits of the third parameter.
The first and second parameters contain a pair of packs and each of them contains, in turn, four 16-bit unsigned integers. This function compares every 16-bit unsigned integer in the packs of the first parameter with the corresponding 16-bit unsigned integer in the second parameter, then if the 16-bit unsigned integer in the first parameter is equal to its counterpart, set 0xFFFF to the corresponding 16-bit integer of the resulting __m128i value, otherwise set 0 to the corresponding 16-bit integer of the resulting __m128i value.
The first and second parameters contain a pair of packs and each of them contains, in turn, four 16-bit unsigned integers. This function compares every 16-bit unsigned integer in the packs of the first parameter with the corresponding 16-bit unsigned integer, then if the 16-bit unsigned integer in the first parameter is equal to its counterpart, set 1 of the corresponding bit of the resulting __m128i value.
The first and second parameters contain a pair of packs and each of them contains, in turn, four 16-bit unsigned integers. And the third parameter contains a pair of 64-bit integers. This function first shift-rights the pair of 64-bit integers of the third parameter by 4 bits, then compares every 16-bit unsigned integer in the packs of the first parameter with the corresponding 16-bit unsigned integer in the second parameter, then if the 16-bit unsigned integer in the first parameter is equal to its counterpart, set 1 of the corresponding bit of the most significant 4 bits of the third parameter.
The first and second parameters contain a pair of packs and each of them contains, in turn, two 32-bit unsigned integers. This function compares every 32-bit unsigned integer in the packs of the first parameter with the corresponding 32-bit unsigned integer in the second parameter, then if the 32-bit unsigned integer in the first parameter is equal to its counterpart, set 0xFFFFFFFF to the corresponding 32-bit integer of the resulting __m128i value, otherwise set 0 to the corresponding 32-bit integer of the resulting __m128i value.
The first and second parameters contain a pair of packs and each of them contains, in turn, two 32-bit unsigned integers. This function compares every 32-bit unsigned integer in the packs of the first parameter with the corresponding 32-bit unsigned integer, then if the 32-bit unsigned integer in the first parameter is equal to its counterpart, set 1 of the corresponding bit of the resulting __m128i value.
The first and second parameters contain a pair of packs and each of them contains, in turn, two 32-bit unsigned integers. And the third parameter contains a pair of 64-bit integers. This function first shift-rights the pair of 64-bit integers of the third parameter by 2 bits, then compares every 32-bit unsigned integer in the packs of the first parameter with the corresponding 32-bit unsigned integer in the second parameter, then if the 32-bit unsigned integer in the first parameter is equal to its counterpart, set 1 of the corresponding bit of the most significant 2 bits of the third parameter.
The first and second parameters contain a pair of packs and each of them contains, in turn, sixteen 4-bit unsigned integers. This function compares every 4-bit unsigned integer in the packs of the first parameter with the corresponding 4-bit unsigned integer in the second parameter, then if the 4-bit unsigned integer in the first parameter is equal to its counterpart, set 0xF to the corresponding 4-bit integer of the resulting __m128i value, otherwise set 0 to the corresponding 4-bit integer of the resulting __m128i value.
The first and second parameters contain a pair of packs and each of them contains, in turn, sixteen 4-bit unsigned integers. This function compares every 4-bit unsigned integer in the packs of the first parameter with the corresponding 4-bit unsigned integer in the second parameter, then if the 4-bit unsigned integer in the first parameter is equal to its counterpart, set 1 of the corresponding bit of the resulting __m128i value.
The first and second parameters contain a pair of packs and each of them contains, in turn, sixteen 4-bit unsigned integers. And the third parameter contains a pair of 64-bit integers. This function first shift-rights the pair of 64-bit integers of the third parameter by 16 bits, then compares every 4-bit unsigned integer in the packs of the first parameter with the corresponding 4-bit unsigned integer in the second parameter, then if the 4-bit unsigned integer in the first parameter is equal to its counterpart, set 1 of the corresponding bit of the most significant 16 bits of the third parameter.
The first and second parameters contain a pair 64-bit unsigned integers. This function compares each 64-bit unsigned integer of the first parameter with the corresponding 64-bit unsigned integer in the second parameter, then if the 64-bit unsigned integer in the first parameter is equal to its counterpart, set 0xFFFFFFFFFFFFFFFF to the corresponding 64-bit integer of the resulting __m128i value, otherwise set 0 to the corresponding 64-bit integer of the resulting __m128i value.
This function compares each unsigned long long type number of the first parameter to the corresponding unsigned long long type number of the second parameter. The MSB of the corresponding unsigned long long type number of the __m128i result is set to 1 if the first one is equal to the second one. Bit 0 to bit 62 are set to 0.
The first and second parameters contain a pair of 64-bit unsigned integers. And the third parameter contains a pair of 64-bit integers. This function first shift-rights the pair of 64-bit integers of the third parameter by 1 bit, then compares every 64-bit unsigned integer of the first parameter with the corresponding 64-bit unsigned integer in the second parameter, then if the 64-bit unsigned integer in the first parameter is equal to its counterpart, set 1 of the corresponding bit of the most significant bit of the third parameter.
The first and second parameters contain a pair of packs and each of them contains, in turn, eight 8-bit unsigned integers. This function compares every 8-bit unsigned integer in the packs of the first parameter with the corresponding 8-bit unsigned integer in the second parameter, then if the 8-bit unsigned integer in the first parameter is equal to its counterpart, set 0xFF to the corresponding 8-bit integer of the resulting __m128i value, otherwise set 0 to the corresponding 8-bit integer of the resulting __m128i value.
The first and second parameters contain a pair of packs and each of them contains, in turn, eight 8-bit unsigned integers. This function compares every 8-bit unsigned integer in the packs of the first parameter with the corresponding 8-bit unsigned integer, then if the 8-bit unsigned integer in the first parameter is equal to its counterpart, set 1 of the corresponding bit of the resulting __m128i value.
The first and second parameters contain a pair of packs and each of them contains, in turn, eight 8-bit unsigned integers. And the third parameter contains a pair of 64-bit integers. This function first shift-rights the pair of 64-bit integers of the third parameter by 8 bits, then compares every 8-bit unsigned integer in the packs of the first parameter with the corresponding 8-bit unsigned integer in the second parameter, then if the 8-bit unsigned integer in the first parameter is equal to its counterpart, set 1 of the corresponding bit of the most significant 8 bits of the third parameter.
The first and second parameters contain a pair of packs and each of them contains, in turn, four 16-bit unsigned integers. This function compares every 16-bit unsigned integer in the packs of the first parameter with the corresponding 16-bit unsigned integer in the second parameter, then if the 16-bit unsigned integer in the first parameter is grater than its counterpart, set 0xFFFF to the corresponding 16-bit integer of the resulting __m128i value, otherwise set 0 to the corresponding 16-bit integer of the resulting __m128i value.
The first and second parameters contain a pair of packs and each of them contains, in turn, four 16-bit unsigned integers. This function compares every 16-bit unsigned integer in the packs of the first parameter with the corresponding 16-bit unsigned integer, then if the 16-bit unsigned integer in the first parameter is greater than its counterpart, set 1 of the corresponding bit of the resulting __m128i value.
The first and second parameters contain a pair of packs and each of them contains, in turn, four 16-bit unsigned integers. And the third parameter contains a pair of 64-bit integers. This function first shift-rights the pair of 64-bit integers of the third parameter by 4 bits, then compares every 16-bit unsigned integer in the packs of the first parameter with the corresponding 16-bit unsigned integer in the second parameter, then if the 16-bit unsigned integer in the first parameter is grater than its counterpart, set 1 of the corresponding bit of the most significant 4 bits of the third parameter.
The first and second parameters contain a pair of packs and each of them contains, in turn, two 32-bit unsigned integers. This function compares every 32-bit unsigned integer in the packs of the first parameter with the corresponding 32-bit unsigned integer in the second parameter, then if the 32-bit unsigned integer in the first parameter is grater than its counterpart, set 0xFFFFFFFF to the corresponding 32-bit integer of the resulting __m128i value, otherwise set 0 to the corresponding 32-bit integer of the resulting __m128i value.
The first and second parameters contain a pair of packs and each of them contains, in turn, two 32-bit unsigned integers. This function compares every 32-bit unsigned integer in the packs of the first parameter with the corresponding 32-bit unsigned integer, then if the 32-bit unsigned integer in the first parameter is less than or equal to its counterpart, set 1 of the corresponding bit of the resulting __m128i value.
The first and second parameters contain a pair of packs and each of them contains, in turn, two 32-bit unsigned integers. And the third parameter contains a pair of 64-bit integers. This function first shift-rights the pair of 64-bit integers of the third parameter by 2 bits, then compares every 32-bit unsigned integer in the packs of the first parameter with the corresponding 32-bit unsigned integer in the second parameter, then if the 32-bit unsigned integer in the first parameter is grater than or equal to its counterpart, set 1 of the corresponding bit of the most significant 2 bits of the third parameter.
The first and second parameters contain a pair of packs and each of them contains, in turn, sixteen 4-bit unsigned integers. This function compares every 4-bit unsigned integer in the packs of the first parameter with the corresponding 4-bit unsigned integer in the second parameter, then if the 4-bit unsigned integer in the first parameter is grater than its counterpart, set 0xF to the corresponding 4-bit integer of the resulting __m128i value, otherwise set 0 to the corresponding 4-bit integer of the resulting __m128i value.
The first and second parameters contain a pair of packs and each of them contains, in turn, sixteen 4-bit unsigned integers. This function compares every 4-bit unsigned integer in the packs of the first parameter with the corresponding 4-bit unsigned integer in the second parameter, then if the 4-bit unsigned integer in the first parameter is greater than its counterpart, set 1 of the corresponding bit of the resulting __m128i value.
The first and second parameters contain a pair of packs and each of them contains, in turn, sixteen 4-bit unsigned integers. And the third parameter contains a pair of 64-bit integers. This function first shift-rights the pair of 64-bit integers of the third parameter by 16 bits, then compares every 4-bit unsigned integer in the packs of the first parameter with the corresponding 4-bit unsigned integer in the second parameter, then if the 4-bit unsigned integer in the first parameter is greater than its counterpart, set 1 of the corresponding bit of the most significant 16 bits of the third parameter.
The first and second parameters contain a pair 64-bit unsigned integers. This function compares each 64-bit unsigned integer of the first parameter with the corresponding 64-bit unsigned integer in the second parameter, then if the 64-bit unsigned integer in the first parameter is grater than its counterpart, set 0xFFFFFFFFFFFFFFFF to the corresponding 64-bit integer of the resulting __m128i value, otherwise set 0 to the corresponding 64-bit integer of the resulting __m128i value.
This function compares each unsigned long long type number of the first parameter to the corresponding unsigned long long type number of the second parameter. The MSB of the corresponding unsigned long long type number of the __m128i result is set to 1 if the first one is greater than the second one. Bit 0 to bit 62 are set to 0.
The first and second parameters contain a pair of 64-bit unsigned integers. And the third parameter contains a pair of 64-bit integers. This function first shift-rights the pair of 64-bit integers of the third parameter by 1 bit, then compares every 64-bit unsigned integer of the first parameter with the corresponding 64-bit unsigned integer in the second parameter, then if the 64-bit unsigned integer in the first parameter is greater than to its counterpart, set 1 of the corresponding bit of the most significant bit of the third parameter.
The first and second parameters contain a pair of packs and each of them contains, in turn, eight 8-bit unsigned integers. This function compares every 8-bit unsigned integer in the packs of the first parameter with the corresponding 8-bit unsigned integer in the second parameter, then if the 8-bit unsigned integer in the first parameter is grater than its counterpart, set 0xFF to the corresponding 8-bit integer of the resulting __m128i value, otherwise set 0 to the corresponding 8-bit integer of the resulting __m128i value.
The first and second parameters contain a pair of packs and each of them contains, in turn, eight 8-bit unsigned integers. This function compares every 8-bit unsigned integer in the packs of the first parameter with the corresponding 8-bit unsigned integer in the second parameter, then if the 8-bit unsigned integer in the first parameter is grater than its counterpart, set 0xFF to the corresponding 8-bit integer of the resulting __m128i value, otherwise set 0 to the corresponding 8-bit integer of the resulting __m128i value.
The first and second parameters contain a pair of packs and each of them contains, in turn, eight 8-bit unsigned integers. And the third parameter contains a pair of 64-bit integers. This function first shift-rights the pair of 64-bit integers of the third parameter by 8 bits, then compares every 8-bit unsigned integer in the packs of the first parameter with the corresponding 8-bit unsigned integer in the second parameter, then if the 8-bit unsigned integer in the first parameter is greater than its counterpart, set 1 of the corresponding bit of the most significant 8 bits of the third parameter.
The first and second parameters contain a pair of packs and each of them contains, in turn, four 16-bit unsigned integers. This function compares every 16-bit unsigned integer in the packs of the first parameter with the corresponding 16-bit unsigned integer in the second parameter, then if the 16-bit unsigned integer in the first parameter is lesser than or equal to its counterpart, set 0xFFFF to the corresponding 16-bit integer of the resulting __m128i value, otherwise set 0 to the corresponding 16-bit integer of the resulting __m128i value.
The first and second parameters contain a pair of packs and each of them contains, in turn, four 16-bit unsigned integers. This function compares every 16-bit unsigned integer in the packs of the first parameter with the corresponding 16-bit unsigned integer, then if the 16-bit unsigned integer in the first parameter is less than or equal to its counterpart, set 1 of the corresponding bit of the resulting __m128i value.
The first and second parameters contain a pair of packs and each of them contains, in turn, four 16-bit unsigned integers. And the third parameter contains a pair of 64-bit integers. This function first shift-rights the pair of 64-bit integers of the third parameter by 4 bits, then compares every 16-bit unsigned integer in the packs of the first parameter with the corresponding 16-bit unsigned integer in the second parameter, then if the 16-bit unsigned integer in the first parameter is lesser than or equal to its counterpart, set 1 of the corresponding bit of the most significant 4 bits of the third parameter.
The first and second parameters contain a pair of packs and each of them contains, in turn, two 32-bit unsigned integers. This function compares every 32-bit unsigned integer in the packs of the first parameter with the corresponding 32-bit unsigned integer in the second parameter, then if the 32-bit unsigned integer in the first parameter is lesser than or equal to its counterpart, set 0xFFFFFFFF to the corresponding 32-bit integer of the resulting __m128i value, otherwise set 0 to the corresponding 32-bit integer of the resulting __m128i value.
The first and second parameters contain a pair of packs and each of them contains, in turn, two 32-bit unsigned integers. This function compares every 32-bit unsigned integer in the packs of the first parameter with the corresponding 32-bit unsigned integer, then if the 32-bit unsigned integer in the first parameter is less than or equal to its counterpart, set 1 of the corresponding bit of the resulting __m128i value.
The first and second parameters contain a pair of packs and each of them contains, in turn, two 32-bit unsigned integers. And the third parameter contains a pair of 64-bit integers. This function first shift-rights the pair of 64-bit integers of the third parameter by 2 bits, then compares every 32-bit unsigned integer in the packs of the first parameter with the corresponding 32-bit unsigned integer in the second parameter, then if the 32-bit unsigned integer in the first parameter is lesser than or equal to its counterpart, set 1 of the corresponding bit of the most significant 2 bits of the third parameter.
The first and second parameters contain a pair of packs and each of them contains, in turn, sixteen 4-bit unsigned integers. This function compares every 4-bit unsigned integer in the packs of the first parameter with the corresponding 4-bit unsigned integer in the second parameter, then if the 4-bit unsigned integer in the first parameter is lesser than or equal to its counterpart, set 0xF to the corresponding 4-bit integer of the resulting __m128i value, otherwise set 0 to the corresponding 4-bit integer of the resulting __m128i value.
The first and second parameters contain a pair of packs and each of them contains, in turn, sixteen 4-bit unsigned integers. This function compares every 4-bit unsigned integer in the packs of the first parameter with the corresponding 4-bit unsigned integer in the second parameter, then if the 4-bit unsigned integer in the first parameter is lesser than or equal to its counterpart, set 1 of the corresponding bit of the resulting __m128i value.
The first and second parameters contain a pair of packs and each of them contains, in turn, sixteen 4-bit unsigned integers. And the third parameter contains a pair of 64-bit integers. This function first shift-rights the pair of 64-bit integers of the third parameter by 16 bits, then compares every 4-bit unsigned integer in the packs of the first parameter with the corresponding 4-bit unsigned integer in the second parameter, then if the 4-bit unsigned integer in the first parameter is lesser than or equal to its counterpart, set 1 of the corresponding bit of the most significant 16 bits of the third parameter.
The first and second parameters contain a pair 64-bit unsigned integers. This function compares each 64-bit unsigned integer of the first parameter with the corresponding 64-bit unsigned integer in the second parameter, then if the 64-bit unsigned integer in the first parameter is lesser than or equal to its counterpart, set 0xFFFFFFFFFFFFFFFF to the corresponding 64-bit integer of the resulting __m128i value, otherwise set 0 to the corresponding 64-bit integer of the resulting __m128i value.
This function compares each unsigned long long type number of the first parameter to the corresponding unsigned long long type number of the second parameter. The MSB of the corresponding unsigned long long type number of the __m128i result is set to 1 if the first one is less than or equal to the second one. Bit 0 to bit 62 are set to 0.
The first and second parameters contain a pair of 64-bit unsigned integers. And the third parameter contains a pair of 64-bit integers. This function first shift-rights the pair of 64-bit integers of the third parameter by 1 bit, then compares every 64-bit unsigned integer of the first parameter with the corresponding 64-bit unsigned integer in the second parameter, then if the 64-bit unsigned integer in the first parameter is lesser than or equal to its counterpart, set 1 of the corresponding bit of the most significant bit of the third parameter.
The first and second parameters contain a pair of packs and each of them contains, in turn, eight 8-bit unsigned integers. This function compares every 8-bit unsigned integer in the packs of the first parameter with the corresponding 8-bit unsigned integer in the second parameter, then if the 8-bit unsigned integer in the first parameter is lesser than or equal to its counterpart, set 0xFF to the corresponding 8-bit integer of the resulting __m128i value, otherwise set 0 to the corresponding 8-bit integer of the resulting __m128i value.
The first and second parameters contain a pair of packs and each of them contains, in turn, eight 8-bit unsigned integers. This function compares every 8-bit unsigned integer in the packs of the first parameter with the corresponding 8-bit unsigned integer, then if the 8-bit unsigned integer in the first parameter is less than or equal to its counterpart, set 1 of the corresponding bit of the resulting __m128i value.
The first and second parameters contain a pair of packs and each of them contains, in turn, eight 8-bit unsigned integers. And the third parameter contains a pair of 64-bit integers. This function first shift-rights the pair of 64-bit integers of the third parameter by 8 bits, then compares every 8-bit unsigned integer in the packs of the first parameter with the corresponding 8-bit unsigned integer in the second parameter, then if the 8-bit unsigned integer in the first parameter is lesser than or equal to its counterpart, set 1 of the corresponding bit of the most significant 8 bits of the third parameter.
The first and second parameters contain a pair of packs and each of them contains, in turn, four 16-bit unsigned integers. This function compares every 16-bit unsigned integer in the packs of the first parameter with the corresponding 16-bit unsigned integer in the second parameter, then if the 16-bit unsigned integer in the first parameter is not equal to its counterpart, set 0xFFFF to the corresponding 16-bit integer of the resulting __m128i value, otherwise set 0 to the corresponding 16-bit integer of the resulting __m128i value.
The first and second parameters contain a pair of packs and each of them contains, in turn, four 16-bit unsigned integers. This function compares every 16-bit unsigned integer in the packs of the first parameter with the corresponding 16-bit unsigned integer, then if the 16-bit unsigned integer in the first parameter is not equal to its counterpart, set 1 of the corresponding bit of the resulting __m128i value.
The first and second parameters contain a pair of packs and each of them contains, in turn, four 16-bit unsigned integers. And the third parameter contains a pair of 64-bit integers. This function first shift-rights the pair of 64-bit integers of the third parameter by 4 bits, then compares every 16-bit unsigned integer in the packs of the first parameter with the corresponding 16-bit unsigned integer in the second parameter, then if the 16-bit unsigned integer in the first parameter is not equal to its counterpart, set 1 of the corresponding bit of the most significant 4 bits of the third parameter.
The first and second parameters contain a pair of packs and each of them contains, in tern, two 32-bit unsigned integers. This function compares every 32-bit unsigned integer in the packs of the first parameter with the corresponding 32-bit unsigned integer in the second parameter, then if the 32-bit unsigned integer in the first parameter is not equal to its counterpart, set 0xFFFFFFFF to the corresponding 32-bit integer of the resulting __m128i value, otherwise set 0 to the corresponding 32-bit integer of the resulting __m128i value.
The first and second parameters contain a pair of packs and each of them contains, in turn, two 32-bit unsigned integers. This function compares every 32-bit unsigned integer in the packs of the first parameter with the corresponding 32-bit unsigned integer, then if the 32-bit unsigned integer in the first parameter is not equal to its counterpart, set 1 of the corresponding bit of the resulting __m128i value.
The first and second parameters contain a pair of packs and each of them contains, in turn, two 32-bit unsigned integers. And the third parameter contains a pair of 64-bit integers. This function first shift-rights the pair of 64-bit integers of the third parameter by 2 bits, then compares every 32-bit unsigned integer in the packs of the first parameter with the corresponding 32-bit unsigned integer in the second parameter, then if the 32-bit unsigned integer in the first parameter is not equal to its counterpart, set 1 of the corresponding bit of the most significant 2 bits of the third parameter.
The first and second parameters contain a pair of packs and each of them contains, in turn, sixteen 4-bit signed integers. This function compares every 4-bit signed integer in the packs of the first parameter with the corresponding 4-bit signed integer in the second parameter, then if the 4-bit signed integer in the first parameter is not equal to its counterpart, set 0xF to the corresponding 4-bit integer of the resulting __m128i value, otherwise set 0 to the corresponding 4-bit integer of the resulting __m128i value.
The first and second parameters contain a pair of packs and each of them contains, in turn, sixteen 4-bit unsigned integers. This function compares every 4-bit unsigned integer in the packs of the first parameter with the corresponding 4-bit unsigned integer in the second parameter, then if the 4-bit unsigned integer in the first parameter is not equal to its counterpart, set 1 of the corresponding bit of the resulting __m128i value.
The first and second parameters contain a pair of packs and each of them contains, in turn, sixteen 4-bit unsigned integers. And the third parameter contains a pair of 64-bit integers. This function first shift-rights the pair of 64-bit integers of the third parameter by 16 bits, then compares every 4-bit unsigned integer in the packs of the first parameter with the corresponding 4-bit unsigned integer in the second parameter, then if the 4-bit unsigned integer in the first parameter is not equal to its counterpart, set 1 of the corresponding bit of the most significant 16 bits of the third parameter.
The first and second parameters contain a pair 64-bit unsigned integers. This function compares each 64-bit unsigned integer of the first parameter with the corresponding 64-bit unsigned integer in the second parameter, then if the 64-bit unsigned integer in the first parameter is not equal to its counterpart, set 0xFFFFFFFFFFFFFFFF to the corresponding 64-bit integer of the resulting __m128i value, otherwise set 0 to the corresponding 64-bit integer of the resulting __m128i value.
This function compares each unsigned long long type number of the first parameter to the corresponding unsigned long long type number of the second parameter. The MSB of the corresponding unsigned long long type number of the __m128i result is set to 1 if the first one is not equal to the second one. Bit 0 to bit 62 are set to 0.
The first and second parameters contain a pair of 64-bit unsigned integers. And the third parameter contains a pair of 64-bit integers. This function first shift-rights the pair of 64-bit integers of the third parameter by 1 bit, then compares every 64-bit unsigned integer of the first parameter with the corresponding 64-bit unsigned integer in the second parameter, then if the 64-bit unsigned integer in the first parameter is not equal to its counterpart, set 1 of the corresponding bit of the most significant bit of the third parameter.
The first and second parameters contain a pair of packs and each of them contains, in turn, eight 8-bit unsigned integers. This function compares every 8-bit unsigned integer in the packs of the first parameter with the corresponding 8-bit unsigned integer in the second parameter, then if the 8-bit unsigned integer in the first parameter is not equal to its counterpart, set 0xFF to the corresponding 8-bit integer of the resulting __m128i value, otherwise set 0 to the corresponding 8-bit integer of the resulting __m128i value.
The first and second parameters contain a pair of packs and each of them contains, in turn, eight 8-bit unsigned integers. This function compares every 8-bit unsigned integer in the packs of the first parameter with the corresponding 8-bit unsigned integer, then if the 8-bit unsigned integer in the first parameter is not equal to its counterpart, set 1 of the corresponding bit of the resulting __m128i value.
The first and second parameters contain a pair of packs and each of them contains, in turn, eight 8-bit unsigned integers. And the third parameter contains a pair of 64-bit integers. This function first shift-rights the pair of 64-bit integers of the third parameter by 8 bits, then compares every 8-bit unsigned integer in the packs of the first parameter with the corresponding 8-bit unsigned integer in the second parameter, then if the 8-bit unsigned integer in the first parameter is not equal to its counterpart, set 1 of the corresponding bit of the most significant 8 bits of the third parameter.
This function concatenates each of two 64-bit integer in the third parameter with the corresponding 64-bit integer of the first parameter and shift-lefts the concatenated 128-bit value by the value the corresponding 64-bit integer of the second parameter multiplied by eight. Then put the most significant 64 bits of the 128-bit value to the result value.
This function executes (a * b + c) operation with the pairs of unsigned long long numbers in first, second and third parameters, takes the lower 8 bytes of the result pair to produce an __m128d result.
This function executes (a * b + c) operation with the pairs of unsigned long long numbers in first, second and third parameters, takes the upper 8 bytes of the result pair to produce an __m128d result.
The first and second parameters contain a pair of packs and each of them contains, in turn, two 32-bit signed integers. This function compares each of 32-bit signed integer in the first parameter with corresponding 32-bit signed integer in the second parameter and build up a pair of two 32-bit signed integer packs with the bigger results of comparisons as an __m128i result.
This function produces an __m128i result by copying the maximum values of each signed long long type number of the first parameter or the ones of the second parameter.
The first and second parameters contain a pair of packs and each of them contains, in turn, two 32-bit unsigned integers. This function compares each of 32-bit unsigned integer in the first parameter with corresponding 32-bit unsigned integer in the second parameter and build up a pair of two 32-bit unsigned integer packs with the bigger results of comparisons as an __m128i result.
This function produces an __m128i result by copying the minimum values of each signed long long type number of the first parameter or the ones of the second parameter.
The first and second parameters contain a pair of packs and each of them contains, in turn, two 32-bit signed integers. This function compares each of 32-bit signed integer in the first parameter with corresponding 32-bit signed integer in the second parameter and build up a pair of two 32-bit signed integer packs with the smaller results of comparisons as an __m128i result.
This function produces an __m128i result by copying the minimum values of each signed long long type number of the first parameter or the ones of the second parameter.
The first and second parameters contain a pair of packs and each of them contains, in turn, two 32-bit unsigned integers. This function compares each of 32-bit unsigned integer in the first parameter with corresponding 32-bit unsigned integer in the second parameter and build up a pair of two 32-bit unsigned integer packs with the smaller results of comparisons as an __m128i result.
This function produces an __m128i result by copying the minimum values of each unsigned long long type number of the first parameter or the ones of the second parameter.
The first and second parameters contain a pair of packs and each of them contains, in turn, two 32-bit integers. This function multiplies each 32-bit integer in the packs of the first parameter with the corresponding 32-bit integer in the second parameter, then put the lower 32-bit integer of the result in the corresponding portion of resulting __m128i value.
The first and second parameters contain a pair of 64-bit integers. This function multiplies each 64-bit integer in the first parameter with the corresponding 64-bit integer in the second parameter, then put the lower 64-bit integer of the result in the corresponding portion of resulting __m128i value.
The first second and third parameters contain a pair of packs and each of them contains, in turn, four 16-bit integers. Each 16-bit integer of the third parameter is overwritten with the corresponding 16-bit integer of the second parameter if the MSB of the corresponding 16-bit integer of the first parameter is 1. If it is 0, the 16-bit integer of the third parameter is left unchanged.
The second and third parameters contain a pair of packs and each of them contains, in turn, four 16-bit integers. This function consults each of a pair of the most significant four bits of the first parameter to select one of the corresponding 16-bit integers from the second and third parameters and build up a pair of four 16-bit integer packs as an __m128i result.
The first second and third parameters contain a pair of packs and each of them contains, in turn, two 32-bit integers. Each 32-bit integer of the third parameter is overwritten with the corresponding 32-bit integer of the second parameter if the MSB of the corresponding 32-bit integer of the first parameter is 1. If it is 0, the 32-bit integer of the third parameter is left unchanged.
The second and third parameters contain a pair of packs and each of them contains, in turn, two 32-bit integers. This function consults each of a pair of the most significant two bits of the first parameter to select one of the corresponding 16-bit integers from the second and third parameters and build up a pair of four 16-bit integer packs as an __m128i result.
The first second and third parameters contain a pair of packs and each of them contains, in turn, eight 8-bit integers. Each 8-bit integer of the third parameter is overwritten with the corresponding 8-bit integer of the second parameter if the MSB of the corresponding 8-bit integer of the first parameter is 1. If it is 0, the 8-bit integer of the third parameter is left unchanged.
The second and third parameters contain a pair of packs and each of them contains, in turn, eight 8-bit integers. This function consults each of a pair of the most significant eight bits of the first parameter to select one of the corresponding 8-bit integers from the second and third parameters and build up a pair of eight 8-bit integer packs as an __m128i result.
This function produces an __m128i result by logical-shifting left of each unsigned long long type number of the first parameter by the shift amount indicated by the unsigned long long type number of the second parameter.
This function produces an __m128i result by arithmetic-shifting right of each signed long long type number of the first parameter by the shift amount indicated by the unsigned long long type number of the second parameter.
This function produces an __m128i result by logical-shifting right of each unsigned long long type number of the first parameter by the shift amount indicated by the unsigned long long type number of the second parameter.
The first and second parameters contain a pair of packs and each of them contains, in turn, four 16-bit integers. This function subtracts every 16-bit integer in the packs of the second parameter from the corresponding 16-bit integer in the first parameter, then put the resulting 16-bit integer into the corresponding part of the resulting __m128i value.
The first and second parameters contain a pair of packs and each of them contains, in turn, two 32-bit integers. This function subtracts every 32-bit integer in the packs of the second parameter from the corresponding 32-bit integer in the first parameter, then put the resulting 32-bit integer into the corresponding part of the resulting __m128i value.
This function produces an __m128i result by subtracting each unsigned long long type number of the second parameter from the unsigned long long type number of the first parameter.
The first and second parameters contain a pair of packs and each of them contains, in turn, eight 8-bit integers. This function subtract every 8-bit integer in the packs of the second parameter from the corresponding 8-bit integer in the first parameter and return the resulting pair of packs.
This function produces an __m128d result by copying each double-precision floating-point number of the first parameter or the ones of the second parameter, regarding the MSB's of the third parameter.
This function produces an __m128d result by copying each unsigned long long type number of the first parameter or the ones of the second parameter, regarding the MSB's of the third parameter.
The parameter contains a pair of 32-bit integers. This function sign-extends each 32-bit integer to signed 64-bit integer and put the result in the corresponding portion of resulting __m128i value.
This function executes logical right or left shift on the first and second parameter, masked the fragments out of them and bitwise-or them together to produce an __m128d result. The shift width mask width and mask offset are given as the third parameter.
This function executes logical right or left shift on the first and second parameter, masked the fragments out of them and bitwise-or them together to produce an __m128i result. The shift width mask width and mask offset are given as the third parameter.
This function first swaps a pair of double-precision floating-point numbers the first parameter holds, then executes logical right or left shift on the first and second parameter, masked the fragments out of them and do a logical operation on them together to produce an __m128d result. The shift width, mask width, mask offset, and the kind of logical operation are given as the third parameter.
This function first swaps a pair of double-precision floating-point numbers the first parameter holds, then executes logical right or left shift on the first and second parameter, masked the fragments out of them and do a logical operation on them together to produce an __m128i result. The shift width, mask width, mask offset, and the kind of logical operation are given as the third parameter.
The first and second parameters contain a pair of packs and each of them contains, in turn, two 32-bit unsigned integers. This function shift-lefts each 32-bit unsigned integers of the first parameter logically by the shift counts indicated by the corresponding 32-bit unsigned integers in the second parameter and return the resulting pair of packs.
This function generates a pair of the square roots of the double-precision floating-point numbers the parameter holds to produce an __m128d result.
The first parameter contains a pair of packs and each of them contains, in turn, two 32-bit signed integers and the second parameter contains a pair of packs of two 32-bit unsigned integers. This function shift-rights each 32-bit unsigned integers of the first parameter arithmetically by the shift counts indicated by the corresponding 32-bit unsigned integers in the second parameter and return the pair.
This function returns the value of the first parameter as it is to produce an __m128d result.
This function returns the value of the first parameter as it is to produce an __m128i result.
This function returns the value of the first parameter as it is to produce an __m128d result.
This function returns the value of the first parameter as it is to produce an __m128i result.
The first and second parameters contain a pair of packs and each of them contains, in turn, two 32-bit unsigned integers. This function shift-rights each 32-bit unsigned integers of the first parameter logically by the shift counts indicated by the corresponding 32-bit unsigned integers in the second parameter and return the resulting pair of packs.
This function executes subtraction to produce an __m128d result.
This function performs bitwise XNOR operation between the first parameter and the second parameter to produce an __m128d result.
This function performs bitwise XNOR operation between the first parameter and the second parameter to produce an __m128d result.
This function performs bitwise XOR operation between the first parameter and the second parameter to produce an __m128d result.
This function performs bitwise XOR operation between the first parameter and the second parameter to produce an __m128i result.
This function converts each of a pair of signed long long integers to double-precision floating-point numbers to produce an __m128d result.
This function produces an __m128d result whose bits are all 0.
This function produces an __m128i result whose bits are all 0.
The parameter contains a pair of 32-bit integers. This function zero-extends each 32-bit integer to unsigned 64-bit integer and put the result in the corresponding portion of resulting __m128i value.
This is an alias to __sparcace_lddfds_m128i().
This function loads a pair of 64-bit integer from the 4-byte aligned address pointed to by the parameter. Lower 64-bit data is copied into basic part of the return value and upper 32-bit data is copied into extend part of the return value.
This function loads a pair of 32-bit signed integer from the 4-byte aligned address pointed to by the parameter. Lower 32-bit data is copied into basic part of the pair and upper 32-bit data is copied into extend part of the pair. The return value is sign-extended.
This function loads a pair of 32-bit unsigned integer from the 4-byte aligned address pointed to by the parameter. Lower 32-bit data is copied into basic part of the return value and upper 32-bit data is copied into extend part of the pair. The return value is zero-extended.
This function builds an __m128d type data from a pair of double-precision floating-point numbers and returns the object.
This function builds an __m128i type data from a pair of unsigned long long type numbers and returns the object.
This is an alias to __sparcace_stdfds_m128i().
This function stores the basic part of the pair of 64-bit integers which the first parameter contains to the lower 8-byte of 16-byte area of the address which is 4-byte aligned and pointed to by the second parameter and the extend part of the pair to the upper 8-byte of the address.
This function stores each double-precision floating-point number of the first parameter to the 16 byte-aligned address pointed to by the third parameter if the MSB of the corresponding floating-point number of the second parameter is one. Otherwise does nothing.
This function stores each unsigned long long type number of the first parameter to the 16 byte-aligned address pointed to by the third parameter if the MSB of the corresponding unsigned long long type number of the second parameter is one. Otherwise does nothing.
The first and second parameters contain a pair of packs and each of them contains, in turn, two 32-bit integers. This function stores each of the four 32-bit integers which the first parameter contains to the 16-byte area of the address which is 4-byte aligned and pointed to by the third parameter if the MSB (bit 63) of the corresponding 32-bit integer of the second parameter is 1. If the MSB (bit 63) is 0, the store skipped.
The first and second parameters contain a pair of 64-bit integers. This function stores upper 32-bit part of the basic 64-bit integer of the pair which the first parameter contains to the 16-byte area of the address which is 4-byte aligned and pointed to by the third parameter if the MSB (bit 63) of the corresponding 64-bit integer of the second parameter is 1. It then stores the lower 32-bit part of the first 64-bit integer of the pair if the second MSB (bit 62) is 1. And then it stores upper and lower 32-bit part of the extend 64-bit integer if the MSB (bit 63) and second MSB (bit 62) of the corresponding 64-bit integer of the second parameter is 1 respectively.
This function stores the lower 32-bit part of basic part of the pair of 64-bit integers which the first parameter contains to the lower 4-byte of 8-byte area of the address which is 4-byte aligned and pointed to by the third parameter if the MSB (bit 63) of the basic part of the second parameter is 1. And the lower 32-bit part of extend part of the pair to the upper 4-byte of the address if the MSB (bit 63) of the extend part of the second parameter is 1.
This function stores the lower 32-bit part of basic part of the pair of 64-bit integers which the first parameter contains to the lower 4-byte of 8-byte area of the address which is 4-byte aligned and pointed to by the second parameter and the lower 32-bit part of extend part of the pair to the upper 4-byte of the address.
This function swaps the two double-precision floating-point numbers the parameter holds to produce an __m128d result.
This function swaps the two unsigned long long integers the parameter holds to produce an __m128i result.
This is an alias to __sparcace_fpadd16_m128i().
This is an alias to __sparcace_fpadd32_m128i().
This is an alias to __sparcace_fpadd64_m128i().
This is an alias to __sparcace_faddd_m128d().
This is an alias to __sparcace_fand_m128d().
This is an alias to __sparcace_fand_m128i().
This is an alias to __sparcace_fandnot1_m128d().
This is an alias to __sparcace_fandnot1_m128i().
This is an alias to __sparcace_cast_m128d_m128i().
This is an alias to __sparcace_cast_m128i_m128d().
This is an alias to __sparcace_fpcmpueq16x_m128i().
This is an alias to __sparcace_fpcmpueq32x_m128i().
This is an alias to __sparcace_fpcmpueq8x_m128i().
This is an alias to __sparcace_fpcmpgt16x_m128i().
This is an alias to __sparcace_fpcmpgt32x_m128i().
This is an alias to __sparcace_fpcmpgt8x_m128i().
This is an alias to __sparcace_fdivd_m128d().
This is an alias to __sparcace_fmaddd_m128d().
This is an alias to __sparcace_fmsubd_m128d().
This is an alias to __sparcace_fnmsubd_m128d(). CAUTION: this is not an alias to __sparcace_fnmaddd_m128d().
This is an alias to __sparcace_fnmaddd_m128d(). CAUTION: this is not an alias to __sparcace_fnmsubd_m128().
This is an alias to __sparcace_fpmax32x_m128i().
This is an alias to __sparcace_fpmaxu32x_m128i().
This is an alias to __sparcace_fmaxd_m128d().
This is an alias to __sparcace_fpmin32x_m128i().
This is an alias to __sparcace_fpminu32x_m128i().
This is an alias to __sparcace_fmind_m128d().
This is an alias to __sparcace_fmuld_m128d().
This is an alias to __sparcace_for_m128d().
This is an alias to __sparcace_for_m128i().
This is an alias to __sparcace_set_m128i().
This is an alias to __sparcace_set_m128d().
This is an alias to __sparcace_fzero_m128d().
This is an alias to __sparcace_fzero_m128i().
This is an alias to __sparcace_fpsll64x_m128i().
This is an alias to __sparcace_fsqrtd_m128d().
This is an alias to __sparcace_fpsrl64x_m128i().
This is an alias to __sparcace_fpsub16_m128i().
This is an alias to __sparcace_fpsub32_m128i().
This is an alias to __sparcace_fpsub64_m128i().
This is an alias to __sparcace_fsubd_m128d().
This is an alias to __sparcace_fxor_m128d().
This is an alias to __sparcace_fxor_m128i().
SPARC64X, SPARC64X+, and SPARC64 XII support the Decimal Floating-Point data type and operations. The data format conforms to 64bit DPD defined in IEEE 754-2008. The compiler provides the type and various functions to handle the data.
To represent Decimal Floating-Point numbers, _Decimal64 intrinsic type is declared in dpd_conf.h. You must include the header file prior to use of the type as in the following example:
#include <dpd_conf.h> int main(void) { _Decimal64 dd; ... return 0; }
_Decimal64 type
can be modified with type modifiers: const and/or volatile.
can be specified with storage class specifiers: auto, static, register, extern and/or typedef.
can be an element of an aggregate: array, struct and/or union.
_Decimal64 type variables
can be a formal parameter of a function.
can be an actual argument of a function call.
can be the return value of a function.
can be lhs or rhs of assignment operator "=".
can be the operand of address operator "&".
can be the operand of sizeof operator.
can be the operand of typeof operator.
Intrinsic functions are provided for other operations such as arithmetic, comparison, or type conversion.
Literal syntax for _Decimal64 is not supported. Intrinsics for type conversion can be used instead.
Memory alignment of an _Decimal64 type data is the same as a 64-bit Binary Floating-Point number.
The __DEC_FP_INTR macro is defined as 1 when -xarch=[sparcace|sparcaceplus| sparcace2] and -m64 are specified. This macro is useful to determine whether the compiler supports the Decimal Floating-Point intrinsics feature.
The DEC_EVAL_METHOD macro required by IEEE 754-2008 is defined as 1 when dpd_conf.h is included.
The __STDC_DEC_FP__ macro is not defined, as the compiler does not fully support the functionality described in ISO/IEC TR 24732.
The #pragma FLOAT_CONST_DECIMAL_64 required by IEEE 754-2008 is not supported.
The list below describes the intrinsic functions declared in dpd_conf.h header file. Unlike SIMD intrinsic functions, exactly same intrinsic functions are available on SPARC64 X, SPARC64 X+, and SPARC64 XII.
This function stores src into memory addressed by addr. addr must be aligned on an 8-byte boundary, or the behavior is undefined regardless of the -xmemalign setting.
This function loads _Decimal64 type value from memory addressed by addr, and returns it. addr must be aligned on an 8-byte boundary, or the behavior is undefined regardless of the -xmemalign setting.
This function adds src1 and src2, and returns the result. A floating-point exception is thrown in accordance with the IEEE 754-2008 standard.
This function subtracts src2 from src1, and returns the result. A floating-point exception is thrown in accordance with the IEEE 754-2008 standard.
This function multiplies src1 and src2, and returns the result. A floating-point exception is thrown in accordance with the IEEE 754-2008 standard.
This function divides src1 by src2, and returns the result. A floating-point exception is thrown in accordance with the IEEE 754-2008 standard.
This function computes the absolute value of src and returns the result. No floating-point exception is thrown even if src is signaling NaN.
This function reverses the sign of src and returns the result. No floating-point exception is thrown even if src is signaling NaN.
This function returns non-0 when src1 is equal to src2, otherwise it returns 0. The treatments of NaN, Inf and negative-Zero conforms to IEEE 754-2008.
This function returns non-0 when src1 is not equal to src2, otherwise it returns 0. The treatments of NaN, Inf and negative-Zero conforms to IEEE 754-2008.
This function returns non-0 when src1 is grater than src2, otherwise it returns 0. The treatments of NaN, Inf and negative-Zero conforms to IEEE 754-2008.
This function returns non-0 when src1 is grater than or equal to src2, otherwise it returns 0. The treatments of NaN, Inf and negative-Zero conforms to IEEE 754-2008.
This function returns non-0 when src1 is less than src2, otherwise it returns 0. The treatments of NaN, Inf and negative-Zero conforms to IEEE 754-2008.
This function returns non-0 when src1 is less than or equal to src2, otherwise it returns 0. The treatments of NaN, Inf and negative-Zero conforms to IEEE 754-2008.
This function converts a 64-bit signed integer value in src to a Decimal Floating-Point value and returns the result.
This function converts a 64-bit unsigned integer value in src to a Decimal Floating-Point value and returns the result.
This function converts a Binary Floating-Point value in src to a Decimal Floating-Point value and returns the result.
This function behaves just as the function strtod64() defined in "ISO/IEC TR 24732", except the rounding direction is fixed to "to nearest, ties even".
This function converts a Decimal Floating-Point value in src to a 64-bit signed integer value and returns the result.
This function converts a Decimal Floating-Point value in src to a 64-bit unsigned integer value and returns the result.
This function converts a Decimal Floating-Point value in src to a Binary Floating-Point value and returns the result.
This function prints dec in %He format to the memory addressed by buf. The precision is as long as the coefficient of dec. The output string is terminated with a null character at the (n-1)th character when the string is equal to or longer than n, or at the end of the string. This function returns buf when dec is successfully translated to string and a null pointer otherwise.
This function prints dec in %Hf format to the memory addressed by buf. The precision is as long as the coefficient of dec. The output string is terminated with a null character at the (n-1)th character when the string is equal to or longer than n, or at the end of the string. This function returns buf when dec is successfully translated to string and a null pointer otherwise.
This function retrieves the current rounding mode for _Decimal64. The value is defined in dpd_conf.h, as follows:
round to nearest, ties to even
round toward zero
round toward positive infinity
round toward negative infinity
round to nearest, ties away from zero
The initial value of the rounding mode for _Decimal64 is __DPD_ROUND_NEAREST. Note that the -fround option does not alter the rounding mode for _Decimal64.
This function set the rounding mode for _Decimal64 to r. r should be one those listed above. It returns 0 on success or non-0 on failure.