Vector Optimized Library of Kernels 3.1.1
Architecture-tuned implementations of math kernels
 
Loading...
Searching...
No Matches
SSE2NEON Namespace Reference

Data Structures

class  SSE2NEONTest
 
class  SSE2NEONTestImpl
 
struct  test_mm_cmpestri_sbyte_data_t
 
struct  test_mm_cmpestri_sword_data_t
 
struct  test_mm_cmpestri_ubyte_data_t
 
struct  test_mm_cmpestri_uword_data_t
 
struct  test_mm_cmpestrm_sbyte_data_t
 
struct  test_mm_cmpestrm_sword_data_t
 
struct  test_mm_cmpestrm_ubyte_data_t
 
struct  test_mm_cmpestrm_uword_data_t
 
struct  test_mm_cmpistri_sbyte_data_t
 
struct  test_mm_cmpistri_sword_data_t
 
struct  test_mm_cmpistri_ubyte_data_t
 
struct  test_mm_cmpistri_uword_data_t
 
struct  test_mm_cmpistrm_sbyte_data_t
 
struct  test_mm_cmpistrm_sword_data_t
 
struct  test_mm_cmpistrm_ubyte_data_t
 
struct  test_mm_cmpistrm_uword_data_t
 

Enumerations

enum  result_t { TEST_SUCCESS = 1 , TEST_FAIL = 0 , TEST_UNIMPL = -1 }
 
enum  InstructionTest { INTRIN_LIST }
 

Functions

void * platformAlignedAlloc (size_t size)
 
void platformAlignedFree (void *ptr)
 
result_t validateInt64 (__m128i a, int64_t i0, int64_t i1)
 
result_t validateInt64 (__m64 a, int64_t i0)
 
result_t validateUInt64 (__m128i a, uint64_t u0, uint64_t u1)
 
result_t validateUInt64 (__m64 a, uint64_t u0)
 
result_t validateInt32 (__m128i a, int32_t i0, int32_t i1, int32_t i2, int32_t i3)
 
result_t validateUInt32 (__m128i a, uint32_t u0, uint32_t u1, uint32_t u2, uint32_t u3)
 
result_t validateUInt32 (__m64 a, uint32_t u0, uint32_t u1)
 
result_t validateInt16 (__m128i a, int16_t i0, int16_t i1, int16_t i2, int16_t i3, int16_t i4, int16_t i5, int16_t i6, int16_t i7)
 
result_t validateInt16 (__m64 a, int16_t i0, int16_t i1, int16_t i2, int16_t i3)
 
result_t validateUInt16 (__m128i a, uint16_t u0, uint16_t u1, uint16_t u2, uint16_t u3, uint16_t u4, uint16_t u5, uint16_t u6, uint16_t u7)
 
result_t validateInt32 (__m64 a, int32_t u0, int32_t u1)
 
result_t validateUInt16 (__m64 a, uint16_t u0, uint16_t u1, uint16_t u2, uint16_t u3)
 
result_t validateInt8 (__m128i a, int8_t i0, int8_t i1, int8_t i2, int8_t i3, int8_t i4, int8_t i5, int8_t i6, int8_t i7, int8_t i8, int8_t i9, int8_t i10, int8_t i11, int8_t i12, int8_t i13, int8_t i14, int8_t i15)
 
result_t validateInt8 (__m64 a, int8_t i0, int8_t i1, int8_t i2, int8_t i3, int8_t i4, int8_t i5, int8_t i6, int8_t i7)
 
result_t validateUInt8 (__m128i a, uint8_t u0, uint8_t u1, uint8_t u2, uint8_t u3, uint8_t u4, uint8_t u5, uint8_t u6, uint8_t u7, uint8_t u8, uint8_t u9, uint8_t u10, uint8_t u11, uint8_t u12, uint8_t u13, uint8_t u14, uint8_t u15)
 
result_t validateUInt8 (__m64 a, uint8_t u0, uint8_t u1, uint8_t u2, uint8_t u3, uint8_t u4, uint8_t u5, uint8_t u6, uint8_t u7)
 
result_t validateSingleFloatPair (float a, float b)
 
result_t validateSingleDoublePair (double a, double b)
 
result_t validateFloat (__m128 a, float f0, float f1, float f2, float f3)
 
result_t validateFloatEpsilon (__m128 a, float f0, float f1, float f2, float f3, float epsilon)
 
result_t validateFloatError (__m128 a, float f0, float f1, float f2, float f3, float err)
 
result_t validateDouble (__m128d a, double d0, double d1)
 
result_t validateFloatError (__m128d a, double d0, double d1, double err)
 
template<typename T >
result_t validate128 (T a, T b)
 
static float bankersRounding (float val)
 
static double bankersRounding (double val)
 
static double next ()
 
static float ranf ()
 
static float ranf (float low, float high)
 
result_t test_mm_slli_si128 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_srli_si128 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_shuffle_pi16 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
__m128i do_mm_set_epi32 (int32_t x, int32_t y, int32_t z, int32_t w)
 
template<class T >
__m64 load_m64 (const T *p)
 
template<class T >
__m128 load_m128 (const T *p)
 
template<class T >
__m128i load_m128i (const T *p)
 
template<class T >
__m128d load_m128d (const T *p)
 
result_t do_mm_store_ps (float *p, float x, float y, float z, float w)
 
result_t do_mm_store_ps (int32_t *p, int32_t x, int32_t y, int32_t z, int32_t w)
 
float cmp_noNaN (float a, float b)
 
double cmp_noNaN (double a, double b)
 
float cmp_hasNaN (float a, float b)
 
double cmp_hasNaN (double a, double b)
 
int32_t comilt_ss (float a, float b)
 
int32_t comigt_ss (float a, float b)
 
int32_t comile_ss (float a, float b)
 
int32_t comige_ss (float a, float b)
 
int32_t comieq_ss (float a, float b)
 
int32_t comineq_ss (float a, float b)
 
static int16_t saturate_16 (int32_t a)
 
uint32_t canonical_crc32_u8 (uint32_t crc, uint8_t v)
 
uint32_t canonical_crc32_u16 (uint32_t crc, uint16_t v)
 
uint32_t canonical_crc32_u32 (uint32_t crc, uint32_t v)
 
uint64_t canonical_crc32_u64 (uint64_t crc, uint64_t v)
 
__m128i aesenc_128_reference (__m128i a, __m128i b)
 
__m128i aesdec_128_reference (__m128i a, __m128i b)
 
__m128i aesenclast_128_reference (__m128i s, __m128i rk)
 
static uint32_t rotr (uint32_t value, uint32_t amount)
 
static uint64_t MUL (uint32_t a, uint32_t b)
 
static uint64_t clmul_32 (uint32_t x, uint32_t y)
 
static std::pair< uint64_t, uint64_t > clmul_64 (uint64_t x, uint64_t y)
 
