Signaling NaN (sNaN): exponent all 1s, mantissa MSB = 0, at least one other * bit set Intel x86 will convert sNaN to qNaN on most operations */

Add the lower single-precision (32-bit) floating-point element in a and b, store the result in the lower element of dst, and copy the upper 3 packed e

Perform the last round of an AES encryption flow on data (state) in a using the round key in RoundKey, and store the result in dst. https://www.intel.

Compare packed single-precision (32-bit) floating-point elements in a and b to see if neither is NaN, and store the results in dst. https://www.intel.

Compare the lower single-precision (32-bit) floating-point elements in a and b, store the minimum value in the lower element of dst, and copy the uppe

Multiply packed double-precision (64-bit) floating-point elements in a and b, and store the results in dst. https://www.intel.com/content/www/us/en/do

Broadcast 8-bit integer a to all elements of dst. https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_set1_epi8

Extract double from __m128d at index */

Perform the last round of an AES decryption flow on data (state) in a using the round key in RoundKey, and store the result in dst. https://www.intel.

Round the packed double-precision (64-bit) floating-point elements in a up to an integer value, and store the results as packed double-precision float

Compare packed single-precision (32-bit) floating-point elements in a and b for greater-than, and store the results in dst. https://www.intel.com/cont

Compare packed double-precision (64-bit) floating-point elements in a and b for less-than, and store the results in dst. https://www.intel.com/content

Compare the lower double-precision (64-bit) floating-point element in a and b for equality, and return the boolean result (0 or 1). https://www.intel.

Compare the lower single-precision (32-bit) floating-point element in a and b for equality, and return the boolean result (0 or 1). https://www.intel.

Round the packed double-precision (64-bit) floating-point elements in a down to an integer value, and store the results as packed double-precision flo

Compare the lower single-precision (32-bit) floating-point elements in a and b, store the maximum value in the lower element of dst, and copy the uppe

Broadcast 64-bit integer a to all elements of dst. https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_mm_set1_epi64x

This function is not called from "runSingleTest", but for other intrinsic tests that might need to call "_mm_set_epi32".

Verify all lanes of __m128d have expected bit pattern */

Compute the bitwise AND of packed single-precision (32-bit) floating-point elements in a and b, and store the results in dst. https://www.intel.com/co

Blend packed single-precision (32-bit) floating-point elements from a and b using mask, and store the results in dst. https://www.intel.com/content/ww

Compare packed double-precision (64-bit) floating-point elements in a and b for equality, and store the results in dst. https://www.intel.com/content/

Compare packed single-precision (32-bit) floating-point elements in a and b for greater-than-or-equal, and store the results in dst. https://www.intel

Compare packed single-precision (32-bit) floating-point elements in a and b for less-than-or-equal, and store the results in dst. https://www.intel.co

Compare packed double-precision (64-bit) floating-point elements in a and b to see if neither is NaN, and store the results in dst. https://www.intel.

Starting with the initial value in crc, accumulates a CRC32 value for unsigned 16-bit integer v, and stores the result in dst. https://www.intel.com/c

Starting with the initial value in crc, accumulates a CRC32 value for unsigned 32-bit integer v, and stores the result in dst. https://www.intel.com/c

Starting with the initial value in crc, accumulates a CRC32 value for unsigned 8-bit integer v, and stores the result in dst. https://www.intel.com/co

Convert packed signed 32-bit integers in a to packed single-precision (32-bit) floating-point elements, and store the results in dst. https://www.inte

Convert packed double-precision (64-bit) floating-point elements in a to packed 32-bit integers, and store the results in dst. https://www.intel.com/c

Convert the lower single-precision (32-bit) floating-point element in a to a 32-bit integer with truncation, and store the result in dst. x86 returns

Divide the lower single-precision (32-bit) floating-point element in a by the lower single-precision (32-bit) floating-point element in b, store the r

Horizontally add adjacent pairs of single-precision (32-bit) floating-point elements in a and b, and pack the results in dst. See SSE3 rounding mode n

Horizontally subtract adjacent pairs of single-precision (32-bit) floating-point elements in a and b, and pack the results in dst. See SSE3 rounding m