result_t test_mm_empty (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_add_ps (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_add_ss (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_and_ps (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_andnot_ps (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_avg_pu16 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_avg_pu8 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cmpeq_ps (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cmpeq_ss (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cmpge_ps (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cmpge_ss (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cmpgt_ps (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cmpgt_ss (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cmple_ps (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cmple_ss (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cmplt_ps (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cmplt_ss (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cmpneq_ps (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cmpneq_ss (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cmpnge_ps (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cmpnge_ss (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cmpngt_ps (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cmpngt_ss (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cmpnle_ps (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cmpnle_ss (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cmpnlt_ps (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cmpnlt_ss (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cmpord_ps (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cmpord_ss (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cmpunord_ps (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cmpunord_ss (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_comieq_ss (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_comige_ss (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_comigt_ss (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_comile_ss (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_comilt_ss (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_comineq_ss (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cvt_pi2ps (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cvt_ps2pi (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cvt_si2ss (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cvt_ss2si (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cvtpi16_ps (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cvtpi32_ps (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cvtpi32x2_ps (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cvtpi8_ps (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cvtps_pi16 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cvtps_pi32 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cvtps_pi8 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cvtpu16_ps (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cvtpu8_ps (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cvtsi32_ss (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cvtsi64_ss (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cvtss_f32 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cvtss_si32 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cvtss_si64 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cvtt_ps2pi (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cvtt_ss2si (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cvttps_pi32 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cvttss_si32 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cvttss_si64 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_div_ps (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_div_ss (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_extract_pi16 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_malloc (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_free (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_get_flush_zero_mode (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_get_rounding_mode (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_getcsr (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_insert_pi16 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_load_ps (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_load_ps1 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_load_ss (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_load1_ps (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_loadh_pi (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_loadl_pi (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_loadr_ps (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_loadu_ps (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_loadu_si16 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_loadu_si64 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_maskmove_si64 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_m_maskmovq (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_max_pi16 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_max_ps (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_max_pu8 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_max_ss (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_min_pi16 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_min_ps (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_min_pu8 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_min_ss (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_move_ss (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_movehl_ps (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_movelh_ps (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_movemask_pi8 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_movemask_ps (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_mul_ps (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_mul_ss (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_mulhi_pu16 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_or_ps (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_m_pavgb (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_m_pavgw (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_m_pextrw (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_m_pinsrw (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_m_pmaxsw (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_m_pmaxub (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_m_pminsw (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_m_pminub (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_m_pmovmskb (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_m_pmulhuw (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_prefetch (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_m_psadbw (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_m_pshufw (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_rcp_ps (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_rcp_ss (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_rsqrt_ps (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_rsqrt_ss (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_sad_pu8 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_set_flush_zero_mode (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_set_ps (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_set_ps1 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_set_rounding_mode (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_set_ss (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_set1_ps (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_setcsr (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_setr_ps (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_setzero_ps (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_sfence (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_shuffle_ps (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_sqrt_ps (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_sqrt_ss (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_store_ps (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_store_ps1 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_store_ss (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_store1_ps (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_storeh_pi (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_storel_pi (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_storer_ps (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_storeu_ps (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_storeu_si16 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_storeu_si64 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_stream_pi (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_stream_ps (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_sub_ps (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_sub_ss (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_ucomieq_ss (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_ucomige_ss (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_ucomigt_ss (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_ucomile_ss (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_ucomilt_ss (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_ucomineq_ss (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_undefined_ps (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_unpackhi_ps (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_unpacklo_ps (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_xor_ps (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_add_epi16 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_add_epi32 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_add_epi64 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_add_epi8 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_add_pd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_add_sd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_add_si64 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_adds_epi16 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_adds_epi8 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_adds_epu16 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_adds_epu8 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_and_pd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_and_si128 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_andnot_pd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_andnot_si128 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_avg_epu16 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_avg_epu8 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_bslli_si128 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_bsrli_si128 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_castpd_ps (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_castpd_si128 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_castps_pd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_castps_si128 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_castsi128_pd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_castsi128_ps (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_clflush (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cmpeq_epi16 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cmpeq_epi32 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cmpeq_epi8 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cmpeq_pd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cmpeq_sd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cmpge_pd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cmpge_sd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cmpgt_epi16 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cmpgt_epi32 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cmpgt_epi8 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cmpgt_pd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cmpgt_sd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cmple_pd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cmple_sd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cmplt_epi16 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cmplt_epi32 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cmplt_epi8 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cmplt_pd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cmplt_sd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cmpneq_pd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cmpneq_sd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cmpnge_pd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cmpnge_sd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cmpngt_pd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cmpngt_sd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cmpnle_pd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cmpnle_sd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cmpnlt_pd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cmpnlt_sd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cmpord_pd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cmpord_sd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cmpunord_pd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cmpunord_sd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_comieq_sd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_comige_sd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_comigt_sd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_comile_sd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_comilt_sd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_comineq_sd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cvtepi32_pd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cvtepi32_ps (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cvtpd_epi32 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cvtpd_pi32 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cvtpd_ps (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cvtpi32_pd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cvtps_epi32 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cvtps_pd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cvtsd_f64 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cvtsd_si32 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cvtsd_si64 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cvtsd_si64x (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cvtsd_ss (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cvtsi128_si32 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cvtsi128_si64 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cvtsi128_si64x (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cvtsi32_sd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cvtsi32_si128 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cvtsi64_sd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cvtsi64_si128 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cvtsi64x_sd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cvtsi64x_si128 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cvtss_sd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cvttpd_epi32 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cvttpd_pi32 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cvttps_epi32 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cvttsd_si32 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cvttsd_si64 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cvttsd_si64x (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_div_pd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_div_sd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_extract_epi16 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_insert_epi16 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_lfence (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_load_pd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_load_pd1 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_load_sd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_load_si128 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_load1_pd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_loadh_pd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_loadl_epi64 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_loadl_pd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_loadr_pd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_loadu_pd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_loadu_si128 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_loadu_si32 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_madd_epi16 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_maskmoveu_si128 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_max_epi16 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_max_epu8 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_max_pd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_max_sd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_mfence (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_min_epi16 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_min_epu8 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_min_pd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_min_sd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_move_epi64 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_move_sd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_movemask_epi8 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_movemask_pd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_movepi64_pi64 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_movpi64_epi64 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_mul_epu32 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_mul_pd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_mul_sd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_mul_su32 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_mulhi_epi16 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_mulhi_epu16 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_mullo_epi16 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_or_pd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_or_si128 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_packs_epi16 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_packs_epi32 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_packus_epi16 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_pause (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_sad_epu8 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_set_epi16 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_set_epi32 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_set_epi64 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_set_epi64x (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_set_epi8 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_set_pd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_set_pd1 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_set_sd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_set1_epi16 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_set1_epi32 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_set1_epi64 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_set1_epi64x (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_set1_epi8 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_set1_pd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_setr_epi16 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_setr_epi32 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_setr_epi64 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_setr_epi8 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_setr_pd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_setzero_pd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_setzero_si128 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_shuffle_epi32 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_shuffle_pd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_shufflehi_epi16 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_shufflelo_epi16 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_sll_epi16 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_sll_epi32 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_sll_epi64 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_slli_epi16 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_slli_epi32 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_slli_epi64 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_sqrt_pd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_sqrt_sd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_sra_epi16 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_sra_epi32 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_srai_epi16 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_srai_epi32 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_srl_epi16 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_srl_epi32 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_srl_epi64 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_srli_epi16 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_srli_epi32 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_srli_epi64 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_store_pd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_store_pd1 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_store_sd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_store_si128 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_store1_pd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_storeh_pd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_storel_epi64 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_storel_pd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_storer_pd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_storeu_pd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_storeu_si128 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_storeu_si32 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_stream_pd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_stream_si128 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_stream_si32 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_stream_si64 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_sub_epi16 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_sub_epi32 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_sub_epi64 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_sub_epi8 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_sub_pd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_sub_sd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_sub_si64 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_subs_epi16 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_subs_epi8 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_subs_epu16 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_subs_epu8 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_ucomieq_sd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_ucomige_sd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_ucomigt_sd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_ucomile_sd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_ucomilt_sd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_ucomineq_sd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_undefined_pd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_undefined_si128 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_unpackhi_epi16 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_unpackhi_epi32 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_unpackhi_epi64 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_unpackhi_epi8 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_unpackhi_pd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_unpacklo_epi16 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_unpacklo_epi32 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_unpacklo_epi64 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_unpacklo_epi8 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_unpacklo_pd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_xor_pd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_xor_si128 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_addsub_pd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_addsub_ps (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_hadd_pd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_hadd_ps (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_hsub_pd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_hsub_ps (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_lddqu_si128 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_loaddup_pd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_movedup_pd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_movehdup_ps (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_moveldup_ps (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_abs_epi16 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_abs_epi32 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_abs_epi8 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_abs_pi16 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_abs_pi32 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_abs_pi8 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_alignr_epi8 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_alignr_pi8 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_hadd_epi16 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_hadd_epi32 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_hadd_pi16 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_hadd_pi32 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_hadds_epi16 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_hadds_pi16 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_hsub_epi16 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_hsub_epi32 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_hsub_pi16 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_hsub_pi32 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_hsubs_epi16 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_hsubs_pi16 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_maddubs_epi16 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_maddubs_pi16 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_mulhrs_epi16 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_mulhrs_pi16 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_shuffle_epi8 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_shuffle_pi8 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_sign_epi16 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_sign_epi32 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_sign_epi8 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_sign_pi16 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_sign_pi32 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_sign_pi8 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_blend_epi16 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_blend_pd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_blend_ps (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_blendv_epi8 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_blendv_pd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_blendv_ps (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_ceil_pd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_ceil_ps (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_ceil_sd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_ceil_ss (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cmpeq_epi64 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cvtepi16_epi32 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cvtepi16_epi64 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cvtepi32_epi64 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cvtepi8_epi16 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cvtepi8_epi32 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cvtepi8_epi64 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cvtepu16_epi32 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cvtepu16_epi64 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cvtepu32_epi64 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cvtepu8_epi16 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cvtepu8_epi32 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cvtepu8_epi64 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_dp_pd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_dp_ps (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_extract_epi32 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_extract_epi64 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_extract_epi8 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_extract_ps (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_floor_pd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_floor_ps (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_floor_sd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_floor_ss (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_insert_epi32 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_insert_epi64 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_insert_epi8 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_insert_ps (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_max_epi32 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_max_epi8 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_max_epu16 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_max_epu32 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_min_epi32 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_min_epi8 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_min_epu16 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_min_epu32 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_minpos_epu16 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_mpsadbw_epu8 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_mul_epi32 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_mullo_epi32 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_packus_epi32 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_round_pd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_round_ps (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_round_sd (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_round_ss (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_stream_load_si128 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_test_all_ones (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_test_all_zeros (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_test_mix_ones_zeros (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_testc_si128 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_testnzc_si128 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_testz_si128 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cmpestra (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cmpestrc (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cmpestri (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cmpestrm (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cmpestro (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cmpestrs (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cmpestrz (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cmpgt_epi64 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cmpistra (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cmpistrc (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cmpistri (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cmpistrm (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cmpistro (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cmpistrs (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_cmpistrz (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_crc32_u16 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_crc32_u32 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_crc32_u64 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_crc32_u8 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_aesenc_si128 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_aesdec_si128 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_aesenclast_si128 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_aesdeclast_si128 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_aesimc_si128 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
static uint32_t sub_word (uint32_t in)
 
result_t test_mm_aeskeygenassist_si128 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_clmulepi64_si128 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_get_denormals_zero_mode (const SSE2NEONTestImpl &impl, uint32_t iter)
 
static int popcnt_reference (uint64_t a)
 
result_t test_mm_popcnt_u32 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_popcnt_u64 (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_mm_set_denormals_zero_mode (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_rdtsc (const SSE2NEONTestImpl &impl, uint32_t iter)
 
result_t test_last (const SSE2NEONTestImpl &impl, uint32_t iter)
 

Variables

int32_t NaN = ~0
 
int64_t NaN64 = ~0
 
const char * instructionString []
 
static uint64_t state
 
const double TWOPOWER64 = pow(2, 64)
 
static const uint8_t crypto_aes_sbox [256]
 
static const uint8_t crypto_aes_rsbox [256]
 
static test_mm_cmpestri_ubyte_data_t test_mm_cmpestra_ubyte_data [TEST_MM_CMPESTRA_UBYTE_DATA_LEN]
 
static test_mm_cmpestri_sbyte_data_t test_mm_cmpestra_sbyte_data [TEST_MM_CMPESTRA_SBYTE_DATA_LEN]
 
static test_mm_cmpestri_uword_data_t test_mm_cmpestra_uword_data [TEST_MM_CMPESTRA_UWORD_DATA_LEN]
 
static test_mm_cmpestri_sword_data_t test_mm_cmpestra_sword_data [TEST_MM_CMPESTRA_SWORD_DATA_LEN]
 
static test_mm_cmpestri_ubyte_data_t test_mm_cmpestrc_ubyte_data [TEST_MM_CMPESTRC_UBYTE_DATA_LEN]
 
static test_mm_cmpestri_sbyte_data_t test_mm_cmpestrc_sbyte_data [TEST_MM_CMPESTRC_SBYTE_DATA_LEN]
 
static test_mm_cmpestri_uword_data_t test_mm_cmpestrc_uword_data [TEST_MM_CMPESTRC_UWORD_DATA_LEN]
 
static test_mm_cmpestri_sword_data_t test_mm_cmpestrc_sword_data [TEST_MM_CMPESTRC_SWORD_DATA_LEN]
 
static test_mm_cmpestri_ubyte_data_t test_mm_cmpestri_ubyte_data [TEST_MM_CMPESTRI_UBYTE_DATA_LEN]
 
static test_mm_cmpestri_sbyte_data_t test_mm_cmpestri_sbyte_data [TEST_MM_CMPESTRI_SBYTE_DATA_LEN]
 
static test_mm_cmpestri_uword_data_t test_mm_cmpestri_uword_data [TEST_MM_CMPESTRI_UWORD_DATA_LEN]
 
static test_mm_cmpestri_sword_data_t test_mm_cmpestri_sword_data [TEST_MM_CMPESTRI_SWORD_DATA_LEN]
 
static test_mm_cmpestrm_ubyte_data_t test_mm_cmpestrm_ubyte_data [TEST_MM_CMPESTRM_UBYTE_DATA_LEN]
 
static test_mm_cmpestrm_sbyte_data_t test_mm_cmpestrm_sbyte_data [TEST_MM_CMPESTRM_SBYTE_DATA_LEN]
 
static test_mm_cmpestrm_uword_data_t test_mm_cmpestrm_uword_data [TEST_MM_CMPESTRM_UWORD_DATA_LEN]
 
static test_mm_cmpestrm_sword_data_t test_mm_cmpestrm_sword_data [TEST_MM_CMPESTRM_SWORD_DATA_LEN]
 
static test_mm_cmpestri_ubyte_data_t test_mm_cmpestro_ubyte_data [TEST_MM_CMPESTRO_UBYTE_DATA_LEN]
 
static test_mm_cmpestri_sbyte_data_t test_mm_cmpestro_sbyte_data [TEST_MM_CMPESTRO_SBYTE_DATA_LEN]
 
static test_mm_cmpestri_uword_data_t test_mm_cmpestro_uword_data [TEST_MM_CMPESTRO_UWORD_DATA_LEN]
 
static test_mm_cmpestri_sword_data_t test_mm_cmpestro_sword_data [TEST_MM_CMPESTRO_SWORD_DATA_LEN]
 
static test_mm_cmpestri_ubyte_data_t test_mm_cmpestrs_ubyte_data [TEST_MM_CMPESTRS_UBYTE_DATA_LEN]
 
static test_mm_cmpestri_sbyte_data_t test_mm_cmpestrs_sbyte_data [TEST_MM_CMPESTRS_SBYTE_DATA_LEN]
 
static test_mm_cmpestri_uword_data_t test_mm_cmpestrs_uword_data [TEST_MM_CMPESTRS_UWORD_DATA_LEN]
 
static test_mm_cmpestri_sword_data_t test_mm_cmpestrs_sword_data [TEST_MM_CMPESTRS_SWORD_DATA_LEN]
 
static test_mm_cmpestri_ubyte_data_t test_mm_cmpestrz_ubyte_data [TEST_MM_CMPESTRZ_UBYTE_DATA_LEN]
 
static test_mm_cmpestri_sbyte_data_t test_mm_cmpestrz_sbyte_data [TEST_MM_CMPESTRZ_SBYTE_DATA_LEN]
 
static test_mm_cmpestri_uword_data_t test_mm_cmpestrz_uword_data [TEST_MM_CMPESTRZ_UWORD_DATA_LEN]
 
static test_mm_cmpestri_sword_data_t test_mm_cmpestrz_sword_data [TEST_MM_CMPESTRZ_SWORD_DATA_LEN]
 
static test_mm_cmpistri_ubyte_data_t test_mm_cmpistra_ubyte_data [TEST_MM_CMPISTRA_UBYTE_DATA_LEN]
 
static test_mm_cmpistri_sbyte_data_t test_mm_cmpistra_sbyte_data [TEST_MM_CMPISTRA_SBYTE_DATA_LEN]
 
static test_mm_cmpistri_uword_data_t test_mm_cmpistra_uword_data [TEST_MM_CMPISTRA_UWORD_DATA_LEN]
 
static test_mm_cmpistri_sword_data_t test_mm_cmpistra_sword_data [TEST_MM_CMPISTRA_SWORD_DATA_LEN]
 
static test_mm_cmpistri_ubyte_data_t test_mm_cmpistrc_ubyte_data [TEST_MM_CMPISTRC_UBYTE_DATA_LEN]
 
static test_mm_cmpistri_sbyte_data_t test_mm_cmpistrc_sbyte_data [TEST_MM_CMPISTRC_SBYTE_DATA_LEN]
 
static test_mm_cmpistri_uword_data_t test_mm_cmpistrc_uword_data [TEST_MM_CMPISTRC_UWORD_DATA_LEN]
 
static test_mm_cmpistri_sword_data_t test_mm_cmpistrc_sword_data [TEST_MM_CMPISTRC_SWORD_DATA_LEN]
 
static test_mm_cmpistri_ubyte_data_t test_mm_cmpistri_ubyte_data [TEST_MM_CMPISTRI_UBYTE_DATA_LEN]
 
static test_mm_cmpistri_sbyte_data_t test_mm_cmpistri_sbyte_data [TEST_MM_CMPISTRI_SBYTE_DATA_LEN]
 
static test_mm_cmpistri_uword_data_t test_mm_cmpistri_uword_data [TEST_MM_CMPISTRI_UWORD_DATA_LEN]
 
static test_mm_cmpistri_sword_data_t test_mm_cmpistri_sword_data [TEST_MM_CMPISTRI_SWORD_DATA_LEN]
 
static test_mm_cmpistrm_ubyte_data_t test_mm_cmpistrm_ubyte_data [TEST_MM_CMPISTRM_UBYTE_DATA_LEN]
 
static test_mm_cmpistrm_sbyte_data_t test_mm_cmpistrm_sbyte_data [TEST_MM_CMPISTRM_SBYTE_DATA_LEN]
 
static test_mm_cmpistrm_uword_data_t test_mm_cmpistrm_uword_data [TEST_MM_CMPISTRM_UWORD_DATA_LEN]
 
static test_mm_cmpistrm_sword_data_t test_mm_cmpistrm_sword_data [TEST_MM_CMPISTRM_SWORD_DATA_LEN]
 
static test_mm_cmpistri_ubyte_data_t test_mm_cmpistro_ubyte_data [TEST_MM_CMPISTRO_UBYTE_DATA_LEN]
 
static test_mm_cmpistri_sbyte_data_t test_mm_cmpistro_sbyte_data [TEST_MM_CMPISTRO_SBYTE_DATA_LEN]
 
static test_mm_cmpistri_uword_data_t test_mm_cmpistro_uword_data [TEST_MM_CMPISTRO_UWORD_DATA_LEN]
 
static test_mm_cmpistri_sword_data_t test_mm_cmpistro_sword_data [TEST_MM_CMPISTRO_SWORD_DATA_LEN]
 
static test_mm_cmpistri_ubyte_data_t test_mm_cmpistrs_ubyte_data [TEST_MM_CMPISTRS_UBYTE_DATA_LEN]
 
static test_mm_cmpistri_sbyte_data_t test_mm_cmpistrs_sbyte_data [TEST_MM_CMPISTRS_SBYTE_DATA_LEN]
 
static test_mm_cmpistri_uword_data_t test_mm_cmpistrs_uword_data [TEST_MM_CMPISTRS_UWORD_DATA_LEN]
 
static test_mm_cmpistri_sword_data_t test_mm_cmpistrs_sword_data [TEST_MM_CMPISTRS_SWORD_DATA_LEN]
 
static test_mm_cmpistri_ubyte_data_t test_mm_cmpistrz_ubyte_data [TEST_MM_CMPISTRZ_UBYTE_DATA_LEN]
 
static test_mm_cmpistri_sbyte_data_t test_mm_cmpistrz_sbyte_data [TEST_MM_CMPISTRZ_SBYTE_DATA_LEN]
 
static test_mm_cmpistri_uword_data_t test_mm_cmpistrz_uword_data [TEST_MM_CMPISTRZ_UWORD_DATA_LEN]
 
static test_mm_cmpistri_sword_data_t test_mm_cmpistrz_sword_data [TEST_MM_CMPISTRZ_SWORD_DATA_LEN]
 

Enumeration Type Documentation

◆ InstructionTest

Enumerator
INTRIN_LIST 

◆ result_t

Enumerator
TEST_SUCCESS 
TEST_FAIL 
TEST_UNIMPL 

Function Documentation

◆ aesdec_128_reference()

__m128i SSE2NEON::aesdec_128_reference ( __m128i a,
__m128i b )
inline

◆ aesenc_128_reference()

__m128i SSE2NEON::aesenc_128_reference ( __m128i a,
__m128i b )
inline

◆ aesenclast_128_reference()

__m128i SSE2NEON::aesenclast_128_reference ( __m128i s,
__m128i rk )
inline

◆ bankersRounding() [1/2]

static double SSE2NEON::bankersRounding ( double val)
inlinestatic

◆ bankersRounding() [2/2]

static float SSE2NEON::bankersRounding ( float val)
inlinestatic

◆ canonical_crc32_u16()

uint32_t SSE2NEON::canonical_crc32_u16 ( uint32_t crc,
uint16_t v )

◆ canonical_crc32_u32()

uint32_t SSE2NEON::canonical_crc32_u32 ( uint32_t crc,
uint32_t v )

◆ canonical_crc32_u64()

uint64_t SSE2NEON::canonical_crc32_u64 ( uint64_t crc,
uint64_t v )

◆ canonical_crc32_u8()

uint32_t SSE2NEON::canonical_crc32_u8 ( uint32_t crc,
uint8_t v )

◆ clmul_32()

static uint64_t SSE2NEON::clmul_32 ( uint32_t x,
uint32_t y )
static

◆ clmul_64()

static std::pair< uint64_t, uint64_t > SSE2NEON::clmul_64 ( uint64_t x,
uint64_t y )
static

◆ cmp_hasNaN() [1/2]

double SSE2NEON::cmp_hasNaN ( double a,
double b )

◆ cmp_hasNaN() [2/2]

float SSE2NEON::cmp_hasNaN ( float a,
float b )

◆ cmp_noNaN() [1/2]

double SSE2NEON::cmp_noNaN ( double a,
double b )

◆ cmp_noNaN() [2/2]

float SSE2NEON::cmp_noNaN ( float a,
float b )

◆ comieq_ss()

int32_t SSE2NEON::comieq_ss ( float a,
float b )

◆ comige_ss()

int32_t SSE2NEON::comige_ss ( float a,
float b )

◆ comigt_ss()

int32_t SSE2NEON::comigt_ss ( float a,
float b )

◆ comile_ss()

int32_t SSE2NEON::comile_ss ( float a,
float b )

◆ comilt_ss()

int32_t SSE2NEON::comilt_ss ( float a,
float b )

◆ comineq_ss()

int32_t SSE2NEON::comineq_ss ( float a,
float b )

◆ do_mm_set_epi32()

__m128i SSE2NEON::do_mm_set_epi32 ( int32_t x,
int32_t y,
int32_t z,
int32_t w )

◆ do_mm_store_ps() [1/2]

result_t SSE2NEON::do_mm_store_ps ( float * p,
float x,
float y,
float z,
float w )

◆ do_mm_store_ps() [2/2]

result_t SSE2NEON::do_mm_store_ps ( int32_t * p,
int32_t x,
int32_t y,
int32_t z,
int32_t w )

◆ load_m128()

template<class T >
__m128 SSE2NEON::load_m128 ( const T * p)

◆ load_m128d()

template<class T >
__m128d SSE2NEON::load_m128d ( const T * p)

◆ load_m128i()

template<class T >
__m128i SSE2NEON::load_m128i ( const T * p)

◆ load_m64()

template<class T >
__m64 SSE2NEON::load_m64 ( const T * p)

◆ MUL()

static uint64_t SSE2NEON::MUL ( uint32_t a,
uint32_t b )
inlinestatic

◆ next()

static double SSE2NEON::next ( )
static

◆ platformAlignedAlloc()

void * SSE2NEON::platformAlignedAlloc ( size_t size)

◆ platformAlignedFree()

void SSE2NEON::platformAlignedFree ( void * ptr)

◆ popcnt_reference()

static int SSE2NEON::popcnt_reference ( uint64_t a)
static

◆ ranf() [1/2]

static float SSE2NEON::ranf ( )
static

◆ ranf() [2/2]

static float SSE2NEON::ranf ( float low,
float high )
static

◆ rotr()

static uint32_t SSE2NEON::rotr ( uint32_t value,
uint32_t amount )
inlinestatic

◆ saturate_16()

static int16_t SSE2NEON::saturate_16 ( int32_t a)
inlinestatic

◆ sub_word()

static uint32_t SSE2NEON::sub_word ( uint32_t in)
inlinestatic

◆ test_last()

result_t SSE2NEON::test_last ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_m_maskmovq()

result_t SSE2NEON::test_m_maskmovq ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_m_pavgb()

result_t SSE2NEON::test_m_pavgb ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_m_pavgw()

result_t SSE2NEON::test_m_pavgw ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_m_pextrw()

result_t SSE2NEON::test_m_pextrw ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_m_pinsrw()

result_t SSE2NEON::test_m_pinsrw ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_m_pmaxsw()

result_t SSE2NEON::test_m_pmaxsw ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_m_pmaxub()

result_t SSE2NEON::test_m_pmaxub ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_m_pminsw()

result_t SSE2NEON::test_m_pminsw ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_m_pminub()

result_t SSE2NEON::test_m_pminub ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_m_pmovmskb()

result_t SSE2NEON::test_m_pmovmskb ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_m_pmulhuw()

result_t SSE2NEON::test_m_pmulhuw ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_m_psadbw()

result_t SSE2NEON::test_m_psadbw ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_m_pshufw()

result_t SSE2NEON::test_m_pshufw ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_abs_epi16()

result_t SSE2NEON::test_mm_abs_epi16 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_abs_epi32()

result_t SSE2NEON::test_mm_abs_epi32 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_abs_epi8()

result_t SSE2NEON::test_mm_abs_epi8 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_abs_pi16()

result_t SSE2NEON::test_mm_abs_pi16 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_abs_pi32()

result_t SSE2NEON::test_mm_abs_pi32 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_abs_pi8()

result_t SSE2NEON::test_mm_abs_pi8 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_add_epi16()

result_t SSE2NEON::test_mm_add_epi16 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_add_epi32()

result_t SSE2NEON::test_mm_add_epi32 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_add_epi64()

result_t SSE2NEON::test_mm_add_epi64 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_add_epi8()

result_t SSE2NEON::test_mm_add_epi8 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_add_pd()

result_t SSE2NEON::test_mm_add_pd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_add_ps()

result_t SSE2NEON::test_mm_add_ps ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_add_sd()

result_t SSE2NEON::test_mm_add_sd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_add_si64()

result_t SSE2NEON::test_mm_add_si64 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_add_ss()

result_t SSE2NEON::test_mm_add_ss ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_adds_epi16()

result_t SSE2NEON::test_mm_adds_epi16 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_adds_epi8()

result_t SSE2NEON::test_mm_adds_epi8 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_adds_epu16()

result_t SSE2NEON::test_mm_adds_epu16 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_adds_epu8()

result_t SSE2NEON::test_mm_adds_epu8 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_addsub_pd()

result_t SSE2NEON::test_mm_addsub_pd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_addsub_ps()

result_t SSE2NEON::test_mm_addsub_ps ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_aesdec_si128()

result_t SSE2NEON::test_mm_aesdec_si128 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_aesdeclast_si128()

result_t SSE2NEON::test_mm_aesdeclast_si128 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_aesenc_si128()

result_t SSE2NEON::test_mm_aesenc_si128 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_aesenclast_si128()

result_t SSE2NEON::test_mm_aesenclast_si128 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_aesimc_si128()

result_t SSE2NEON::test_mm_aesimc_si128 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_aeskeygenassist_si128()

result_t SSE2NEON::test_mm_aeskeygenassist_si128 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_alignr_epi8()

result_t SSE2NEON::test_mm_alignr_epi8 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_alignr_pi8()

result_t SSE2NEON::test_mm_alignr_pi8 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_and_pd()

result_t SSE2NEON::test_mm_and_pd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_and_ps()

result_t SSE2NEON::test_mm_and_ps ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_and_si128()

result_t SSE2NEON::test_mm_and_si128 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_andnot_pd()

result_t SSE2NEON::test_mm_andnot_pd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_andnot_ps()

result_t SSE2NEON::test_mm_andnot_ps ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_andnot_si128()

result_t SSE2NEON::test_mm_andnot_si128 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_avg_epu16()

result_t SSE2NEON::test_mm_avg_epu16 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_avg_epu8()

result_t SSE2NEON::test_mm_avg_epu8 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_avg_pu16()

result_t SSE2NEON::test_mm_avg_pu16 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_avg_pu8()

result_t SSE2NEON::test_mm_avg_pu8 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_blend_epi16()

result_t SSE2NEON::test_mm_blend_epi16 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_blend_pd()

result_t SSE2NEON::test_mm_blend_pd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_blend_ps()

result_t SSE2NEON::test_mm_blend_ps ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_blendv_epi8()

result_t SSE2NEON::test_mm_blendv_epi8 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_blendv_pd()

result_t SSE2NEON::test_mm_blendv_pd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_blendv_ps()

result_t SSE2NEON::test_mm_blendv_ps ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_bslli_si128()

result_t SSE2NEON::test_mm_bslli_si128 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_bsrli_si128()

result_t SSE2NEON::test_mm_bsrli_si128 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_castpd_ps()

result_t SSE2NEON::test_mm_castpd_ps ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_castpd_si128()

result_t SSE2NEON::test_mm_castpd_si128 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_castps_pd()

result_t SSE2NEON::test_mm_castps_pd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_castps_si128()

result_t SSE2NEON::test_mm_castps_si128 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_castsi128_pd()

result_t SSE2NEON::test_mm_castsi128_pd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_castsi128_ps()

result_t SSE2NEON::test_mm_castsi128_ps ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_ceil_pd()

result_t SSE2NEON::test_mm_ceil_pd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_ceil_ps()

result_t SSE2NEON::test_mm_ceil_ps ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_ceil_sd()

result_t SSE2NEON::test_mm_ceil_sd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_ceil_ss()

result_t SSE2NEON::test_mm_ceil_ss ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_clflush()

result_t SSE2NEON::test_mm_clflush ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_clmulepi64_si128()

result_t SSE2NEON::test_mm_clmulepi64_si128 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cmpeq_epi16()

result_t SSE2NEON::test_mm_cmpeq_epi16 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cmpeq_epi32()

result_t SSE2NEON::test_mm_cmpeq_epi32 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cmpeq_epi64()

result_t SSE2NEON::test_mm_cmpeq_epi64 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cmpeq_epi8()

result_t SSE2NEON::test_mm_cmpeq_epi8 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cmpeq_pd()

result_t SSE2NEON::test_mm_cmpeq_pd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cmpeq_ps()

result_t SSE2NEON::test_mm_cmpeq_ps ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cmpeq_sd()

result_t SSE2NEON::test_mm_cmpeq_sd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cmpeq_ss()

result_t SSE2NEON::test_mm_cmpeq_ss ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cmpestra()

result_t SSE2NEON::test_mm_cmpestra ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cmpestrc()

result_t SSE2NEON::test_mm_cmpestrc ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cmpestri()

result_t SSE2NEON::test_mm_cmpestri ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cmpestrm()

result_t SSE2NEON::test_mm_cmpestrm ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cmpestro()

result_t SSE2NEON::test_mm_cmpestro ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cmpestrs()

result_t SSE2NEON::test_mm_cmpestrs ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cmpestrz()

result_t SSE2NEON::test_mm_cmpestrz ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cmpge_pd()

result_t SSE2NEON::test_mm_cmpge_pd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cmpge_ps()

result_t SSE2NEON::test_mm_cmpge_ps ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cmpge_sd()

result_t SSE2NEON::test_mm_cmpge_sd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cmpge_ss()

result_t SSE2NEON::test_mm_cmpge_ss ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cmpgt_epi16()

result_t SSE2NEON::test_mm_cmpgt_epi16 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cmpgt_epi32()

result_t SSE2NEON::test_mm_cmpgt_epi32 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cmpgt_epi64()

result_t SSE2NEON::test_mm_cmpgt_epi64 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cmpgt_epi8()

result_t SSE2NEON::test_mm_cmpgt_epi8 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cmpgt_pd()

result_t SSE2NEON::test_mm_cmpgt_pd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cmpgt_ps()

result_t SSE2NEON::test_mm_cmpgt_ps ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cmpgt_sd()

result_t SSE2NEON::test_mm_cmpgt_sd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cmpgt_ss()

result_t SSE2NEON::test_mm_cmpgt_ss ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cmpistra()

result_t SSE2NEON::test_mm_cmpistra ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cmpistrc()

result_t SSE2NEON::test_mm_cmpistrc ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cmpistri()

result_t SSE2NEON::test_mm_cmpistri ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cmpistrm()

result_t SSE2NEON::test_mm_cmpistrm ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cmpistro()

result_t SSE2NEON::test_mm_cmpistro ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cmpistrs()

result_t SSE2NEON::test_mm_cmpistrs ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cmpistrz()

result_t SSE2NEON::test_mm_cmpistrz ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cmple_pd()

result_t SSE2NEON::test_mm_cmple_pd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cmple_ps()

result_t SSE2NEON::test_mm_cmple_ps ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cmple_sd()

result_t SSE2NEON::test_mm_cmple_sd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cmple_ss()

result_t SSE2NEON::test_mm_cmple_ss ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cmplt_epi16()

result_t SSE2NEON::test_mm_cmplt_epi16 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cmplt_epi32()

result_t SSE2NEON::test_mm_cmplt_epi32 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cmplt_epi8()

result_t SSE2NEON::test_mm_cmplt_epi8 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cmplt_pd()

result_t SSE2NEON::test_mm_cmplt_pd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cmplt_ps()

result_t SSE2NEON::test_mm_cmplt_ps ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cmplt_sd()

result_t SSE2NEON::test_mm_cmplt_sd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cmplt_ss()

result_t SSE2NEON::test_mm_cmplt_ss ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cmpneq_pd()

result_t SSE2NEON::test_mm_cmpneq_pd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cmpneq_ps()

result_t SSE2NEON::test_mm_cmpneq_ps ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cmpneq_sd()

result_t SSE2NEON::test_mm_cmpneq_sd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cmpneq_ss()

result_t SSE2NEON::test_mm_cmpneq_ss ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cmpnge_pd()

result_t SSE2NEON::test_mm_cmpnge_pd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cmpnge_ps()

result_t SSE2NEON::test_mm_cmpnge_ps ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cmpnge_sd()

result_t SSE2NEON::test_mm_cmpnge_sd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cmpnge_ss()

result_t SSE2NEON::test_mm_cmpnge_ss ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cmpngt_pd()

result_t SSE2NEON::test_mm_cmpngt_pd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cmpngt_ps()

result_t SSE2NEON::test_mm_cmpngt_ps ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cmpngt_sd()

result_t SSE2NEON::test_mm_cmpngt_sd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cmpngt_ss()

result_t SSE2NEON::test_mm_cmpngt_ss ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cmpnle_pd()

result_t SSE2NEON::test_mm_cmpnle_pd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cmpnle_ps()

result_t SSE2NEON::test_mm_cmpnle_ps ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cmpnle_sd()

result_t SSE2NEON::test_mm_cmpnle_sd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cmpnle_ss()

result_t SSE2NEON::test_mm_cmpnle_ss ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cmpnlt_pd()

result_t SSE2NEON::test_mm_cmpnlt_pd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cmpnlt_ps()

result_t SSE2NEON::test_mm_cmpnlt_ps ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cmpnlt_sd()

result_t SSE2NEON::test_mm_cmpnlt_sd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cmpnlt_ss()

result_t SSE2NEON::test_mm_cmpnlt_ss ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cmpord_pd()

result_t SSE2NEON::test_mm_cmpord_pd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cmpord_ps()

result_t SSE2NEON::test_mm_cmpord_ps ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cmpord_sd()

result_t SSE2NEON::test_mm_cmpord_sd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cmpord_ss()

result_t SSE2NEON::test_mm_cmpord_ss ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cmpunord_pd()

result_t SSE2NEON::test_mm_cmpunord_pd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cmpunord_ps()

result_t SSE2NEON::test_mm_cmpunord_ps ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cmpunord_sd()

result_t SSE2NEON::test_mm_cmpunord_sd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cmpunord_ss()

result_t SSE2NEON::test_mm_cmpunord_ss ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_comieq_sd()

result_t SSE2NEON::test_mm_comieq_sd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_comieq_ss()

result_t SSE2NEON::test_mm_comieq_ss ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_comige_sd()

result_t SSE2NEON::test_mm_comige_sd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_comige_ss()

result_t SSE2NEON::test_mm_comige_ss ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_comigt_sd()

result_t SSE2NEON::test_mm_comigt_sd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_comigt_ss()

result_t SSE2NEON::test_mm_comigt_ss ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_comile_sd()

result_t SSE2NEON::test_mm_comile_sd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_comile_ss()

result_t SSE2NEON::test_mm_comile_ss ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_comilt_sd()

result_t SSE2NEON::test_mm_comilt_sd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_comilt_ss()

result_t SSE2NEON::test_mm_comilt_ss ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_comineq_sd()

result_t SSE2NEON::test_mm_comineq_sd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_comineq_ss()

result_t SSE2NEON::test_mm_comineq_ss ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_crc32_u16()

result_t SSE2NEON::test_mm_crc32_u16 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_crc32_u32()

result_t SSE2NEON::test_mm_crc32_u32 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_crc32_u64()

result_t SSE2NEON::test_mm_crc32_u64 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_crc32_u8()

result_t SSE2NEON::test_mm_crc32_u8 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cvt_pi2ps()

result_t SSE2NEON::test_mm_cvt_pi2ps ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cvt_ps2pi()

result_t SSE2NEON::test_mm_cvt_ps2pi ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cvt_si2ss()

result_t SSE2NEON::test_mm_cvt_si2ss ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cvt_ss2si()

result_t SSE2NEON::test_mm_cvt_ss2si ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cvtepi16_epi32()

result_t SSE2NEON::test_mm_cvtepi16_epi32 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cvtepi16_epi64()

result_t SSE2NEON::test_mm_cvtepi16_epi64 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cvtepi32_epi64()

result_t SSE2NEON::test_mm_cvtepi32_epi64 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cvtepi32_pd()

result_t SSE2NEON::test_mm_cvtepi32_pd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cvtepi32_ps()

result_t SSE2NEON::test_mm_cvtepi32_ps ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cvtepi8_epi16()

result_t SSE2NEON::test_mm_cvtepi8_epi16 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cvtepi8_epi32()

result_t SSE2NEON::test_mm_cvtepi8_epi32 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cvtepi8_epi64()

result_t SSE2NEON::test_mm_cvtepi8_epi64 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cvtepu16_epi32()

result_t SSE2NEON::test_mm_cvtepu16_epi32 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cvtepu16_epi64()

result_t SSE2NEON::test_mm_cvtepu16_epi64 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cvtepu32_epi64()

result_t SSE2NEON::test_mm_cvtepu32_epi64 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cvtepu8_epi16()

result_t SSE2NEON::test_mm_cvtepu8_epi16 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cvtepu8_epi32()

result_t SSE2NEON::test_mm_cvtepu8_epi32 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cvtepu8_epi64()

result_t SSE2NEON::test_mm_cvtepu8_epi64 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cvtpd_epi32()

result_t SSE2NEON::test_mm_cvtpd_epi32 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cvtpd_pi32()

result_t SSE2NEON::test_mm_cvtpd_pi32 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cvtpd_ps()

result_t SSE2NEON::test_mm_cvtpd_ps ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cvtpi16_ps()

result_t SSE2NEON::test_mm_cvtpi16_ps ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cvtpi32_pd()

result_t SSE2NEON::test_mm_cvtpi32_pd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cvtpi32_ps()

result_t SSE2NEON::test_mm_cvtpi32_ps ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cvtpi32x2_ps()

result_t SSE2NEON::test_mm_cvtpi32x2_ps ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cvtpi8_ps()

result_t SSE2NEON::test_mm_cvtpi8_ps ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cvtps_epi32()

result_t SSE2NEON::test_mm_cvtps_epi32 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cvtps_pd()

result_t SSE2NEON::test_mm_cvtps_pd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cvtps_pi16()

result_t SSE2NEON::test_mm_cvtps_pi16 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cvtps_pi32()

result_t SSE2NEON::test_mm_cvtps_pi32 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cvtps_pi8()

result_t SSE2NEON::test_mm_cvtps_pi8 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cvtpu16_ps()

result_t SSE2NEON::test_mm_cvtpu16_ps ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cvtpu8_ps()

result_t SSE2NEON::test_mm_cvtpu8_ps ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cvtsd_f64()

result_t SSE2NEON::test_mm_cvtsd_f64 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cvtsd_si32()

result_t SSE2NEON::test_mm_cvtsd_si32 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cvtsd_si64()

result_t SSE2NEON::test_mm_cvtsd_si64 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cvtsd_si64x()

result_t SSE2NEON::test_mm_cvtsd_si64x ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cvtsd_ss()

result_t SSE2NEON::test_mm_cvtsd_ss ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cvtsi128_si32()

result_t SSE2NEON::test_mm_cvtsi128_si32 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cvtsi128_si64()

result_t SSE2NEON::test_mm_cvtsi128_si64 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cvtsi128_si64x()

result_t SSE2NEON::test_mm_cvtsi128_si64x ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cvtsi32_sd()

result_t SSE2NEON::test_mm_cvtsi32_sd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cvtsi32_si128()

result_t SSE2NEON::test_mm_cvtsi32_si128 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cvtsi32_ss()

result_t SSE2NEON::test_mm_cvtsi32_ss ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cvtsi64_sd()

result_t SSE2NEON::test_mm_cvtsi64_sd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cvtsi64_si128()

result_t SSE2NEON::test_mm_cvtsi64_si128 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cvtsi64_ss()

result_t SSE2NEON::test_mm_cvtsi64_ss ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cvtsi64x_sd()

result_t SSE2NEON::test_mm_cvtsi64x_sd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cvtsi64x_si128()

result_t SSE2NEON::test_mm_cvtsi64x_si128 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cvtss_f32()

result_t SSE2NEON::test_mm_cvtss_f32 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cvtss_sd()

result_t SSE2NEON::test_mm_cvtss_sd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cvtss_si32()

result_t SSE2NEON::test_mm_cvtss_si32 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cvtss_si64()

result_t SSE2NEON::test_mm_cvtss_si64 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cvtt_ps2pi()

result_t SSE2NEON::test_mm_cvtt_ps2pi ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cvtt_ss2si()

result_t SSE2NEON::test_mm_cvtt_ss2si ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cvttpd_epi32()

result_t SSE2NEON::test_mm_cvttpd_epi32 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cvttpd_pi32()

result_t SSE2NEON::test_mm_cvttpd_pi32 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cvttps_epi32()

result_t SSE2NEON::test_mm_cvttps_epi32 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cvttps_pi32()

result_t SSE2NEON::test_mm_cvttps_pi32 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cvttsd_si32()

result_t SSE2NEON::test_mm_cvttsd_si32 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cvttsd_si64()

result_t SSE2NEON::test_mm_cvttsd_si64 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cvttsd_si64x()

result_t SSE2NEON::test_mm_cvttsd_si64x ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cvttss_si32()

result_t SSE2NEON::test_mm_cvttss_si32 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_cvttss_si64()

result_t SSE2NEON::test_mm_cvttss_si64 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_div_pd()

result_t SSE2NEON::test_mm_div_pd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_div_ps()

result_t SSE2NEON::test_mm_div_ps ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_div_sd()

result_t SSE2NEON::test_mm_div_sd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_div_ss()

result_t SSE2NEON::test_mm_div_ss ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_dp_pd()

result_t SSE2NEON::test_mm_dp_pd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_dp_ps()

result_t SSE2NEON::test_mm_dp_ps ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_empty()

result_t SSE2NEON::test_mm_empty ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_extract_epi16()

result_t SSE2NEON::test_mm_extract_epi16 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_extract_epi32()

result_t SSE2NEON::test_mm_extract_epi32 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_extract_epi64()

result_t SSE2NEON::test_mm_extract_epi64 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_extract_epi8()

result_t SSE2NEON::test_mm_extract_epi8 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_extract_pi16()

result_t SSE2NEON::test_mm_extract_pi16 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_extract_ps()

result_t SSE2NEON::test_mm_extract_ps ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_floor_pd()

result_t SSE2NEON::test_mm_floor_pd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_floor_ps()

result_t SSE2NEON::test_mm_floor_ps ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_floor_sd()

result_t SSE2NEON::test_mm_floor_sd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_floor_ss()

result_t SSE2NEON::test_mm_floor_ss ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_free()

result_t SSE2NEON::test_mm_free ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_get_denormals_zero_mode()

result_t SSE2NEON::test_mm_get_denormals_zero_mode ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_get_flush_zero_mode()

result_t SSE2NEON::test_mm_get_flush_zero_mode ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_get_rounding_mode()

result_t SSE2NEON::test_mm_get_rounding_mode ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_getcsr()

result_t SSE2NEON::test_mm_getcsr ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_hadd_epi16()

result_t SSE2NEON::test_mm_hadd_epi16 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_hadd_epi32()

result_t SSE2NEON::test_mm_hadd_epi32 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_hadd_pd()

result_t SSE2NEON::test_mm_hadd_pd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_hadd_pi16()

result_t SSE2NEON::test_mm_hadd_pi16 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_hadd_pi32()

result_t SSE2NEON::test_mm_hadd_pi32 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_hadd_ps()

result_t SSE2NEON::test_mm_hadd_ps ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_hadds_epi16()

result_t SSE2NEON::test_mm_hadds_epi16 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_hadds_pi16()

result_t SSE2NEON::test_mm_hadds_pi16 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_hsub_epi16()

result_t SSE2NEON::test_mm_hsub_epi16 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_hsub_epi32()

result_t SSE2NEON::test_mm_hsub_epi32 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_hsub_pd()

result_t SSE2NEON::test_mm_hsub_pd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_hsub_pi16()

result_t SSE2NEON::test_mm_hsub_pi16 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_hsub_pi32()

result_t SSE2NEON::test_mm_hsub_pi32 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_hsub_ps()

result_t SSE2NEON::test_mm_hsub_ps ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_hsubs_epi16()

result_t SSE2NEON::test_mm_hsubs_epi16 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_hsubs_pi16()

result_t SSE2NEON::test_mm_hsubs_pi16 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_insert_epi16()

result_t SSE2NEON::test_mm_insert_epi16 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_insert_epi32()

result_t SSE2NEON::test_mm_insert_epi32 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_insert_epi64()

result_t SSE2NEON::test_mm_insert_epi64 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_insert_epi8()

result_t SSE2NEON::test_mm_insert_epi8 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_insert_pi16()

result_t SSE2NEON::test_mm_insert_pi16 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_insert_ps()

result_t SSE2NEON::test_mm_insert_ps ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_lddqu_si128()

result_t SSE2NEON::test_mm_lddqu_si128 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_lfence()

result_t SSE2NEON::test_mm_lfence ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_load1_pd()

result_t SSE2NEON::test_mm_load1_pd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_load1_ps()

result_t SSE2NEON::test_mm_load1_ps ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_load_pd()

result_t SSE2NEON::test_mm_load_pd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_load_pd1()

result_t SSE2NEON::test_mm_load_pd1 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_load_ps()

result_t SSE2NEON::test_mm_load_ps ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_load_ps1()

result_t SSE2NEON::test_mm_load_ps1 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_load_sd()

result_t SSE2NEON::test_mm_load_sd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_load_si128()

result_t SSE2NEON::test_mm_load_si128 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_load_ss()

result_t SSE2NEON::test_mm_load_ss ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_loaddup_pd()

result_t SSE2NEON::test_mm_loaddup_pd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_loadh_pd()

result_t SSE2NEON::test_mm_loadh_pd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_loadh_pi()

result_t SSE2NEON::test_mm_loadh_pi ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_loadl_epi64()

result_t SSE2NEON::test_mm_loadl_epi64 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_loadl_pd()

result_t SSE2NEON::test_mm_loadl_pd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_loadl_pi()

result_t SSE2NEON::test_mm_loadl_pi ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_loadr_pd()

result_t SSE2NEON::test_mm_loadr_pd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_loadr_ps()

result_t SSE2NEON::test_mm_loadr_ps ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_loadu_pd()

result_t SSE2NEON::test_mm_loadu_pd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_loadu_ps()

result_t SSE2NEON::test_mm_loadu_ps ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_loadu_si128()

result_t SSE2NEON::test_mm_loadu_si128 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_loadu_si16()

result_t SSE2NEON::test_mm_loadu_si16 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_loadu_si32()

result_t SSE2NEON::test_mm_loadu_si32 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_loadu_si64()

result_t SSE2NEON::test_mm_loadu_si64 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_madd_epi16()

result_t SSE2NEON::test_mm_madd_epi16 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_maddubs_epi16()

result_t SSE2NEON::test_mm_maddubs_epi16 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_maddubs_pi16()

result_t SSE2NEON::test_mm_maddubs_pi16 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_malloc()

result_t SSE2NEON::test_mm_malloc ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_maskmove_si64()

result_t SSE2NEON::test_mm_maskmove_si64 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_maskmoveu_si128()

result_t SSE2NEON::test_mm_maskmoveu_si128 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_max_epi16()

result_t SSE2NEON::test_mm_max_epi16 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_max_epi32()

result_t SSE2NEON::test_mm_max_epi32 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_max_epi8()

result_t SSE2NEON::test_mm_max_epi8 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_max_epu16()

result_t SSE2NEON::test_mm_max_epu16 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_max_epu32()

result_t SSE2NEON::test_mm_max_epu32 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_max_epu8()

result_t SSE2NEON::test_mm_max_epu8 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_max_pd()

result_t SSE2NEON::test_mm_max_pd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_max_pi16()

result_t SSE2NEON::test_mm_max_pi16 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_max_ps()

result_t SSE2NEON::test_mm_max_ps ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_max_pu8()

result_t SSE2NEON::test_mm_max_pu8 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_max_sd()

result_t SSE2NEON::test_mm_max_sd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_max_ss()

result_t SSE2NEON::test_mm_max_ss ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_mfence()

result_t SSE2NEON::test_mm_mfence ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_min_epi16()

result_t SSE2NEON::test_mm_min_epi16 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_min_epi32()

result_t SSE2NEON::test_mm_min_epi32 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_min_epi8()

result_t SSE2NEON::test_mm_min_epi8 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_min_epu16()

result_t SSE2NEON::test_mm_min_epu16 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_min_epu32()

result_t SSE2NEON::test_mm_min_epu32 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_min_epu8()

result_t SSE2NEON::test_mm_min_epu8 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_min_pd()

result_t SSE2NEON::test_mm_min_pd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_min_pi16()

result_t SSE2NEON::test_mm_min_pi16 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_min_ps()

result_t SSE2NEON::test_mm_min_ps ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_min_pu8()

result_t SSE2NEON::test_mm_min_pu8 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_min_sd()

result_t SSE2NEON::test_mm_min_sd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_min_ss()

result_t SSE2NEON::test_mm_min_ss ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_minpos_epu16()

result_t SSE2NEON::test_mm_minpos_epu16 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_move_epi64()

result_t SSE2NEON::test_mm_move_epi64 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_move_sd()

result_t SSE2NEON::test_mm_move_sd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_move_ss()

result_t SSE2NEON::test_mm_move_ss ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_movedup_pd()

result_t SSE2NEON::test_mm_movedup_pd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_movehdup_ps()

result_t SSE2NEON::test_mm_movehdup_ps ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_movehl_ps()

result_t SSE2NEON::test_mm_movehl_ps ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_moveldup_ps()

result_t SSE2NEON::test_mm_moveldup_ps ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_movelh_ps()

result_t SSE2NEON::test_mm_movelh_ps ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_movemask_epi8()

result_t SSE2NEON::test_mm_movemask_epi8 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_movemask_pd()

result_t SSE2NEON::test_mm_movemask_pd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_movemask_pi8()

result_t SSE2NEON::test_mm_movemask_pi8 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_movemask_ps()

result_t SSE2NEON::test_mm_movemask_ps ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_movepi64_pi64()

result_t SSE2NEON::test_mm_movepi64_pi64 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_movpi64_epi64()

result_t SSE2NEON::test_mm_movpi64_epi64 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_mpsadbw_epu8()

result_t SSE2NEON::test_mm_mpsadbw_epu8 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_mul_epi32()

result_t SSE2NEON::test_mm_mul_epi32 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_mul_epu32()

result_t SSE2NEON::test_mm_mul_epu32 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_mul_pd()

result_t SSE2NEON::test_mm_mul_pd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_mul_ps()

result_t SSE2NEON::test_mm_mul_ps ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_mul_sd()

result_t SSE2NEON::test_mm_mul_sd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_mul_ss()

result_t SSE2NEON::test_mm_mul_ss ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_mul_su32()

result_t SSE2NEON::test_mm_mul_su32 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_mulhi_epi16()

result_t SSE2NEON::test_mm_mulhi_epi16 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_mulhi_epu16()

result_t SSE2NEON::test_mm_mulhi_epu16 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_mulhi_pu16()

result_t SSE2NEON::test_mm_mulhi_pu16 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_mulhrs_epi16()

result_t SSE2NEON::test_mm_mulhrs_epi16 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_mulhrs_pi16()

result_t SSE2NEON::test_mm_mulhrs_pi16 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_mullo_epi16()

result_t SSE2NEON::test_mm_mullo_epi16 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_mullo_epi32()

result_t SSE2NEON::test_mm_mullo_epi32 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_or_pd()

result_t SSE2NEON::test_mm_or_pd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_or_ps()

result_t SSE2NEON::test_mm_or_ps ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_or_si128()

result_t SSE2NEON::test_mm_or_si128 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_packs_epi16()

result_t SSE2NEON::test_mm_packs_epi16 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_packs_epi32()

result_t SSE2NEON::test_mm_packs_epi32 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_packus_epi16()

result_t SSE2NEON::test_mm_packus_epi16 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_packus_epi32()

result_t SSE2NEON::test_mm_packus_epi32 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_pause()

result_t SSE2NEON::test_mm_pause ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_popcnt_u32()

result_t SSE2NEON::test_mm_popcnt_u32 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_popcnt_u64()

result_t SSE2NEON::test_mm_popcnt_u64 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_prefetch()

result_t SSE2NEON::test_mm_prefetch ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_rcp_ps()

result_t SSE2NEON::test_mm_rcp_ps ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_rcp_ss()

result_t SSE2NEON::test_mm_rcp_ss ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_round_pd()

result_t SSE2NEON::test_mm_round_pd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_round_ps()

result_t SSE2NEON::test_mm_round_ps ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_round_sd()

result_t SSE2NEON::test_mm_round_sd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_round_ss()

result_t SSE2NEON::test_mm_round_ss ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_rsqrt_ps()

result_t SSE2NEON::test_mm_rsqrt_ps ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_rsqrt_ss()

result_t SSE2NEON::test_mm_rsqrt_ss ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_sad_epu8()

result_t SSE2NEON::test_mm_sad_epu8 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_sad_pu8()

result_t SSE2NEON::test_mm_sad_pu8 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_set1_epi16()

result_t SSE2NEON::test_mm_set1_epi16 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_set1_epi32()

result_t SSE2NEON::test_mm_set1_epi32 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_set1_epi64()

result_t SSE2NEON::test_mm_set1_epi64 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_set1_epi64x()

result_t SSE2NEON::test_mm_set1_epi64x ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_set1_epi8()

result_t SSE2NEON::test_mm_set1_epi8 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_set1_pd()

result_t SSE2NEON::test_mm_set1_pd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_set1_ps()

result_t SSE2NEON::test_mm_set1_ps ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_set_denormals_zero_mode()

result_t SSE2NEON::test_mm_set_denormals_zero_mode ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_set_epi16()

result_t SSE2NEON::test_mm_set_epi16 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_set_epi32()

result_t SSE2NEON::test_mm_set_epi32 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_set_epi64()

result_t SSE2NEON::test_mm_set_epi64 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_set_epi64x()

result_t SSE2NEON::test_mm_set_epi64x ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_set_epi8()

result_t SSE2NEON::test_mm_set_epi8 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_set_flush_zero_mode()

result_t SSE2NEON::test_mm_set_flush_zero_mode ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_set_pd()

result_t SSE2NEON::test_mm_set_pd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_set_pd1()

result_t SSE2NEON::test_mm_set_pd1 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_set_ps()

result_t SSE2NEON::test_mm_set_ps ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_set_ps1()

result_t SSE2NEON::test_mm_set_ps1 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_set_rounding_mode()

result_t SSE2NEON::test_mm_set_rounding_mode ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_set_sd()

result_t SSE2NEON::test_mm_set_sd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_set_ss()

result_t SSE2NEON::test_mm_set_ss ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_setcsr()

result_t SSE2NEON::test_mm_setcsr ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_setr_epi16()

result_t SSE2NEON::test_mm_setr_epi16 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_setr_epi32()

result_t SSE2NEON::test_mm_setr_epi32 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_setr_epi64()

result_t SSE2NEON::test_mm_setr_epi64 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_setr_epi8()

result_t SSE2NEON::test_mm_setr_epi8 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_setr_pd()

result_t SSE2NEON::test_mm_setr_pd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_setr_ps()

result_t SSE2NEON::test_mm_setr_ps ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_setzero_pd()

result_t SSE2NEON::test_mm_setzero_pd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_setzero_ps()

result_t SSE2NEON::test_mm_setzero_ps ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_setzero_si128()

result_t SSE2NEON::test_mm_setzero_si128 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_sfence()

result_t SSE2NEON::test_mm_sfence ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_shuffle_epi32()

result_t SSE2NEON::test_mm_shuffle_epi32 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_shuffle_epi8()

result_t SSE2NEON::test_mm_shuffle_epi8 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_shuffle_pd()

result_t SSE2NEON::test_mm_shuffle_pd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_shuffle_pi16()

result_t SSE2NEON::test_mm_shuffle_pi16 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_shuffle_pi8()

result_t SSE2NEON::test_mm_shuffle_pi8 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_shuffle_ps()

result_t SSE2NEON::test_mm_shuffle_ps ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_shufflehi_epi16()

result_t SSE2NEON::test_mm_shufflehi_epi16 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_shufflelo_epi16()

result_t SSE2NEON::test_mm_shufflelo_epi16 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_sign_epi16()

result_t SSE2NEON::test_mm_sign_epi16 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_sign_epi32()

result_t SSE2NEON::test_mm_sign_epi32 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_sign_epi8()

result_t SSE2NEON::test_mm_sign_epi8 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_sign_pi16()

result_t SSE2NEON::test_mm_sign_pi16 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_sign_pi32()

result_t SSE2NEON::test_mm_sign_pi32 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_sign_pi8()

result_t SSE2NEON::test_mm_sign_pi8 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_sll_epi16()

result_t SSE2NEON::test_mm_sll_epi16 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_sll_epi32()

result_t SSE2NEON::test_mm_sll_epi32 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_sll_epi64()

result_t SSE2NEON::test_mm_sll_epi64 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_slli_epi16()

result_t SSE2NEON::test_mm_slli_epi16 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_slli_epi32()

result_t SSE2NEON::test_mm_slli_epi32 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_slli_epi64()

result_t SSE2NEON::test_mm_slli_epi64 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_slli_si128()

result_t SSE2NEON::test_mm_slli_si128 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_sqrt_pd()

result_t SSE2NEON::test_mm_sqrt_pd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_sqrt_ps()

result_t SSE2NEON::test_mm_sqrt_ps ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_sqrt_sd()

result_t SSE2NEON::test_mm_sqrt_sd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_sqrt_ss()

result_t SSE2NEON::test_mm_sqrt_ss ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_sra_epi16()

result_t SSE2NEON::test_mm_sra_epi16 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_sra_epi32()

result_t SSE2NEON::test_mm_sra_epi32 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_srai_epi16()

result_t SSE2NEON::test_mm_srai_epi16 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_srai_epi32()

result_t SSE2NEON::test_mm_srai_epi32 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_srl_epi16()

result_t SSE2NEON::test_mm_srl_epi16 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_srl_epi32()

result_t SSE2NEON::test_mm_srl_epi32 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_srl_epi64()

result_t SSE2NEON::test_mm_srl_epi64 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_srli_epi16()

result_t SSE2NEON::test_mm_srli_epi16 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_srli_epi32()

result_t SSE2NEON::test_mm_srli_epi32 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_srli_epi64()

result_t SSE2NEON::test_mm_srli_epi64 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_srli_si128()

result_t SSE2NEON::test_mm_srli_si128 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_store1_pd()

result_t SSE2NEON::test_mm_store1_pd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_store1_ps()

result_t SSE2NEON::test_mm_store1_ps ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_store_pd()

result_t SSE2NEON::test_mm_store_pd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_store_pd1()

result_t SSE2NEON::test_mm_store_pd1 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_store_ps()

result_t SSE2NEON::test_mm_store_ps ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_store_ps1()

result_t SSE2NEON::test_mm_store_ps1 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_store_sd()

result_t SSE2NEON::test_mm_store_sd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_store_si128()

result_t SSE2NEON::test_mm_store_si128 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_store_ss()

result_t SSE2NEON::test_mm_store_ss ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_storeh_pd()

result_t SSE2NEON::test_mm_storeh_pd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_storeh_pi()

result_t SSE2NEON::test_mm_storeh_pi ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_storel_epi64()

result_t SSE2NEON::test_mm_storel_epi64 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_storel_pd()

result_t SSE2NEON::test_mm_storel_pd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_storel_pi()

result_t SSE2NEON::test_mm_storel_pi ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_storer_pd()

result_t SSE2NEON::test_mm_storer_pd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_storer_ps()

result_t SSE2NEON::test_mm_storer_ps ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_storeu_pd()

result_t SSE2NEON::test_mm_storeu_pd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_storeu_ps()

result_t SSE2NEON::test_mm_storeu_ps ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_storeu_si128()

result_t SSE2NEON::test_mm_storeu_si128 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_storeu_si16()

result_t SSE2NEON::test_mm_storeu_si16 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_storeu_si32()

result_t SSE2NEON::test_mm_storeu_si32 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_storeu_si64()

result_t SSE2NEON::test_mm_storeu_si64 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_stream_load_si128()

result_t SSE2NEON::test_mm_stream_load_si128 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_stream_pd()

result_t SSE2NEON::test_mm_stream_pd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_stream_pi()

result_t SSE2NEON::test_mm_stream_pi ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_stream_ps()

result_t SSE2NEON::test_mm_stream_ps ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_stream_si128()

result_t SSE2NEON::test_mm_stream_si128 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_stream_si32()

result_t SSE2NEON::test_mm_stream_si32 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_stream_si64()

result_t SSE2NEON::test_mm_stream_si64 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_sub_epi16()

result_t SSE2NEON::test_mm_sub_epi16 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_sub_epi32()

result_t SSE2NEON::test_mm_sub_epi32 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_sub_epi64()

result_t SSE2NEON::test_mm_sub_epi64 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_sub_epi8()

result_t SSE2NEON::test_mm_sub_epi8 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_sub_pd()

result_t SSE2NEON::test_mm_sub_pd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_sub_ps()

result_t SSE2NEON::test_mm_sub_ps ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_sub_sd()

result_t SSE2NEON::test_mm_sub_sd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_sub_si64()

result_t SSE2NEON::test_mm_sub_si64 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_sub_ss()

result_t SSE2NEON::test_mm_sub_ss ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_subs_epi16()

result_t SSE2NEON::test_mm_subs_epi16 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_subs_epi8()

result_t SSE2NEON::test_mm_subs_epi8 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_subs_epu16()

result_t SSE2NEON::test_mm_subs_epu16 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_subs_epu8()

result_t SSE2NEON::test_mm_subs_epu8 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_test_all_ones()

result_t SSE2NEON::test_mm_test_all_ones ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_test_all_zeros()

result_t SSE2NEON::test_mm_test_all_zeros ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_test_mix_ones_zeros()

result_t SSE2NEON::test_mm_test_mix_ones_zeros ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_testc_si128()

result_t SSE2NEON::test_mm_testc_si128 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_testnzc_si128()

result_t SSE2NEON::test_mm_testnzc_si128 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_testz_si128()

result_t SSE2NEON::test_mm_testz_si128 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_ucomieq_sd()

result_t SSE2NEON::test_mm_ucomieq_sd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_ucomieq_ss()

result_t SSE2NEON::test_mm_ucomieq_ss ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_ucomige_sd()

result_t SSE2NEON::test_mm_ucomige_sd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_ucomige_ss()

result_t SSE2NEON::test_mm_ucomige_ss ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_ucomigt_sd()

result_t SSE2NEON::test_mm_ucomigt_sd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_ucomigt_ss()

result_t SSE2NEON::test_mm_ucomigt_ss ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_ucomile_sd()

result_t SSE2NEON::test_mm_ucomile_sd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_ucomile_ss()

result_t SSE2NEON::test_mm_ucomile_ss ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_ucomilt_sd()

result_t SSE2NEON::test_mm_ucomilt_sd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_ucomilt_ss()

result_t SSE2NEON::test_mm_ucomilt_ss ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_ucomineq_sd()

result_t SSE2NEON::test_mm_ucomineq_sd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_ucomineq_ss()

result_t SSE2NEON::test_mm_ucomineq_ss ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_undefined_pd()

result_t SSE2NEON::test_mm_undefined_pd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_undefined_ps()

result_t SSE2NEON::test_mm_undefined_ps ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_undefined_si128()

result_t SSE2NEON::test_mm_undefined_si128 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_unpackhi_epi16()

result_t SSE2NEON::test_mm_unpackhi_epi16 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_unpackhi_epi32()

result_t SSE2NEON::test_mm_unpackhi_epi32 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_unpackhi_epi64()

result_t SSE2NEON::test_mm_unpackhi_epi64 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_unpackhi_epi8()

result_t SSE2NEON::test_mm_unpackhi_epi8 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_unpackhi_pd()

result_t SSE2NEON::test_mm_unpackhi_pd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_unpackhi_ps()

result_t SSE2NEON::test_mm_unpackhi_ps ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_unpacklo_epi16()

result_t SSE2NEON::test_mm_unpacklo_epi16 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_unpacklo_epi32()

result_t SSE2NEON::test_mm_unpacklo_epi32 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_unpacklo_epi64()

result_t SSE2NEON::test_mm_unpacklo_epi64 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_unpacklo_epi8()

result_t SSE2NEON::test_mm_unpacklo_epi8 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_unpacklo_pd()

result_t SSE2NEON::test_mm_unpacklo_pd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_unpacklo_ps()

result_t SSE2NEON::test_mm_unpacklo_ps ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_xor_pd()

result_t SSE2NEON::test_mm_xor_pd ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_xor_ps()

result_t SSE2NEON::test_mm_xor_ps ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_mm_xor_si128()

result_t SSE2NEON::test_mm_xor_si128 ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ test_rdtsc()

result_t SSE2NEON::test_rdtsc ( const SSE2NEONTestImpl & impl,
uint32_t iter )

◆ validate128()

template<typename T >
result_t SSE2NEON::validate128 ( T a,
T b )

◆ validateDouble()

result_t SSE2NEON::validateDouble ( __m128d a,
double d0,
double d1 )

◆ validateFloat()

result_t SSE2NEON::validateFloat ( __m128 a,
float f0,
float f1,
float f2,
float f3 )

◆ validateFloatEpsilon()

result_t SSE2NEON::validateFloatEpsilon ( __m128 a,
float f0,
float f1,
float f2,
float f3,
float epsilon )

◆ validateFloatError() [1/2]

result_t SSE2NEON::validateFloatError ( __m128 a,
float f0,
float f1,
float f2,
float f3,
float err )

◆ validateFloatError() [2/2]

result_t SSE2NEON::validateFloatError ( __m128d a,
double d0,
double d1,
double err )

◆ validateInt16() [1/2]

result_t SSE2NEON::validateInt16 ( __m128i a,
int16_t i0,
int16_t i1,
int16_t i2,
int16_t i3,
int16_t i4,
int16_t i5,
int16_t i6,
int16_t i7 )

◆ validateInt16() [2/2]

result_t SSE2NEON::validateInt16 ( __m64 a,
int16_t i0,
int16_t i1,
int16_t i2,
int16_t i3 )

◆ validateInt32() [1/2]

result_t SSE2NEON::validateInt32 ( __m128i a,
int32_t i0,
int32_t i1,
int32_t i2,
int32_t i3 )

◆ validateInt32() [2/2]

result_t SSE2NEON::validateInt32 ( __m64 a,
int32_t u0,
int32_t u1 )

◆ validateInt64() [1/2]

result_t SSE2NEON::validateInt64 ( __m128i a,
int64_t i0,
int64_t i1 )

◆ validateInt64() [2/2]

result_t SSE2NEON::validateInt64 ( __m64 a,
int64_t i0 )

◆ validateInt8() [1/2]

result_t SSE2NEON::validateInt8 ( __m128i a,
int8_t i0,
int8_t i1,
int8_t i2,
int8_t i3,
int8_t i4,
int8_t i5,
int8_t i6,
int8_t i7,
int8_t i8,
int8_t i9,
int8_t i10,
int8_t i11,
int8_t i12,
int8_t i13,
int8_t i14,
int8_t i15 )

◆ validateInt8() [2/2]

result_t SSE2NEON::validateInt8 ( __m64 a,
int8_t i0,
int8_t i1,
int8_t i2,
int8_t i3,
int8_t i4,
int8_t i5,
int8_t i6,
int8_t i7 )

◆ validateSingleDoublePair()

result_t SSE2NEON::validateSingleDoublePair ( double a,
double b )

◆ validateSingleFloatPair()

result_t SSE2NEON::validateSingleFloatPair ( float a,
float b )

◆ validateUInt16() [1/2]

result_t SSE2NEON::validateUInt16 ( __m128i a,
uint16_t u0,
uint16_t u1,
uint16_t u2,
uint16_t u3,
uint16_t u4,
uint16_t u5,
uint16_t u6,
uint16_t u7 )

◆ validateUInt16() [2/2]

result_t SSE2NEON::validateUInt16 ( __m64 a,
uint16_t u0,
uint16_t u1,
uint16_t u2,
uint16_t u3 )

◆ validateUInt32() [1/2]

result_t SSE2NEON::validateUInt32 ( __m128i a,
uint32_t u0,
uint32_t u1,
uint32_t u2,
uint32_t u3 )

◆ validateUInt32() [2/2]

result_t SSE2NEON::validateUInt32 ( __m64 a,
uint32_t u0,
uint32_t u1 )

◆ validateUInt64() [1/2]

result_t SSE2NEON::validateUInt64 ( __m128i a,
uint64_t u0,
uint64_t u1 )

◆ validateUInt64() [2/2]

result_t SSE2NEON::validateUInt64 ( __m64 a,
uint64_t u0 )

◆ validateUInt8() [1/2]

result_t SSE2NEON::validateUInt8 ( __m128i a,
uint8_t u0,
uint8_t u1,
uint8_t u2,
uint8_t u3,
uint8_t u4,
uint8_t u5,
uint8_t u6,
uint8_t u7,
uint8_t u8,
uint8_t u9,
uint8_t u10,
uint8_t u11,
uint8_t u12,
uint8_t u13,
uint8_t u14,
uint8_t u15 )

◆ validateUInt8() [2/2]

result_t SSE2NEON::validateUInt8 ( __m64 a,
uint8_t u0,
uint8_t u1,
uint8_t u2,
uint8_t u3,
uint8_t u4,
uint8_t u5,
uint8_t u6,
uint8_t u7 )

Variable Documentation

◆ crypto_aes_rsbox

const uint8_t SSE2NEON::crypto_aes_rsbox[256]
static
Initial value:
= {
0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 0xbf, 0x40, 0xa3, 0x9e,
0x81, 0xf3, 0xd7, 0xfb, 0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87,
0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb, 0x54, 0x7b, 0x94, 0x32,
0xa6, 0xc2, 0x23, 0x3d, 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e,
0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2, 0x76, 0x5b, 0xa2, 0x49,
0x6d, 0x8b, 0xd1, 0x25, 0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16,
0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92, 0x6c, 0x70, 0x48, 0x50,
0xfd, 0xed, 0xb9, 0xda, 0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84,
0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a, 0xf7, 0xe4, 0x58, 0x05,
0xb8, 0xb3, 0x45, 0x06, 0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02,
0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b, 0x3a, 0x91, 0x11, 0x41,
0x4f, 0x67, 0xdc, 0xea, 0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73,
0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85, 0xe2, 0xf9, 0x37, 0xe8,
0x1c, 0x75, 0xdf, 0x6e, 0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89,
0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b, 0xfc, 0x56, 0x3e, 0x4b,
0xc6, 0xd2, 0x79, 0x20, 0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4,
0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31, 0xb1, 0x12, 0x10, 0x59,
0x27, 0x80, 0xec, 0x5f, 0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d,
0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef, 0xa0, 0xe0, 0x3b, 0x4d,
0xae, 0x2a, 0xf5, 0xb0, 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61,
0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 0xe1, 0x69, 0x14, 0x63,
0x55, 0x21, 0x0c, 0x7d,
}

◆ crypto_aes_sbox

const uint8_t SSE2NEON::crypto_aes_sbox[256]
static
Initial value:
= {
0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b,
0xfe, 0xd7, 0xab, 0x76, 0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0,
0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0, 0xb7, 0xfd, 0x93, 0x26,
0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,
0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2,
0xeb, 0x27, 0xb2, 0x75, 0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0,
0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84, 0x53, 0xd1, 0x00, 0xed,
0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,
0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f,
0x50, 0x3c, 0x9f, 0xa8, 0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5,
0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2, 0xcd, 0x0c, 0x13, 0xec,
0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73,
0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14,
0xde, 0x5e, 0x0b, 0xdb, 0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c,
0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79, 0xe7, 0xc8, 0x37, 0x6d,
0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,
0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f,
0x4b, 0xbd, 0x8b, 0x8a, 0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e,
0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e, 0xe1, 0xf8, 0x98, 0x11,
0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,
0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f,
0xb0, 0x54, 0xbb, 0x16,
}

◆ instructionString

const char * SSE2NEON::instructionString
Initial value:
= {
#define _(x)
}
#define INTRIN_LIST
Definition impl.h:6

◆ NaN

int32_t SSE2NEON::NaN = ~0

◆ NaN64

int64_t SSE2NEON::NaN64 = ~0

◆ state

uint64_t SSE2NEON::state
static

◆ test_mm_cmpestra_sbyte_data

test_mm_cmpestri_sbyte_data_t SSE2NEON::test_mm_cmpestra_sbyte_data[TEST_MM_CMPESTRA_SBYTE_DATA_LEN]
static
Initial value:
= {
{{45, -94, 38, -11, 84, -123, -43, -49, 25, -55, -121, -6, 57, 108, -55,
69},
{-26, -61, -21, -96, 48, -112, 95, -56, 29, -55, -121, -6, 57, 108,
-55, 69},
23,
28,
0},
{{-12, 8},
{-12, 7, -12, 8, -13, 45, -12, 8},
2,
8,
0},
{{-100, -127, 56, 78, 21, -1, 9, 127, 45},
{100, 126, 30, 65, 87, 54, 80, 81, -98, -101, 90, 1, 5, 60, -77, -65},
10,
20,
1},
}
#define IMM_SBYTE_ANY_LEAST
Definition impl.cpp:9390
#define IMM_SBYTE_RANGES_LEAST
Definition impl.cpp:9400
#define IMM_SBYTE_ORDERED_MOST_NEGATIVE
Definition impl.cpp:9424

◆ test_mm_cmpestra_sword_data

test_mm_cmpestri_sword_data_t SSE2NEON::test_mm_cmpestra_sword_data[TEST_MM_CMPESTRA_SWORD_DATA_LEN]
static
Initial value:
= {
{{-100, -80, -5, -1, 10, 1000},
{-100, -99, -80, -2, 11, 789, 889, 999},
6,
12,
1},
{{-30000, -90, -32766, 1200, 5},
{-30001, 21, 10000, 1201, 888},
5,
5,
0},
{{2001, -1928},
{2000, 1928, 3000, 2289, 4000, 111, 2002, -1928},
2,
9,
0},
}
#define IMM_SWORD_ANY_LEAST_MASKED_NEGATIVE
Definition impl.cpp:9525
#define IMM_SWORD_RANGES_LEAST_NEGATIVE
Definition impl.cpp:9496
#define IMM_SWORD_EACH_MOST
Definition impl.cpp:9507

◆ test_mm_cmpestra_ubyte_data

test_mm_cmpestri_ubyte_data_t SSE2NEON::test_mm_cmpestra_ubyte_data[TEST_MM_CMPESTRA_UBYTE_DATA_LEN]
static
Initial value:
= {
{{20, 10, 33, 56, 78},
{20, 10, 34, 98, 127, 20, 10, 32, 20, 10, 32, 11, 3, 20, 10, 31},
3,
17,
1},
{{20, 127, 0, 45, 77, 1, 34, 43, 109},
{2, 127, 0, 54, 6, 43, 12, 110, 100},
9,
20,
0},
{{22, 33, 90, 1},
{22, 33, 90, 1, 1, 5, 4, 7, 98, 34, 1, 12, 13, 14, 15, 16},
4,
11,
0},
}
#define IMM_UBYTE_ANY_LEAST_MASKED_NEGATIVE
Definition impl.cpp:9333
#define IMM_UBYTE_EACH_LEAST_NEGATIVE
Definition impl.cpp:9314
#define IMM_UBYTE_ORDERED_MOST
Definition impl.cpp:9365

◆ test_mm_cmpestra_uword_data

test_mm_cmpestri_uword_data_t SSE2NEON::test_mm_cmpestra_uword_data[TEST_MM_CMPESTRA_UWORD_DATA_LEN]
static
Initial value:
= {
{{10000, 20000, 30000, 40000, 50000},
{40001, 50002, 10000, 20000, 30000, 40000, 50000},
5,
10,
0},
{{1001, 9487, 9487, 8000},
{1001, 1002, 1003, 8709, 100, 1, 1000, 999},
4,
6,
0},
{{12, 21, 0, 45, 88, 10001, 10002, 65535},
{22, 13, 3, 54, 888, 10003, 10000, 65530},
13,
13,
1},
}
#define IMM_UWORD_RANGES_LEAST_MASKED_NEGATIVE
Definition impl.cpp:9438
#define IMM_UWORD_EACH_MOST
Definition impl.cpp:9451
#define IMM_UWORD_ORDERED_LEAST
Definition impl.cpp:9475

◆ test_mm_cmpestrc_sbyte_data

test_mm_cmpestri_sbyte_data_t SSE2NEON::test_mm_cmpestrc_sbyte_data[TEST_MM_CMPESTRC_SBYTE_DATA_LEN]
static
Initial value:
= {
{{-22, -30, 40, 45},
{-31, -32, 46, 77},
4,
4,
0},
{{-12, -7, 33, 100, 12},
{-12, -7, 33, 100, 11, -11, -7, 33, 100, 12},
5,
10,
1},
{{1, 2, 3, 4, 5, -1, -2, -3, -4, -5},
{1, 2, 3, 4, 5, -1, -2, -3, -5},
10,
9,
0},
{{101, -128, -88, -76, 89, 109, 44, -12, -45, -100, 22, 1, 91},
{102, -120, 88, -76, 98, 107, 33, 12, 45, -100, 22, 10, 19},
13,
13,
1},
}
#define IMM_SBYTE_RANGES_MOST
Definition impl.cpp:9408
#define IMM_SBYTE_ORDERED_MOST_MASKED_NEGATIVE
Definition impl.cpp:9429
#define IMM_SBYTE_ANY_MOST_MASKED_NEGATIVE
Definition impl.cpp:9397
#define IMM_SBYTE_EACH_MOST
Definition impl.cpp:9382

◆ test_mm_cmpestrc_sword_data

test_mm_cmpestri_sword_data_t SSE2NEON::test_mm_cmpestrc_sword_data[TEST_MM_CMPESTRC_SWORD_DATA_LEN]
static
Initial value:
= {
{{-100, -90, -80, -66, 1},
{-101, -102, -1000, 2, 67, 10000},
5,
6,
0},
{{12, 13, -700, 888, 44, -987, 19},
{12, 13, -700, 888, 44, -987, 19},
7,
7,
0},
{{2001, -1992, 1995, 10007, 2000},
{2000, 1928, 3000, 9822, 5000, 1111, 2002, -1928},
5,
9,
1},
{{13, -26, 39},
{12, -25, 33, 13, -26, 39},
3,
6,
1},
}
#define IMM_SWORD_RANGES_LEAST
Definition impl.cpp:9492
#define IMM_SWORD_ANY_LEAST_NEGATIVE
Definition impl.cpp:9523
#define IMM_SWORD_EACH_MOST_NEGATIVE
Definition impl.cpp:9515
#define IMM_SWORD_ORDERED_MOST
Definition impl.cpp:9547

◆ test_mm_cmpestrc_ubyte_data

test_mm_cmpestri_ubyte_data_t SSE2NEON::test_mm_cmpestrc_ubyte_data[TEST_MM_CMPESTRC_UBYTE_DATA_LEN]
static
Initial value:
= {
{{66, 3, 3, 65},
{66, 3, 3, 65, 67, 2, 2, 67, 56, 11, 1, 23, 66, 3, 3, 65},
4,
16,
1},
{{1, 11, 2, 22, 3, 33, 4, 44, 5, 55, 6, 66, 7, 77, 8, 88},
{2, 22, 3, 23, 5, 66, 255, 43, 6, 66, 7, 77, 9, 99, 10, 100},
16,
16,
0},
{{36, 72, 108}, {12, 24, 48, 96, 77, 84}, 3, 6, IMM_UBYTE_ANY_LEAST, 0},
{{12, 24, 36, 48},
{11, 49, 50, 56, 77, 15, 10},
4,
7,
1},
}
#define IMM_UBYTE_ORDERED_MOST_MASKED_NEGATIVE
Definition impl.cpp:9370
#define IMM_UBYTE_ANY_LEAST
Definition impl.cpp:9328
#define IMM_UBYTE_RANGES_LEAST_NEGATIVE
Definition impl.cpp:9348
#define IMM_UBYTE_EACH_MOST
Definition impl.cpp:9320

◆ test_mm_cmpestrc_uword_data

test_mm_cmpestri_uword_data_t SSE2NEON::test_mm_cmpestrc_uword_data[TEST_MM_CMPESTRC_UWORD_DATA_LEN]
static
Initial value:
= {
{{1000, 2000, 4000, 8000, 16000},
{40001, 1000, 2000, 40000, 8000, 16000},
5,
6,
1},
{{1111, 1212},
{1110, 1213, 1110, 1214, 1100, 1220, 1000, 1233},
2,
8,
0},
{{10000, 9000, 8000, 7000, 6000, 5000, 4000, 3000},
{9000, 8000, 7000, 6000, 5000, 4000, 3000, 2000},
13,
13,
1},
{{12}, {11, 13, 14, 15, 10}, 1, 5, IMM_UWORD_ANY_MOST, 0},
}
#define IMM_UWORD_EACH_LEAST_MASKED_NEGATIVE
Definition impl.cpp:9456
#define IMM_UWORD_ORDERED_LEAST_NEGATIVE
Definition impl.cpp:9477
#define IMM_UWORD_ANY_MOST
Definition impl.cpp:9464
#define IMM_UWORD_RANGES_MOST
Definition impl.cpp:9441

◆ test_mm_cmpestri_sbyte_data

test_mm_cmpestri_sbyte_data_t SSE2NEON::test_mm_cmpestri_sbyte_data[TEST_MM_CMPESTRI_SBYTE_DATA_LEN]
static
Initial value:
= {
{{-12, -1, 90, -128, 43, 6, 87, 127},
{-1, -1, 9, -127, 126, 6, 78, 23},
8,
8,
1},
{{34, 67, -90, 33, 123, -100, 43, 56},
{43, 76, -90, 44, 20, -100, 54, 56},
8,
8,
0},
{{-43, 67, 89},
{-44, -54, -30, -128, 127, 34, 10, -62},
3,
7,
2},
{{90, 34, -32, 0, 5},
{19, 34, -32, 90, 34, -32, 45, 0, 5, 90, 34, -32, 0, 5, 19, 87},
3,
16,
3},
}
#define IMM_SBYTE_ORDERED_LEAST
Definition impl.cpp:9416
#define IMM_SBYTE_EACH_LEAST
Definition impl.cpp:9374

◆ test_mm_cmpestri_sword_data

test_mm_cmpestri_sword_data_t SSE2NEON::test_mm_cmpestri_sword_data[TEST_MM_CMPESTRI_SWORD_DATA_LEN]
static
Initial value:
= {
{{13, 6, 5, 4, 3, 2, 1, 3},
{-7, 16, 5, 4, -1, 6, 1, 3},
10,
10,
7},
{{13, 6, 5, 4, 3, 2, 1, 3},
{-7, 16, 5, 4, -1, 6, 1, 3},
8,
8,
2},
{{-32768, 90, 455, 67, -1000, -10000, 21, 12},
{-7, 61, 455, 67, -32768, 32767, 11, 888},
8,
8,
2},
{{-12, -56},
{-7, 16, 555, 554, -12, 61, -16, 3},
2,
8,
8},
}
#define IMM_SWORD_ORDERED_LEAST
Definition impl.cpp:9539
#define IMM_SWORD_EACH_LEAST
Definition impl.cpp:9505
#define IMM_SWORD_RANGES_MOST
Definition impl.cpp:9494
#define IMM_SWORD_ANY_LEAST
Definition impl.cpp:9521

◆ test_mm_cmpestri_ubyte_data

test_mm_cmpestri_ubyte_data_t SSE2NEON::test_mm_cmpestri_ubyte_data[TEST_MM_CMPESTRI_UBYTE_DATA_LEN]
static
Initial value:
= {
{{23, 89, 255, 0, 90, 45, 67, 12, 1, 56, 200, 141, 3, 4, 2, 76},
{32, 89, 255, 128, 9, 54, 78, 12, 1, 56, 100, 41, 42, 68, 32, 5},
16,
16,
0},
{{0, 83, 112, 12, 221, 54, 76, 83, 112, 10},
{0, 83, 112, 83, 122, 45, 67, 83, 112, 9},
10,
10,
0},
{{34, 78, 12},
{56, 100, 11, 67, 35, 79, 67, 255, 0, 43, 121, 234, 225, 91, 31, 23},
3,
16,
0},
{{13, 10, 9, 32, 105, 103, 110, 111, 114, 101, 32, 116, 104, 105, 115,
32},
{83, 112, 108, 105, 116, 32, 13, 10, 9, 32, 108, 105, 110, 101, 32,
32},
3,
15,
6},
}
#define IMM_UBYTE_RANGES_LEAST
Definition impl.cpp:9344
#define IMM_UBYTE_EACH_LEAST
Definition impl.cpp:9312
#define IMM_UBYTE_ORDERED_LEAST
Definition impl.cpp:9360
#define IMM_UBYTE_ANY_LEAST_NEGATIVE
Definition impl.cpp:9330

◆ test_mm_cmpestri_uword_data

test_mm_cmpestri_uword_data_t SSE2NEON::test_mm_cmpestri_uword_data[TEST_MM_CMPESTRI_UWORD_DATA_LEN]
static
Initial value:
= {
{{45, 65535, 0, 87, 1000, 10, 45, 26},
{65534, 0, 0, 78, 1000, 10, 32, 26},
8,
8,
2},
{{45, 23, 10, 54, 88, 10000, 20000, 100},
{544, 10000, 20000, 1, 0, 2897, 2330, 2892},
8,
8,
1},
{{10000, 15000},
{12, 45, 67, 899, 10001, 32, 15001, 15000},
2,
8,
4},
{{0, 1, 54, 89, 100},
{101, 102, 65535, 0, 1, 54, 89, 100},
5,
8,
3},
}
#define IMM_UWORD_ANY_LEAST
Definition impl.cpp:9462
#define IMM_UWORD_EACH_LEAST
Definition impl.cpp:9449
#define IMM_UWORD_RANGES_LEAST
Definition impl.cpp:9433

◆ test_mm_cmpestrm_sbyte_data

test_mm_cmpestrm_sbyte_data_t SSE2NEON::test_mm_cmpestrm_sbyte_data[TEST_MM_CMPESTRM_SBYTE_DATA_LEN]
static
Initial value:
= {
{{-127, -127, 34, 88, 0, 1, -1, 78, 90, 9, 23, 34, 3, -128, 127, 0},
{0, -127, 34, 88, 12, 43, -128, 78, 8, 9, 43, 32, 7, 126, 115, 0},
16,
16,
{0, -1, -1, -1, 0, 0, 0, -1, 0, -1, 0, 0, 0, 0, 0, -1}},
{{0, 32, 7, 115, -128, 44, 33},
{0, -127, 34, 88, 12, 43, -128, 78, 8, 9, 43, 32, 7, 126, 115, 0},
7,
10,
{0, -1, -1, -1, -1, -1, 0, -1, -1, -1, 0, 0, 0, 0, 0, 0}},
{{-128, -80, -90, 10, 33},
{-126, -93, -80, -77, -56, -23, -10, -1, 0, 3, 10, 12, 13, 33, 34, 56},
5,
16,
{-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 0, 0, 0, 0}},
{{104, 9, -12},
{0, 0, 87, 104, 9, -12, 89, -117, 9, 10, -11, 87, -114, 104, 9, -61},
3,
16,
{0, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
}
#define IMM_SBYTE_RANGES_UNIT
Definition impl.cpp:10065
#define IMM_SBYTE_EACH_UNIT
Definition impl.cpp:10055
#define IMM_SBYTE_ORDERED_UNIT
Definition impl.cpp:10067
#define IMM_SBYTE_ANY_UNIT_MASKED_NEGATIVE
Definition impl.cpp:10062

◆ test_mm_cmpestrm_sword_data

test_mm_cmpestrm_sword_data_t SSE2NEON::test_mm_cmpestrm_sword_data[TEST_MM_CMPESTRM_SWORD_DATA_LEN]
static
Initial value:
= {
{{13, 6, 5, 4, 3, 2, 1, 3},
{-7, 16, 5, 4, -1, 6, 1, 3},
10,
10,
{0, 0, 0, 0, 0, 0, -1, -1}},
{{85, 115, 101, 70, 108, 97, 116, 65},
{85, 115, 105, 110, 103, 65, 110, 65},
8,
8,
{-1, -1, 0, 0, 0, 0, 0, -1}},
{{-32768, 10000, 10, -13},
{-32767, 32767, -32768, 90, 0, -13, 23, 45},
4,
8,
{0, 0, -1, 0, 0, -1, 0, 0}},
{{10, 20, -10, 60},
{0, 0, 0, 10, 20, -10, 60, 10},
4,
8,
{0, 0, 0, -1, 0, 0, 0, -1}},
}
#define IMM_SWORD_ANY_UNIT
Definition impl.cpp:10090
#define IMM_SWORD_RANGES_UNIT
Definition impl.cpp:10084
#define IMM_SWORD_EACH_UNIT
Definition impl.cpp:10088
#define IMM_SWORD_ORDERED_UNIT
Definition impl.cpp:10092

◆ test_mm_cmpestrm_ubyte_data

test_mm_cmpestrm_ubyte_data_t SSE2NEON::test_mm_cmpestrm_ubyte_data[TEST_MM_CMPESTRM_UBYTE_DATA_LEN]
static

◆ test_mm_cmpestrm_uword_data

test_mm_cmpestrm_uword_data_t SSE2NEON::test_mm_cmpestrm_uword_data[TEST_MM_CMPESTRM_UWORD_DATA_LEN]
static
Initial value:
= {
{{1, 5, 13, 19, 22},
{12, 60000, 5, 1, 100, 1000, 34, 20},
5,
8,
{0, 0, 65535, 65535, 0, 0, 0, 0}},
{{65535, 12, 7, 9876, 3456, 12345, 10, 98},
{65535, 0, 10, 9876, 3456, 0, 13, 32},
8,
8,
{65535, 0, 0, 65535, 65535, 0, 0, 0}},
{{100, 0},
{12345, 6766, 234, 0, 1, 34, 89, 100},
2,
8,
{136, 0, 0, 0, 0, 0, 0, 0}},
{{123, 67, 890},
{123, 67, 890, 8900, 4, 0, 123, 67},
3,
8,
{65535, 0, 0, 0, 0, 0, 65535, 0}},
}
#define IMM_UWORD_ANY_BIT
Definition impl.cpp:10076
#define IMM_UWORD_EACH_UNIT
Definition impl.cpp:10072
#define IMM_UWORD_ORDERED_UNIT
Definition impl.cpp:10078
#define IMM_UWORD_RANGES_UNIT
Definition impl.cpp:10070

◆ test_mm_cmpestro_sbyte_data

test_mm_cmpestri_sbyte_data_t SSE2NEON::test_mm_cmpestro_sbyte_data[TEST_MM_CMPESTRO_SBYTE_DATA_LEN]
static
Initial value:
= {
{{23, -23, 24, -24, 25, -25, 26, -26, 27, -27, 28, -28, -29, 29, 30,
31},
{24, -23, 25, -24, 25, -25, 26, -26, 27, -27, 28, -28, -29, 29, 30,
31},
16,
16,
1},
{{34, 33, 67, 72, -90, 127, 33, -128, 123, -90, -100, 34, 43, 15, 56,
3},
{3, 14, 15, 65, 90, -127, 100, 100},
16,
8,
1},
{{-13, 0, 34},
{-12, -11, 1, 12, 56, 57, 3, 2, -17},
6,
9,
0},
{{1, 2, 3, 4, 5, 6, 7, 8},
{-1, -2, -3, -4, -5, -6, -7, -8, 1, 2, 3, 4, 5, 6, 7, 8},
8,
16,
0},
}
#define IMM_SBYTE_RANGES_MOST_MASKED_NEGATIVE
Definition impl.cpp:9413
#define IMM_SBYTE_ORDERED_MOST
Definition impl.cpp:9427
#define IMM_SBYTE_EACH_MOST_NEGATIVE
Definition impl.cpp:9384
#define IMM_SBYTE_ANY_MOST
Definition impl.cpp:9395

◆ test_mm_cmpestro_sword_data

test_mm_cmpestri_sword_data_t SSE2NEON::test_mm_cmpestro_sword_data[TEST_MM_CMPESTRO_SWORD_DATA_LEN]
static
Initial value:
= {
{{-9999, -9487, -5000, -4433, -3000, -2999, -2000, -1087},
{-32767, -30000, -4998},
100,
3,
1},
{{-30, 89, 7777},
{-30, 89, 7777},
3,
3,
0},
{{8, 9, -100, 1000, -5000, -32000, 32000, 7},
{29999, 32001, 5, 555},
8,
4,
1},
{{-1, 56, -888, 9000, -23, 12, -1, -1},
{-1, 56, -888, 9000, -23, 12, -1, -1},
8,
8,
0},
}
#define IMM_SWORD_ANY_MOST_MASKED_NEGATIVE
Definition impl.cpp:9533
#define IMM_SWORD_RANGES_MOST_MASKED_NEGATIVE
Definition impl.cpp:9502
#define IMM_SWORD_ORDERED_MOST_MASKED_NEGATIVE
Definition impl.cpp:9549
#define IMM_SWORD_EACH_MOST_MASKED_NEGATIVE
Definition impl.cpp:9518

◆ test_mm_cmpestro_ubyte_data

test_mm_cmpestri_ubyte_data_t SSE2NEON::test_mm_cmpestro_ubyte_data[TEST_MM_CMPESTRO_UBYTE_DATA_LEN]
static
Initial value:
= {
{{56, 78, 255, 1, 9},
{56, 78, 43, 255, 1, 6, 9},
5,
7,
0},
{{33, 44, 100, 24, 3, 89, 127, 254, 33, 45, 250},
{33, 44, 100, 22, 3, 98, 125, 254, 33, 4, 243},
11,
11,
0},
{{34, 27, 18, 9}, {}, 4, 16, IMM_UBYTE_RANGES_LEAST_MASKED_NEGATIVE, 1},
{{3, 18, 216},
{3, 18, 222, 3, 17, 216, 3, 18, 216},
3,
9,
1},
}
#define IMM_UBYTE_RANGES_LEAST_MASKED_NEGATIVE
Definition impl.cpp:9354
#define IMM_UBYTE_ANY_MOST_NEGATIVE
Definition impl.cpp:9338
#define IMM_UBYTE_ORDERED_LEAST_NEGATIVE
Definition impl.cpp:9362
#define IMM_UBYTE_EACH_LEAST_MASKED_NEGATIVE
Definition impl.cpp:9317

◆ test_mm_cmpestro_uword_data

test_mm_cmpestri_uword_data_t SSE2NEON::test_mm_cmpestro_uword_data[TEST_MM_CMPESTRO_UWORD_DATA_LEN]
static
Initial value:
= {
{{0, 0, 0, 4, 4, 4, 8, 8},
{0, 0, 0, 3, 3, 16653, 3333, 222},
8,
8,
0},
{{12, 666, 9456, 10000, 32, 444, 57, 0},
{11, 777, 9999, 32767, 23},
8,
5,
1},
{{23, 32, 45, 67},
{10022, 23, 32, 44, 66, 67, 12, 22},
4,
8,
1},
{{222, 45, 8989},
{221, 222, 45, 8989, 222, 45, 8989},
3,
7,
0},
}
#define IMM_UWORD_ANY_LEAST_MASKED_NEGATIVE
Definition impl.cpp:9472
#define IMM_UWORD_RANGES_LEAST_NEGATIVE
Definition impl.cpp:9435
#define IMM_UWORD_EACH_MOST_MASKED_NEGATIVE
Definition impl.cpp:9459
#define IMM_UWORD_ORDERED_MOST
Definition impl.cpp:9483

◆ test_mm_cmpestrs_sbyte_data

test_mm_cmpestri_sbyte_data_t SSE2NEON::test_mm_cmpestrs_sbyte_data[TEST_MM_CMPESTRS_SBYTE_DATA_LEN]
static
Initial value:
= {
{{-1, -2, -3, -4, -100, 100, 1, 2, 3, 4},
{-90, -80, 111, 67, 88},
10,
5,
1},
{{99, 100, 101, -99, -100, -101, 56, 7},
{-128, -126, 100, 127},
23,
4,
0},
}
#define IMM_SBYTE_EACH_LEAST_MASKED_NEGATIVE
Definition impl.cpp:9379
#define IMM_SBYTE_ORDERED_LEAST_MASKED_NEGATIVE
Definition impl.cpp:9421

◆ test_mm_cmpestrs_sword_data

test_mm_cmpestri_sword_data_t SSE2NEON::test_mm_cmpestrs_sword_data[TEST_MM_CMPESTRS_SWORD_DATA_LEN]
static
Initial value:
= {
{{-30000, 2897, 1111, -4455},
{30, 40, 500, 6000, 20, -10, -789, -29999},
4,
8,
1},
{{34, 56, 789, 1024, 2048, 4096, 8192, -16384},
{3, 9, -27, 81, -216, 1011},
9,
6,
0},
}
#define IMM_SWORD_ORDERED_LEAST_MASKED_NEGATIVE
Definition impl.cpp:9544
#define IMM_SWORD_EACH_LEAST_NEGATIVE
Definition impl.cpp:9509

◆ test_mm_cmpestrs_ubyte_data

test_mm_cmpestri_ubyte_data_t SSE2NEON::test_mm_cmpestrs_ubyte_data[TEST_MM_CMPESTRS_UBYTE_DATA_LEN]
static
Initial value:
= {
{{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16},
{0},
16,
0,
0},
{{1, 2, 3}, {1, 2, 3}, 3, 8, IMM_UBYTE_RANGES_MOST, 1},
}
#define IMM_UBYTE_ANY_MOST
Definition impl.cpp:9336
#define IMM_UBYTE_RANGES_MOST
Definition impl.cpp:9346

◆ test_mm_cmpestrs_uword_data

test_mm_cmpestri_uword_data_t SSE2NEON::test_mm_cmpestrs_uword_data[TEST_MM_CMPESTRS_UWORD_DATA_LEN]
static
Initial value:
= {
{{1},
{90, 65535, 63355, 12, 8, 5, 34, 10000},
100,
7,
0},
}
#define IMM_UWORD_ANY_MOST_NEGATIVE
Definition impl.cpp:9466
#define IMM_UWORD_RANGES_MOST_MASKED_NEGATIVE
Definition impl.cpp:9446

◆ test_mm_cmpestrz_sbyte_data

test_mm_cmpestri_sbyte_data_t SSE2NEON::test_mm_cmpestrz_sbyte_data[TEST_MM_CMPESTRZ_SBYTE_DATA_LEN]
static
Initial value:
= {
{{}, {-90, -80, 111, 67, 88}, 0, 18, IMM_SBYTE_EACH_LEAST_NEGATIVE, 0},
{{9, 10, 10, -99, -100, -101, 56, 76},
{-127, 127, -100, -120, 13, 108, 1, -66, -34, 89, -89, 123, 22, -19,
-8},
7,
15,
1},
}
#define IMM_SBYTE_EACH_LEAST_NEGATIVE
Definition impl.cpp:9376
#define IMM_SBYTE_ORDERED_LEAST_NEGATIVE
Definition impl.cpp:9418

◆ test_mm_cmpestrz_sword_data

test_mm_cmpestri_sword_data_t SSE2NEON::test_mm_cmpestrz_sword_data[TEST_MM_CMPESTRZ_SWORD_DATA_LEN]
static
Initial value:
= {
{{30000, 28997, 11111, 4455},
{30, 40, 500, 6000, 20, -10, -789, -29999},
4,
8,
0},
{{789, 1024, 2048, 4096, 8192},
{-3, 9, -27, 18, -217, 10111, 22222},
5,
7,
1},
}
#define IMM_SWORD_EACH_LEAST_MASKED_NEGATIVE
Definition impl.cpp:9512

◆ test_mm_cmpestrz_ubyte_data

test_mm_cmpestri_ubyte_data_t SSE2NEON::test_mm_cmpestrz_ubyte_data[TEST_MM_CMPESTRZ_UBYTE_DATA_LEN]
static
Initial value:
= {
{{0, 1, 2, 3, 4, 5, 6, 7},
{12, 67, 0, 3},
8,
4,
1},
{{255, 0, 127, 88},
{1, 2, 4, 8, 16, 32, 64, 128, 254, 233, 209, 41, 66, 77, 90, 100},
4,
16,
0},
}
#define IMM_UBYTE_RANGES_MOST_MASKED_NEGATIVE
Definition impl.cpp:9357
#define IMM_UBYTE_ANY_MOST_MASKED_NEGATIVE
Definition impl.cpp:9341

◆ test_mm_cmpestrz_uword_data

test_mm_cmpestri_uword_data_t SSE2NEON::test_mm_cmpestrz_uword_data[TEST_MM_CMPESTRZ_UWORD_DATA_LEN]
static
Initial value:
= {
{{1},
{9000, 33333, 63333, 120, 8, 55, 34, 100},
100,
7,
1},
{{1, 2, 3},
{1, 10000, 65535, 8964, 9487, 32, 451, 666},
3,
8,
0},
}
#define IMM_UWORD_RANGES_MOST_NEGATIVE
Definition impl.cpp:9443
#define IMM_UWORD_ANY_LEAST_NEGATIVE
Definition impl.cpp:9469

◆ test_mm_cmpistra_sbyte_data

test_mm_cmpistri_sbyte_data_t SSE2NEON::test_mm_cmpistra_sbyte_data[TEST_MM_CMPISTRA_SBYTE_DATA_LEN]
static
Initial value:
= {
{{-11, -13, -43, -50, 66, 77, 87, 98, -128, 127, 126, 99, 1, 2, 3, -5},
{-12, -13, -43, -56, 66, 78, 88, 98, -125, 127, 120, 9, 100, 22, 54,
-10},
0},
{{10, 11, 100, -90, 0},
{8, 9, 10, 11, 0, 8, 9, 10, -90, 0},
0},
{{-90, -60, -34, -25, 34, 56, 70, 79, 0},
{-100, -59, -35, -24, -101, 33, 57, 69, 80, 81, -128, 100, 101, 102,
-101, -102},
1},
{{1, 1, 1, 1, -1, -1, -1, -1, -10, 10, -10, 10, 44, -44, 44, -44},
{1, 1, -1, 1, -1, -1, -1, -1, -10, 10, -10, 10, 44, -44, 44, -44},
1},
}
#define IMM_SBYTE_ANY_LEAST_NEGATIVE
Definition impl.cpp:9392

◆ test_mm_cmpistra_sword_data

test_mm_cmpistri_sword_data_t SSE2NEON::test_mm_cmpistra_sword_data[TEST_MM_CMPISTRA_SWORD_DATA_LEN]
static
Initial value:
= {
{{-32000, -28000, 0},
{-32001, -29999, -28001, -28000, -27999, -26000, -32768},
0},
{{-12, -11, -10, -9, -8, -7, 90, 1000},
{-13, -10, 9, -8, -7, 1000, 1000, 90},
1},
{{33, 44, 787, 23, 0},
{32, 43, 788, 0, 32, 0, 43, 0},
0},
{{18, 78, 999, -56, 0},
{18, 78, 999, 56, 18, 78, 999, 4},
1},
}
#define IMM_SWORD_RANGES_LEAST_MASKED_NEGATIVE
Definition impl.cpp:9499

◆ test_mm_cmpistra_ubyte_data

test_mm_cmpistri_ubyte_data_t SSE2NEON::test_mm_cmpistra_ubyte_data[TEST_MM_CMPISTRA_UBYTE_DATA_LEN]
static
Initial value:
= {
{{10, 11, 12, 13, 14, 15, 16, 17, 18, 9, 20, 98, 97, 96, 95, 127},
{1, 2, 3, 4, 5, 6, 7, 8, 99, 100, 101, 102, 103, 104, 105, 106},
1},
{{1, 22, 33, 44, 5, 66, 7, 88, 9, 10, 111, 0},
{2, 23, 34, 21, 6, 65, 8, 84, 99, 100, 11, 112, 123, 14, 15, 6},
1},
{{5, 15, 25, 35, 45, 55, 65, 75, 0},
{4, 6, 14, 16, 24, 26, 34, 36, 44, 46, 54, 56, 74, 76},
0},
{{4, 14, 64, 84, 0},
{4, 14, 64, 84, 0, 4, 14, 65, 84, 0, 4, 14, 64, 84, 0, 1},
0},
}
#define IMM_UBYTE_ORDERED_MOST_NEGATIVE
Definition impl.cpp:9367

◆ test_mm_cmpistra_uword_data

test_mm_cmpistri_uword_data_t SSE2NEON::test_mm_cmpistra_uword_data[TEST_MM_CMPISTRA_UWORD_DATA_LEN]
static
Initial value:
= {
{{88, 888, 8888, 31888, 10888, 18088, 10880, 28888},
{888, 88, 8888, 32000, 10888, 18000, 10888, 28888},
0},
{{3, 4, 555, 6666, 7777, 888, 9, 100},
{1, 2, 333, 4444, 5555, 666, 7, 8},
1},
{{1000, 2000, 2002, 3000, 3002, 4000, 5000, 5999},
{999, 2001, 3001, 4001, 4002, 4999, 6000, 6001},
1},
{{55, 66, 77, 888, 0},
{55, 66, 77, 888, 0, 33, 2, 10000},
0},
}
#define IMM_UWORD_EACH_LEAST_NEGATIVE
Definition impl.cpp:9453

◆ test_mm_cmpistrc_sbyte_data

test_mm_cmpistri_sbyte_data_t SSE2NEON::test_mm_cmpistrc_sbyte_data[TEST_MM_CMPISTRC_SBYTE_DATA_LEN]
static
Initial value:
= {
{{35, -35, 67, -66, 34, 55, 12, -100, 34, -34, 66, -67, 52, 100, 127,
-128},
{35, -35, 67, -66, 0, 55, 12, -100, 0, -34, 66, -67, 0, 100, 127,
-128},
0},
{{-119, 112, 105, 104, 0},
{119, -112, 105, -104, 104, -34, 112, -119, 0},
1},
{{-79, -69, -40, -35, 34, 45, 67, 88, 0},
{1, 2, 3, 4, 5, 6, 7, 8, 0},
0},
{{22, -109, 123, 115, -12, 0},
{22, -109, 12, 115, 22, -109, 123, 115, -12, 0},
1},
}
#define IMM_SBYTE_EACH_MOST_MASKED_NEGATIVE
Definition impl.cpp:9387

◆ test_mm_cmpistrc_sword_data

test_mm_cmpistri_sword_data_t SSE2NEON::test_mm_cmpistrc_sword_data[TEST_MM_CMPISTRC_SWORD_DATA_LEN]
static
Initial value:
= {
{{-78, -56, 1000, 1002},
{-79, -55, -12, -13, 999, 1003, -80, 10000},
0},
{{45, 32767, -30000, 2345, -23450, 0},
{45, 32767, -30000, 2346, -23456, 0, 45, 333},
1},
{{-10000, -20000, -30000, 10000, 20000, 30000, 0},
{10000, 20000, 30000, -10000, -20000, 20000, -30000, 12},
1},
{{1, 2, -3, -55, -666, -7777, 8888},
{2, -3, -55, -666, -7777, 8888, 1},
0},
}
#define IMM_SWORD_ANY_MOST_NEGATIVE
Definition impl.cpp:9530

◆ test_mm_cmpistrc_ubyte_data

test_mm_cmpistri_ubyte_data_t SSE2NEON::test_mm_cmpistrc_ubyte_data[TEST_MM_CMPISTRC_UBYTE_DATA_LEN]
static
Initial value:
= {
{{89, 64, 88, 23, 11, 109, 34, 55, 0},
{2, 64, 87, 32, 1, 110, 43, 66, 0},
1},
{{99, 67, 2, 127, 125, 3, 24, 77, 32, 68, 96, 74, 70, 110, 111, 5},
{98, 88, 67, 125, 111, 4, 56, 88, 33, 69, 99, 79, 123, 11, 10, 6},
0},
{{2, 3, 74, 78, 81, 83, 85, 87, 89, 90, 0},
{86, 90, 74, 85, 87, 81, 2, 3, 3, 3, 75, 76, 77, 78, 82, 85},
0},
{{45, 67, 8, 9, 0},
{67, 45, 67, 8, 9, 45, 67, 8, 9, 45, 67, 8, 9, 45, 67, 8},
1},
}
#define IMM_UBYTE_RANGES_MOST_NEGATIVE
Definition impl.cpp:9351

◆ test_mm_cmpistrc_uword_data

test_mm_cmpistri_uword_data_t SSE2NEON::test_mm_cmpistrc_uword_data[TEST_MM_CMPISTRC_UWORD_DATA_LEN]
static
Initial value:
= {
{{23, 45, 67, 89, 102, 121, 23, 45},
{23, 45, 67, 89, 102, 121, 23, 44},
1},
{{1, 11, 55, 75}, {13, 14, 56, 77, 0}, IMM_UWORD_ANY_LEAST, 0},
{{1, 9, 11, 19, 21, 29, 91, 99},
{10, 29, 30, 40, 50, 60, 70, 80},
1},
{{3, 4, 5, 0},
{0, 3, 4, 5, 3, 4, 5, 0},
0},
}
#define IMM_UWORD_ORDERED_LEAST_MASKED_NEGATIVE
Definition impl.cpp:9480

◆ test_mm_cmpistri_sbyte_data

test_mm_cmpistri_sbyte_data_t SSE2NEON::test_mm_cmpistri_sbyte_data[TEST_MM_CMPISTRI_SBYTE_DATA_LEN]
static
Initial value:
= {
{{1, 2, 3, 4, 5, -99, -128, -100, -1, 49, 0},
{2, 3, 3, 4, 5, -100, -128, -99, 1, 44, 0},
2},
{{99, 100, 23, -90, 0},
{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 99, 100, 23, -90, -90, 100},
10},
{{-10, -2, 89, 97, 0},
{-11, -12, -3, 1, 97, 0},
0},
{{-10, -90, -22, 30, 87, 127, 0}, {0}, IMM_SBYTE_ORDERED_LEAST, 16},
}
#define IMM_SBYTE_RANGES_LEAST_NEGATIVE
Definition impl.cpp:9402

◆ test_mm_cmpistri_sword_data

test_mm_cmpistri_sword_data_t SSE2NEON::test_mm_cmpistri_sword_data[TEST_MM_CMPISTRI_SWORD_DATA_LEN]
static
Initial value:
= {
{{-1, -5, 10, 30, 40, 0},
{13, -2, 7, 80, 11, 0},
0},
{{-12, 12, 6666, 777, 0},
{11, 12, 6666, 777, 0},
1},
{{23, 22, 33, 567, 9999, 12345, 0},
{23, 22, 23, 22, 23, 22, 23, 12222},
6},
{{12, -234, -567, 8888, 0},
{13, -234, -567, 8888, 12, -234, -567, 8889},
8},
}
#define IMM_SWORD_ANY_MOST
Definition impl.cpp:9528

◆ test_mm_cmpistri_ubyte_data

test_mm_cmpistri_ubyte_data_t SSE2NEON::test_mm_cmpistri_ubyte_data[TEST_MM_CMPISTRI_UBYTE_DATA_LEN]
static
Initial value:
= {
{{104, 117, 110, 116, 114, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
{33, 64, 35, 36, 37, 94, 38, 42, 40, 41, 91, 93, 58, 59, 60, 62},
16},
{{4, 5, 6, 7, 8, 111, 34, 21, 0, 0, 0, 0, 0, 0, 0, 0},
{5, 6, 7, 8, 8, 111, 43, 12, 0, 0, 0, 0, 0, 0, 0, 0},
15},
{{65, 90, 97, 122, 48, 57, 0},
{47, 46, 43, 44, 42, 43, 45, 41, 40, 123, 124, 125, 126, 127, 1, 2},
16},
{{111, 222, 22, 0},
{33, 44, 55, 66, 77, 88, 99, 111, 222, 22, 11, 0},
7},
}
#define IMM_UBYTE_EACH_MOST_MASKED_NEGATIVE
Definition impl.cpp:9325

◆ test_mm_cmpistri_uword_data

test_mm_cmpistri_uword_data_t SSE2NEON::test_mm_cmpistri_uword_data[TEST_MM_CMPISTRI_UWORD_DATA_LEN]
static
Initial value:
= {
{{38767, 99, 1234, 65535, 2222, 1, 34456, 11},
{38768, 999, 1235, 4444, 2222, 1, 34456, 12},
4},
{{22222, 33333, 44444, 55555, 6000, 600, 60, 6},
{0},
8},
{{34, 777, 1000, 1004, 0},
{33, 32, 889, 1003, 0},
3},
{{44, 555, 44, 0},
{44, 555, 44, 555, 44, 555, 44, 0},
7},
}
#define IMM_UWORD_ORDERED_MOST_NEGATIVE
Definition impl.cpp:9485

◆ test_mm_cmpistrm_sbyte_data

test_mm_cmpistrm_sbyte_data_t SSE2NEON::test_mm_cmpistrm_sbyte_data[TEST_MM_CMPISTRM_SBYTE_DATA_LEN]
static
Initial value:
= {
{{-11, -90, -128, 127, 66, 45, 23, 32, 99, 10, 0},
{-10, -90, -124, 33, 66, 45, 23, 22, 99, 100, 0},
{-115, -2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
{{13, 14, 55, 1, 32, 100, 101, 102, 103, 97, 23, 21, 45, 54, 55, 56},
{22, 109, 87, 45, 1, 103, 22, 102, 43, 87, 78, 56, 65, 55, 44, 33},
{0, 0, 0, -1, -1, -1, 0, -1, 0, 0, 0, -1, 0, -1, 0, 0}},
{{-31, -28, -9, 10, 45, 67, 88, 0},
{-30, -32, -33, -44, 93, 44, 9, 89, 0},
{-1, 0, 0, 0, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
{{34, -10, 78, -99, -100, 100, 0},
{34, 123, 88, 4, 34, -10, 78, -99, -100, 100, 34, -10, 78, -99, -100,
-100},
{0, 0, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
}
#define IMM_SBYTE_ANY_UNIT
Definition impl.cpp:10060
#define IMM_SBYTE_EACH_BIT_MASKED_NEGATIVE
Definition impl.cpp:10057

◆ test_mm_cmpistrm_sword_data

test_mm_cmpistrm_sword_data_t SSE2NEON::test_mm_cmpistrm_sword_data[TEST_MM_CMPISTRM_SWORD_DATA_LEN]
static
Initial value:
= {
{{-39, -10, 17, 89, 998, 1000, 1234, 4566},
{-40, -52, -39, -29, 100, 1024, 4565, 4600},
{0, 0, -1, -1, 0, 0, -1, 0}},
{{345, -1900, -10000, -30000, 50, 6789, 0},
{103, -1901, -10000, 32767, 50, 6780, 0},
{0, 0, -1, 0, -1, 0, -1, -1}},
{{677, 10001, 1001, 23, 0},
{345, 677, 10001, 1003, 1001, 32, 23, 677},
{0, -1, -1, 0, -1, 0, -1, -1}},
{{1024, -2288, 3752, -4096, 0},
{1024, 1024, -2288, 3752, -4096, 1024, -2288, 3752},
{0, -1, 0, 0, 0, -1, 0, 0}},
}
#define IMM_SWORD_RANGES_BIT
Definition impl.cpp:10086

◆ test_mm_cmpistrm_ubyte_data

test_mm_cmpistrm_ubyte_data_t SSE2NEON::test_mm_cmpistrm_ubyte_data[TEST_MM_CMPISTRM_UBYTE_DATA_LEN]
static
Initial value:
= {
{{88, 89, 90, 91, 92, 93, 0},
{78, 88, 99, 127, 92, 93, 0},
{0, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255}},
{{30, 41, 52, 63, 74, 85, 0},
{30, 42, 51, 63, 74, 85, 0},
{57, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
{{34, 32, 21, 16, 7, 0},
{34, 33, 32, 31, 30, 29, 10, 6, 0},
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}},
{{33, 21, 123, 89, 76, 56, 0},
{33, 21, 124, 33, 21, 123, 89, 76, 56, 33, 21, 123, 89, 76, 56, 22},
{0, 0, 0, 255, 0, 0, 0, 0, 0, 255, 0, 0, 0, 0, 0, 0}},
}
#define IMM_UBYTE_ORDERED_UNIT
Definition impl.cpp:10052
#define IMM_UBYTE_RANGES_UNIT
Definition impl.cpp:10050
#define IMM_UBYTE_EACH_UNIT
Definition impl.cpp:10041
#define IMM_UBYTE_ANY_BIT
Definition impl.cpp:10048

◆ test_mm_cmpistrm_uword_data

test_mm_cmpistrm_uword_data_t SSE2NEON::test_mm_cmpistrm_uword_data[TEST_MM_CMPISTRM_UWORD_DATA_LEN]
static
Initial value:
= {
{{1024, 2048, 4096, 5000, 0},
{1023, 1000, 2047, 1596, 5566, 5666, 4477, 9487},
{0, 0, 65535, 65535, 0, 0, 65535, 0}},
{{1, 2, 345, 7788, 10000, 0},
{2, 1, 345, 7788, 10000, 0},
{0, 0, 65535, 65535, 65535, 65535, 65535, 65535}},
{{100, 0},
{12345, 6766, 234, 0, 1, 34, 89, 100},
{0, 0, 0, 0, 0, 0, 0, 0}},
{{34, 122, 9000, 0},
{34, 122, 9000, 34, 122, 9000, 34, 122},
{0, 65535, 65535, 0, 65535, 65535, 0, 65535}},
}
#define IMM_UWORD_ANY_UNIT
Definition impl.cpp:10074
#define IMM_UWORD_ORDERED_UNIT_NEGATIVE
Definition impl.cpp:10080

◆ test_mm_cmpistro_sbyte_data

test_mm_cmpistri_sbyte_data_t SSE2NEON::test_mm_cmpistro_sbyte_data[TEST_MM_CMPISTRO_SBYTE_DATA_LEN]
static
Initial value:
= {
{{33, -33, 23, -32, -1, -1, 23, 46, 78, 34, 54, 100, 90, 91, 92, 101},
{32, 33, 23, -33, -2, -3, 23, 46, -78, 43, 56, 10, 9, 91, 90, 126},
0},
{{-1, -2, -3, -4, -5, -6, -7, -8, 87, 86, 85, 84, 83, 82, 81, 80},
{87, 79, 0},
1},
{{3, 4, 2, 0},
{3, 3, 4, 5, 6, 2, 0},
0},
{{23, 66, 1, 13, 17, 1, 13, 17, 0},
{23, 66, 1, 13, 17, 1, 13, 17, 32, 23, 66, 1, 13, 17, 1, 13},
1},
}
#define IMM_SBYTE_RANGES_MOST_NEGATIVE
Definition impl.cpp:9410

◆ test_mm_cmpistro_sword_data

test_mm_cmpistri_sword_data_t SSE2NEON::test_mm_cmpistro_sword_data[TEST_MM_CMPISTRO_SWORD_DATA_LEN]
static
Initial value:
= {
{{-10, -5, -100, -90, 45, 56, 1000, 1009},
{54, -1, -5, -6, 1001, 10001, 1009, 1009},
1},
{{456, -32768, 32767, 13, 0},
{455, -32768, 32767, 31, 0},
0},
{{23, 46, -44, 32000, 0},
{23, 66, -44, 678, 32000, 0},
0},
{{-7900, -101, -34, 666, 345, 0},
{-7900, -101, -34, 666, 345, -7900, -191, -34},
1},
}

◆ test_mm_cmpistro_ubyte_data

test_mm_cmpistri_ubyte_data_t SSE2NEON::test_mm_cmpistro_ubyte_data[TEST_MM_CMPISTRO_UBYTE_DATA_LEN]
static
Initial value:
= {
{{3, 4, 5, 0}, {5, 5, 5, 4, 3, 0}, IMM_UBYTE_ANY_LEAST, 1},
{{23, 127, 88, 3, 45, 6, 7, 2, 0},
{32, 127, 87, 2, 44, 32, 1, 2, 0},
1},
{{3, 4, 55, 56, 0},
{2, 3, 4, 5, 43, 54, 55, 56, 0},
0},
{{55, 66, 77, 11, 23, 0},
{55, 55, 66, 77, 11, 23, 55, 66, 77, 11, 23, 33, 123, 18, 0},
0},
}
#define IMM_UBYTE_EACH_MOST_NEGATIVE
Definition impl.cpp:9322

◆ test_mm_cmpistro_uword_data

test_mm_cmpistri_uword_data_t SSE2NEON::test_mm_cmpistro_uword_data[TEST_MM_CMPISTRO_UWORD_DATA_LEN]
static
Initial value:
= {
{{3333, 4444, 10000, 20000, 40000, 50000, 65535, 0},
{3332, 4443, 10000, 20001, 40000, 50000, 65534, 0},
0},
{{1, 2, 333, 4444, 55555, 7777, 23, 347},
{4444, 7777, 55555, 23, 347, 2, 1, 0},
1},
{{356, 380, 320, 456, 0},
{455, 379, 333, 319, 300, 299, 0},
1},
{{3, 1001, 235, 0},
{3, 1001, 235, 0, 3, 1001, 235, 0},
0},
}
#define IMM_UWORD_ORDERED_MOST_MASKED_NEGATIVE
Definition impl.cpp:9488

◆ test_mm_cmpistrs_sbyte_data

test_mm_cmpistri_sbyte_data_t SSE2NEON::test_mm_cmpistrs_sbyte_data[TEST_MM_CMPISTRS_SBYTE_DATA_LEN]
static
Initial value:
= {
{{100, 99, 98, 97, -67, -4, -5, -6, -7, -1, -2, -3, -128, -128, -128,
-128},
{0},
0},
{{-128, -128, -128, -128, 127, 127, 127, 127, -128, -128, -128, -128,
127, 127, 127, 127},
{-1, -2, -11, -98, -12, 0},
0},
{{0, 1, 2, 3, 4, 5, -6, -7},
{0, 1, 2, 3, 4, 5, 6, 7},
1},
{{0, 1, 0, -1, 0, -2, 0, 0, -3, 4, 0, 0, 5, 6, 7, 8},
{0},
1},
}

◆ test_mm_cmpistrs_sword_data

test_mm_cmpistri_sword_data_t SSE2NEON::test_mm_cmpistrs_sword_data[TEST_MM_CMPISTRS_SWORD_DATA_LEN]
static
Initial value:
= {
{{-32768, -32768, -32768, -32768, -32768, -32768, -32768, -3276},
{34, 45, 6, 7, 9, 8, 7, 6},
0},
{{1000, 2000, 4000, 8000, 16000, 32000, 32767, 0},
{3, 4, 56, 23, 0},
1},
{{0, 1, 3, 4, -32768, 9, 0, 1},
{56, 47, 43, 999, 1111, 0},
1},
{{1111, 1212, 831, 2345, 32767, 32767, -32768, 32767},
{0},
0},
}

◆ test_mm_cmpistrs_ubyte_data

test_mm_cmpistri_ubyte_data_t SSE2NEON::test_mm_cmpistrs_ubyte_data[TEST_MM_CMPISTRS_UBYTE_DATA_LEN]
static
Initial value:
= {
{{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16},
{1, 2, 3, 4, 5, 0},
0},
{{127, 126, 125, 124, 0},
{127, 1, 34, 43, 54, 0},
1},
{{127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127,
127, 127},
{56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 0},
0},
{{33, 44, 55, 78, 99, 100, 101, 102, 0},
{0},
1},
}

◆ test_mm_cmpistrs_uword_data

test_mm_cmpistri_uword_data_t SSE2NEON::test_mm_cmpistrs_uword_data[TEST_MM_CMPISTRS_UWORD_DATA_LEN]
static
Initial value:
= {
{{0, 1, 2, 3, 65535, 0, 0, 0},
{9, 8, 7, 6, 5, 4, 3, 2},
1},
{{4, 567, 65535, 32, 34, 0}, {0}, IMM_UWORD_ANY_LEAST, 1},
{{65535, 65535, 65535, 65535, 65535, 65535, 65535, 65535},
{1, 2, 3, 4, 900, 7890, 6767, 0},
0},
{{1, 2, 3, 4, 5, 6, 7, 8}, {1, 2, 3, 4, 0}, IMM_UWORD_ORDERED_LEAST, 0},
}

◆ test_mm_cmpistrz_sbyte_data

test_mm_cmpistri_sbyte_data_t SSE2NEON::test_mm_cmpistrz_sbyte_data[TEST_MM_CMPISTRZ_SBYTE_DATA_LEN]
static
Initial value:
= {
{{127, 126, 99, -100, 0},
{-128, -128, -128, -128, -128, -128, -128, -128, -128, -128, -128,
-128, -128, -128, -128, -128},
0},
{{120, 66, 54, 0}, {3, 4, 5, -99, -6, 0}, IMM_SBYTE_ANY_LEAST, 1},
{{0},
{127, 127, 127, 127, 126, 126, 126, 126, -127, -127, -127, -127, -1,
-1, -1, -1},
0},
{{12, 3, 4, 5, 6, 7, 8, 0},
{-1, -2, -3, -4, -6, 75, 0},
1},
}

◆ test_mm_cmpistrz_sword_data

test_mm_cmpistri_sword_data_t SSE2NEON::test_mm_cmpistrz_sword_data[TEST_MM_CMPISTRZ_SWORD_DATA_LEN]
static
Initial value:
= {
{{2, 22, 222, 2222, 22222, -2222, -222, -22},
{-32768, 32767, -32767, 32766, -32766, 32765, -32768, 32767},
0},
{{345, 10000, -10000, -30000, 0},
{1, 2, 3, 4, 5, 6, 7, 0},
1},
{{}, {0}, IMM_SWORD_ANY_LEAST, 1},
{{1, 2, -789, -1, -90, 0},
{1, 10, 100, 1000, 10000, -10000, -1000, 1000},
0},
}

◆ test_mm_cmpistrz_ubyte_data

test_mm_cmpistri_ubyte_data_t SSE2NEON::test_mm_cmpistrz_ubyte_data[TEST_MM_CMPISTRZ_UBYTE_DATA_LEN]
static
Initial value:
= {
{{0},
{255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
255, 255},
0},
{{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16},
{1, 1, 1, 1, 2, 2, 2, 2, 4, 5, 6, 7, 89, 89, 89, 89},
0},
{{1, 2, 3, 4, 0}, {}, IMM_UBYTE_RANGES_LEAST, 1},
{{127, 126, 125, 124, 124, 0},
{100, 101, 123, 100, 111, 122, 0},
1},
}

◆ test_mm_cmpistrz_uword_data

test_mm_cmpistri_uword_data_t SSE2NEON::test_mm_cmpistrz_uword_data[TEST_MM_CMPISTRZ_UWORD_DATA_LEN]
static
Initial value:
= {
{{10000, 20000, 50000, 40000, 0},
{65535, 65533, 60000, 60000, 50000, 123, 1, 2},
0},
{{0},
{65528, 65529, 65530, 65531, 65532, 65533, 65534, 65535},
0},
{{3, 333, 3333, 33333, 0}, {0}, IMM_UWORD_RANGES_LEAST, 1},
{{123, 456, 7, 890, 0},
{123, 456, 7, 900, 0},
1},
}

◆ TWOPOWER64

const double SSE2NEON::TWOPOWER64 = pow(2, 64)