Conditionally store 8-bit integer elements from a into memory using mask (elements are not stored when the highest bit is not set in the corresponding

Horizontally compute the minimum amongst the packed unsigned 16-bit integers in a, store the minimum and index in dst, and zero the remaining bits in

Multiply the lower single-precision (32-bit) floating-point element in a and b, store the result in the lower element of dst, and copy the upper 3 pac

Multiply packed signed 16-bit integers in a and b, producing intermediate signed 32-bit integers. Shift right by 15 bits while rounding up, and store

Compute the bitwise OR of packed single-precision (32-bit) floating-point elements in a and b, and store the results in dst. https://www.intel.com/con

Compute the approximate reciprocal of the lower single-precision (32-bit) floating-point element in a, store the result in the lower element of dst, a

Compute the approximate reciprocal square root of the lower single-precision (32-bit) floating-point element in a, store the result in the lower eleme

Compute the square root of the lower single-precision (32-bit) floating-point element in a, store the result in the lower element of dst, and copy the

Subtract packed double-precision (64-bit) floating-point elements in b from packed double-precision (64-bit) floating-point elements in a, and store t

Vectorized helper: apply x86 saturation semantics to NEON conversion result. * ARM returns 0 for NaN and INT32_MAX for positive overflow, but x86 ret

AES-128 decryption using AES-NI intrinsics */

Double precision qNaN with custom payload */

Add the lower double-precision (64-bit) floating-point element in a and b, store the result in the lower element of dst, and copy the upper element fr

Add packed signed 16-bit integers in a and b using saturation, and store the results in dst. https://www.intel.com/content/www/us/en/docs/intrinsics-g

Add packed signed 8-bit integers in a and b using saturation, and store the results in dst. https://www.intel.com/content/www/us/en/docs/intrinsics-gu

Compute the bitwise AND of packed double-precision (64-bit) floating-point elements in a and b, and store the results in dst. https://www.intel.com/co

Blend packed 8-bit integers from a and b using mask, and store the results in dst. https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index

Blend packed double-precision (64-bit) floating-point elements from a and b using mask, and store the results in dst. https://www.intel.com/content/ww

Compare the lower single-precision (32-bit) floating-point elements in a and b for equality, store the result in the lower element of dst, and copy th

Compare packed strings in a and b with lengths la and lb using the control in imm8, and store the generated index in dst. https://www.intel.com/conten

Compare packed double-precision (64-bit) floating-point elements in a and b for greater-than-or-equal, and store the results in dst. https://www.intel

Compare packed double-precision (64-bit) floating-point elements in a and b for greater-than, and store the results in dst. https://www.intel.com/cont

Compare packed double-precision (64-bit) floating-point elements in a and b for less-than-or-equal, and store the results in dst. https://www.intel.co

Compare packed double-precision (64-bit) floating-point elements in a and b for not-equal, and store the results in dst. https://www.intel.com/content

Compare packed single-precision (32-bit) floating-point elements in a and b for not-equal, and store the results in dst. https://www.intel.com/content

Compare packed double-precision (64-bit) floating-point elements in a and b to see if either is NaN, and store the results in dst. https://www.intel.c

Compare the lower single-precision (32-bit) floating-point element in a and b for less-than, and return the boolean result (0 or 1). https://www.intel

Compare the lower single-precision (32-bit) floating-point element in a and b for not-equal, and return the boolean result (0 or 1). https://www.intel

Convert packed double-precision (64-bit) floating-point elements in a to packed 32-bit integers with truncation, and store the results in dst. https:/

Divide the lower double-precision (64-bit) floating-point element in a by the lower double-precision (64-bit) floating-point element in b, store the r

Conditionally multiply the packed single-precision (32-bit) floating-point elements in a and b using the high 4 bits in imm8, sum the four products, a

Load a double-precision (64-bit) floating-point element from memory into the lower of dst, and zero the upper element. mem_addr does not need to be al

Create mask from the most significant bit of each 8-bit element in a, and store the result in dst. https://www.intel.com/content/www/us/en/docs/intrin

Set each bit of mask dst based on the most significant bit of the corresponding packed single-precision (32-bit) floating-point element in a. https://

Multiply the lower double-precision (64-bit) floating-point element in a and b, store the result in the lower element of dst, and copy the upper eleme

Compute the square root of the lower double-precision (64-bit) floating-point element in b, store the result in the lower element of dst, and copy the

Store 128-bits (composed of 4 packed single-precision (32-bit) floating-point elements) from a into memory. mem_addr must be aligned on a 16-byte boun

Subtract packed 32-bit integers in b from packed 32-bit integers in a, and store the results in dst. https://www.intel.com/content/www/us/en/docs/intr

Subtract the lower double-precision (64-bit) floating-point element in b from the lower double-precision (64-bit) floating-point element in a, store t

Subtract packed signed 16-bit integers in b from packed 16-bit integers in a using saturation, and store the results in dst. https://www.intel.com/con

Subtract packed signed 8-bit integers in b from packed 8-bit integers in a using saturation, and store the results in dst. https://www.intel.com/conte

Subtract packed unsigned 16-bit integers in b from packed unsigned 16-bit integers in a using saturation, and store the results in dst. https://www.in

Subtract packed unsigned 8-bit integers in b from packed unsigned 8-bit integers in a using saturation, and store the results in dst. https://www.inte

ARMv7 polyfill ARMv7/some A64 lacks vmull_p64, but it has vmull_p8. vmull_p8 calculates 8 8-bit->16-bit polynomial multiplies, but we need a 64-bit->

Performs a 64x64->128-bit carryless/polynomial long multiply, using the above routine to calculate the subproducts needed for the full-size multiply.

This function is not called from "runSingleTest", but for other intrinsic tests that might need to call "_mm_store_ps".

Helper to extract sign bit from float */

Inject a double-precision NaN into a float array for double-precision tests. The float arrays are reinterpreted as doubles via reinterpret_cast, where

Compute the absolute value of packed signed 16-bit integers in a, and store the unsigned results in dst. https://www.intel.com/content/www/us/en/docs/

Compute the absolute value of packed signed 32-bit integers in a, and store the unsigned results in dst. https://www.intel.com/content/www/us/en/docs/

Compute the absolute value of packed signed 8-bit integers in a, and store the unsigned results in dst. https://www.intel.com/content/www/us/en/docs/i

Add packed unsigned 16-bit integers in a and b using saturation, and store the results in dst. https://www.intel.com/content/www/us/en/docs/intrinsics

Add packed unsigned 8-bit integers in a and b using saturation, and store the results in dst. https://www.intel.com/content/www/us/en/docs/intrinsics-