Vector Optimized Library of Kernels 3.1.1
Architecture-tuned implementations of math kernels
 
Loading...
Searching...
No Matches
impl.cpp File Reference
#include <assert.h>
#include <float.h>
#include <inttypes.h>
#include <math.h>
#include <stdalign.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <utility>
#include "binding.h"
#include "impl.h"

Data Structures

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

Namespaces

namespace  SSE2NEON
 

Macros

#define MAX_TEST_VALUE   10000
 
#define PRIMITIVE_CAT(a, ...)   a##__VA_ARGS__
 
#define IIF(c)   PRIMITIVE_CAT(IIF_, c)
 
#define IIF_0(t, ...)   __VA_ARGS__
 
#define IIF_1(t, ...)   t
 
#define _(x)   #x,
 
#define SSE2NEON_INIT_RNG(seed)
 
#define XT(x)   (((x) << 1) ^ ((((x) >> 7) & 1) * 0x1b))
 
#define MULTIPLY(x, y)
 
#define TEST_IMPL(IDX)
 
#define TEST_IMPL(IDX)
 
#define TEST_IMPL(IDX)
 
#define TEST_IMPL(IDX)
 
#define TEST_IMPL(IDX)
 
#define TEST_IMPL(IDX)
 
#define TEST_IMPL(IDX)
 
#define TEST_IMPL(IDX)
 
#define TEST_IMPL(IDX)
 
#define TEST_IMPL(IDX)
 
#define TEST_IMPL(IDX)
 
#define TEST_IMPL(IDX)
 
#define TEST_IMPL(IDX)
 
#define TEST_IMPL(IDX)
 
#define MM_DP_PD_TEST_CASE_WITH(imm8)
 
#define GENERATE_MM_DP_PD_TEST_CASES
 
#define MM_DP_PS_TEST_CASE_WITH(IMM)
 
#define GENERATE_MM_DP_PS_TEST_CASES
 
#define TEST_IMPL(IDX)
 
#define TEST_IMPL(IDX)
 
#define TEST_IMPL(IDX)
 
#define TEST_IMPL(IDX)
 
#define TEST_IMPL(IDX)
 
#define TEST_IMPL(IDX)
 
#define TEST_IMPL(IDX)
 
#define TEST_IMPL(IDX)
 
#define TEST_IMPL(IDX)
 
#define IS_CMPESTRI   1
 
#define DEF_ENUM_MM_CMPESTRX_VARIANT(c, ...)   c,
 
#define EVAL_MM_CMPESTRX_TEST_CASE(c, type, data_type, im, IM)
 
#define ENUM_MM_CMPESTRX_TEST_CASES(type, type_lower, data_type, func, FUNC, IM)
 
#define IMM_UBYTE_EACH_LEAST    (_SIDD_UBYTE_OPS | _SIDD_CMP_EQUAL_EACH | _SIDD_LEAST_SIGNIFICANT)
 
#define IMM_UBYTE_EACH_LEAST_NEGATIVE
 
#define IMM_UBYTE_EACH_LEAST_MASKED_NEGATIVE
 
#define IMM_UBYTE_EACH_MOST    (_SIDD_UBYTE_OPS | _SIDD_CMP_EQUAL_EACH | _SIDD_MOST_SIGNIFICANT)
 
#define IMM_UBYTE_EACH_MOST_NEGATIVE
 
#define IMM_UBYTE_EACH_MOST_MASKED_NEGATIVE
 
#define IMM_UBYTE_ANY_LEAST    (_SIDD_UBYTE_OPS | _SIDD_CMP_EQUAL_ANY | _SIDD_LEAST_SIGNIFICANT)
 
#define IMM_UBYTE_ANY_LEAST_NEGATIVE
 
#define IMM_UBYTE_ANY_LEAST_MASKED_NEGATIVE
 
#define IMM_UBYTE_ANY_MOST    (_SIDD_UBYTE_OPS | _SIDD_CMP_EQUAL_ANY | _SIDD_MOST_SIGNIFICANT)
 
#define IMM_UBYTE_ANY_MOST_NEGATIVE
 
#define IMM_UBYTE_ANY_MOST_MASKED_NEGATIVE
 
#define IMM_UBYTE_RANGES_LEAST    (_SIDD_UBYTE_OPS | _SIDD_CMP_RANGES | _SIDD_LEAST_SIGNIFICANT)
 
#define IMM_UBYTE_RANGES_MOST    (_SIDD_UBYTE_OPS | _SIDD_CMP_RANGES | _SIDD_MOST_SIGNIFICANT)
 
#define IMM_UBYTE_RANGES_LEAST_NEGATIVE
 
#define IMM_UBYTE_RANGES_MOST_NEGATIVE
 
#define IMM_UBYTE_RANGES_LEAST_MASKED_NEGATIVE
 
#define IMM_UBYTE_RANGES_MOST_MASKED_NEGATIVE
 
#define IMM_UBYTE_ORDERED_LEAST    (_SIDD_UBYTE_OPS | _SIDD_CMP_EQUAL_ORDERED | _SIDD_LEAST_SIGNIFICANT)
 
#define IMM_UBYTE_ORDERED_LEAST_NEGATIVE
 
#define IMM_UBYTE_ORDERED_MOST    (_SIDD_UBYTE_OPS | _SIDD_CMP_EQUAL_ORDERED | _SIDD_MOST_SIGNIFICANT)
 
#define IMM_UBYTE_ORDERED_MOST_NEGATIVE
 
#define IMM_UBYTE_ORDERED_MOST_MASKED_NEGATIVE
 
#define IMM_SBYTE_EACH_LEAST    (_SIDD_SBYTE_OPS | _SIDD_CMP_EQUAL_EACH | _SIDD_LEAST_SIGNIFICANT)
 
#define IMM_SBYTE_EACH_LEAST_NEGATIVE
 
#define IMM_SBYTE_EACH_LEAST_MASKED_NEGATIVE
 
#define IMM_SBYTE_EACH_MOST    (_SIDD_SBYTE_OPS | _SIDD_CMP_EQUAL_EACH | _SIDD_MOST_SIGNIFICANT)
 
#define IMM_SBYTE_EACH_MOST_NEGATIVE
 
#define IMM_SBYTE_EACH_MOST_MASKED_NEGATIVE
 
#define IMM_SBYTE_ANY_LEAST    (_SIDD_SBYTE_OPS | _SIDD_CMP_EQUAL_ANY | _SIDD_LEAST_SIGNIFICANT)
 
#define IMM_SBYTE_ANY_LEAST_NEGATIVE
 
#define IMM_SBYTE_ANY_MOST    (_SIDD_SBYTE_OPS | _SIDD_CMP_EQUAL_ANY | _SIDD_MOST_SIGNIFICANT)
 
#define IMM_SBYTE_ANY_MOST_MASKED_NEGATIVE
 
#define IMM_SBYTE_RANGES_LEAST    (_SIDD_SBYTE_OPS | _SIDD_CMP_RANGES | _SIDD_LEAST_SIGNIFICANT)
 
#define IMM_SBYTE_RANGES_LEAST_NEGATIVE
 
#define IMM_SBYTE_RANGES_LEAST_MASKED_NEGATIVE
 
#define IMM_SBYTE_RANGES_MOST    (_SIDD_SBYTE_OPS | _SIDD_CMP_RANGES | _SIDD_MOST_SIGNIFICANT)
 
#define IMM_SBYTE_RANGES_MOST_NEGATIVE
 
#define IMM_SBYTE_RANGES_MOST_MASKED_NEGATIVE
 
#define IMM_SBYTE_ORDERED_LEAST    (_SIDD_SBYTE_OPS | _SIDD_CMP_EQUAL_ORDERED | _SIDD_LEAST_SIGNIFICANT)
 
#define IMM_SBYTE_ORDERED_LEAST_NEGATIVE
 
#define IMM_SBYTE_ORDERED_LEAST_MASKED_NEGATIVE
 
#define IMM_SBYTE_ORDERED_MOST_NEGATIVE
 
#define IMM_SBYTE_ORDERED_MOST    (_SIDD_SBYTE_OPS | _SIDD_CMP_EQUAL_ORDERED | _SIDD_MOST_SIGNIFICANT)
 
#define IMM_SBYTE_ORDERED_MOST_MASKED_NEGATIVE
 
#define IMM_UWORD_RANGES_LEAST    (_SIDD_UWORD_OPS | _SIDD_CMP_RANGES | _SIDD_LEAST_SIGNIFICANT)
 
#define IMM_UWORD_RANGES_LEAST_NEGATIVE
 
#define IMM_UWORD_RANGES_LEAST_MASKED_NEGATIVE
 
#define IMM_UWORD_RANGES_MOST    (_SIDD_UWORD_OPS | _SIDD_CMP_RANGES | _SIDD_MOST_SIGNIFICANT)
 
#define IMM_UWORD_RANGES_MOST_NEGATIVE
 
#define IMM_UWORD_RANGES_MOST_MASKED_NEGATIVE
 
#define IMM_UWORD_EACH_LEAST    (_SIDD_UWORD_OPS | _SIDD_CMP_EQUAL_EACH | _SIDD_LEAST_SIGNIFICANT)
 
#define IMM_UWORD_EACH_MOST    (_SIDD_UWORD_OPS | _SIDD_CMP_EQUAL_EACH | _SIDD_MOST_SIGNIFICANT)
 
#define IMM_UWORD_EACH_LEAST_NEGATIVE
 
#define IMM_UWORD_EACH_LEAST_MASKED_NEGATIVE
 
#define IMM_UWORD_EACH_MOST_MASKED_NEGATIVE
 
#define IMM_UWORD_ANY_LEAST    (_SIDD_UWORD_OPS | _SIDD_CMP_EQUAL_ANY | _SIDD_LEAST_SIGNIFICANT)
 
#define IMM_UWORD_ANY_MOST    (_SIDD_UWORD_OPS | _SIDD_CMP_EQUAL_ANY | _SIDD_MOST_SIGNIFICANT)
 
#define IMM_UWORD_ANY_MOST_NEGATIVE
 
#define IMM_UWORD_ANY_LEAST_NEGATIVE
 
#define IMM_UWORD_ANY_LEAST_MASKED_NEGATIVE
 
#define IMM_UWORD_ORDERED_LEAST    (_SIDD_UWORD_OPS | _SIDD_CMP_EQUAL_ORDERED | _SIDD_LEAST_SIGNIFICANT)
 
#define IMM_UWORD_ORDERED_LEAST_NEGATIVE
 
#define IMM_UWORD_ORDERED_LEAST_MASKED_NEGATIVE
 
#define IMM_UWORD_ORDERED_MOST    (_SIDD_UWORD_OPS | _SIDD_CMP_EQUAL_ORDERED | _SIDD_MOST_SIGNIFICANT)
 
#define IMM_UWORD_ORDERED_MOST_NEGATIVE
 
#define IMM_UWORD_ORDERED_MOST_MASKED_NEGATIVE
 
#define IMM_SWORD_RANGES_LEAST    (_SIDD_SWORD_OPS | _SIDD_CMP_RANGES | _SIDD_LEAST_SIGNIFICANT)
 
#define IMM_SWORD_RANGES_MOST    (_SIDD_SWORD_OPS | _SIDD_CMP_RANGES | _SIDD_MOST_SIGNIFICANT)
 
#define IMM_SWORD_RANGES_LEAST_NEGATIVE
 
#define IMM_SWORD_RANGES_LEAST_MASKED_NEGATIVE
 
#define IMM_SWORD_RANGES_MOST_MASKED_NEGATIVE
 
#define IMM_SWORD_EACH_LEAST    (_SIDD_SWORD_OPS | _SIDD_CMP_EQUAL_EACH | _SIDD_LEAST_SIGNIFICANT)
 
#define IMM_SWORD_EACH_MOST    (_SIDD_SWORD_OPS | _SIDD_CMP_EQUAL_EACH | _SIDD_MOST_SIGNIFICANT)
 
#define IMM_SWORD_EACH_LEAST_NEGATIVE
 
#define IMM_SWORD_EACH_LEAST_MASKED_NEGATIVE
 
#define IMM_SWORD_EACH_MOST_NEGATIVE
 
#define IMM_SWORD_EACH_MOST_MASKED_NEGATIVE
 
#define IMM_SWORD_ANY_LEAST    (_SIDD_SWORD_OPS | _SIDD_CMP_EQUAL_ANY | _SIDD_LEAST_SIGNIFICANT)
 
#define IMM_SWORD_ANY_LEAST_NEGATIVE    (_SIDD_SWORD_OPS | _SIDD_CMP_EQUAL_ANY | _SIDD_LEAST_SIGNIFICANT)
 
#define IMM_SWORD_ANY_LEAST_MASKED_NEGATIVE
 
#define IMM_SWORD_ANY_MOST    (_SIDD_SWORD_OPS | _SIDD_CMP_EQUAL_ANY | _SIDD_MOST_SIGNIFICANT)
 
#define IMM_SWORD_ANY_MOST_NEGATIVE
 
#define IMM_SWORD_ANY_MOST_MASKED_NEGATIVE
 
#define IMM_SWORD_ANY_MOST_MASKED_NEGATIVE
 
#define IMM_SWORD_ORDERED_LEAST    (_SIDD_SWORD_OPS | _SIDD_CMP_EQUAL_ORDERED | _SIDD_LEAST_SIGNIFICANT)
 
#define IMM_SWORD_ORDERED_LEAST_NEGATIVE
 
#define IMM_SWORD_ORDERED_LEAST_MASKED_NEGATIVE
 
#define IMM_SWORD_ORDERED_MOST    (_SIDD_SWORD_OPS | _SIDD_CMP_EQUAL_ORDERED | _SIDD_MOST_SIGNIFICANT)
 
#define IMM_SWORD_ORDERED_MOST_MASKED_NEGATIVE
 
#define TEST_MM_CMPESTRA_UBYTE_DATA_LEN   3
 
#define TEST_MM_CMPESTRA_SBYTE_DATA_LEN   3
 
#define TEST_MM_CMPESTRA_UWORD_DATA_LEN   3
 
#define TEST_MM_CMPESTRA_SWORD_DATA_LEN   3
 
#define MM_CMPESTRA_UBYTE_TEST_CASES(_, ...)
 
#define MM_CMPESTRA_SBYTE_TEST_CASES(_, ...)
 
#define MM_CMPESTRA_UWORD_TEST_CASES(_, ...)
 
#define MM_CMPESTRA_SWORD_TEST_CASES(_, ...)
 
#define GENERATE_MM_CMPESTRA_TEST_CASES
 
#define TEST_MM_CMPESTRC_UBYTE_DATA_LEN   4
 
#define TEST_MM_CMPESTRC_SBYTE_DATA_LEN   4
 
#define TEST_MM_CMPESTRC_UWORD_DATA_LEN   4
 
#define TEST_MM_CMPESTRC_SWORD_DATA_LEN   4
 
#define MM_CMPESTRC_UBYTE_TEST_CASES(_, ...)
 
#define MM_CMPESTRC_SBYTE_TEST_CASES(_, ...)
 
#define MM_CMPESTRC_UWORD_TEST_CASES(_, ...)
 
#define MM_CMPESTRC_SWORD_TEST_CASES(_, ...)
 
#define GENERATE_MM_CMPESTRC_TEST_CASES
 
#define TEST_MM_CMPESTRI_UBYTE_DATA_LEN   4
 
#define TEST_MM_CMPESTRI_SBYTE_DATA_LEN   4
 
#define TEST_MM_CMPESTRI_UWORD_DATA_LEN   4
 
#define TEST_MM_CMPESTRI_SWORD_DATA_LEN   4
 
#define MM_CMPESTRI_UBYTE_TEST_CASES(_, ...)
 
#define MM_CMPESTRI_SBYTE_TEST_CASES(_, ...)
 
#define MM_CMPESTRI_UWORD_TEST_CASES(_, ...)
 
#define MM_CMPESTRI_SWORD_TEST_CASES(_, ...)
 
#define GENERATE_MM_CMPESTRI_TEST_CASES
 
#define IS_CMPESTRM   0
 
#define IMM_UBYTE_EACH_UNIT    (_SIDD_UBYTE_OPS | _SIDD_CMP_EQUAL_EACH | _SIDD_UNIT_MASK)
 
#define IMM_UBYTE_EACH_UNIT_NEGATIVE
 
#define IMM_UBYTE_ANY_UNIT    (_SIDD_UBYTE_OPS | _SIDD_CMP_EQUAL_ANY | _SIDD_UNIT_MASK)
 
#define IMM_UBYTE_ANY_BIT    (_SIDD_UBYTE_OPS | _SIDD_CMP_EQUAL_ANY | _SIDD_BIT_MASK)
 
#define IMM_UBYTE_RANGES_UNIT    (_SIDD_UBYTE_OPS | _SIDD_CMP_RANGES | _SIDD_UNIT_MASK)
 
#define IMM_UBYTE_ORDERED_UNIT    (_SIDD_UBYTE_OPS | _SIDD_CMP_EQUAL_ORDERED | _SIDD_UNIT_MASK)
 
#define IMM_SBYTE_EACH_UNIT    (_SIDD_SBYTE_OPS | _SIDD_CMP_EQUAL_EACH | _SIDD_UNIT_MASK)
 
#define IMM_SBYTE_EACH_BIT_MASKED_NEGATIVE
 
#define IMM_SBYTE_ANY_UNIT    (_SIDD_SBYTE_OPS | _SIDD_CMP_EQUAL_ANY | _SIDD_UNIT_MASK)
 
#define IMM_SBYTE_ANY_UNIT_MASKED_NEGATIVE
 
#define IMM_SBYTE_RANGES_UNIT    (_SIDD_SBYTE_OPS | _SIDD_CMP_RANGES | _SIDD_UNIT_MASK)
 
#define IMM_SBYTE_ORDERED_UNIT    (_SIDD_SBYTE_OPS | _SIDD_CMP_EQUAL_ORDERED | _SIDD_UNIT_MASK)
 
#define IMM_UWORD_RANGES_UNIT    (_SIDD_UWORD_OPS | _SIDD_CMP_RANGES | _SIDD_UNIT_MASK)
 
#define IMM_UWORD_EACH_UNIT    (_SIDD_UWORD_OPS | _SIDD_CMP_EQUAL_EACH | _SIDD_UNIT_MASK)
 
#define IMM_UWORD_ANY_UNIT    (_SIDD_UWORD_OPS | _SIDD_CMP_EQUAL_ANY | _SIDD_UNIT_MASK)
 
#define IMM_UWORD_ANY_BIT    (_SIDD_UWORD_OPS | _SIDD_CMP_EQUAL_ANY | _SIDD_BIT_MASK)
 
#define IMM_UWORD_ORDERED_UNIT    (_SIDD_UWORD_OPS | _SIDD_CMP_EQUAL_ORDERED | _SIDD_UNIT_MASK)
 
#define IMM_UWORD_ORDERED_UNIT_NEGATIVE
 
#define IMM_SWORD_RANGES_UNIT    (_SIDD_SWORD_OPS | _SIDD_CMP_RANGES | _SIDD_UNIT_MASK)
 
#define IMM_SWORD_RANGES_BIT    (_SIDD_SWORD_OPS | _SIDD_CMP_RANGES | _SIDD_BIT_MASK)
 
#define IMM_SWORD_EACH_UNIT    (_SIDD_SWORD_OPS | _SIDD_CMP_EQUAL_EACH | _SIDD_UNIT_MASK)
 
#define IMM_SWORD_ANY_UNIT    (_SIDD_SWORD_OPS | _SIDD_CMP_EQUAL_ANY | _SIDD_UNIT_MASK)
 
#define IMM_SWORD_ORDERED_UNIT    (_SIDD_SWORD_OPS | _SIDD_CMP_EQUAL_ORDERED | _SIDD_UNIT_MASK)
 
#define TEST_MM_CMPESTRM_UBYTE_DATA_LEN   4
 
#define TEST_MM_CMPESTRM_SBYTE_DATA_LEN   4
 
#define TEST_MM_CMPESTRM_UWORD_DATA_LEN   4
 
#define TEST_MM_CMPESTRM_SWORD_DATA_LEN   4
 
#define MM_CMPESTRM_UBYTE_TEST_CASES(_, ...)
 
#define MM_CMPESTRM_SBYTE_TEST_CASES(_, ...)
 
#define MM_CMPESTRM_UWORD_TEST_CASES(_, ...)
 
#define MM_CMPESTRM_SWORD_TEST_CASES(_, ...)
 
#define GENERATE_MM_CMPESTRM_TEST_CASES
 
#define TEST_MM_CMPESTRO_UBYTE_DATA_LEN   4
 
#define TEST_MM_CMPESTRO_SBYTE_DATA_LEN   4
 
#define TEST_MM_CMPESTRO_UWORD_DATA_LEN   4
 
#define TEST_MM_CMPESTRO_SWORD_DATA_LEN   4
 
#define MM_CMPESTRO_UBYTE_TEST_CASES(_, ...)
 
#define MM_CMPESTRO_SBYTE_TEST_CASES(_, ...)
 
#define MM_CMPESTRO_UWORD_TEST_CASES(_, ...)
 
#define MM_CMPESTRO_SWORD_TEST_CASES(_, ...)
 
#define GENERATE_MM_CMPESTRO_TEST_CASES
 
#define TEST_MM_CMPESTRS_UBYTE_DATA_LEN   2
 
#define TEST_MM_CMPESTRS_SBYTE_DATA_LEN   2
 
#define TEST_MM_CMPESTRS_UWORD_DATA_LEN   2
 
#define TEST_MM_CMPESTRS_SWORD_DATA_LEN   2
 
#define MM_CMPESTRS_UBYTE_TEST_CASES(_, ...)
 
#define MM_CMPESTRS_SBYTE_TEST_CASES(_, ...)
 
#define MM_CMPESTRS_UWORD_TEST_CASES(_, ...)
 
#define MM_CMPESTRS_SWORD_TEST_CASES(_, ...)
 
#define GENERATE_MM_CMPESTRS_TEST_CASES
 
#define TEST_MM_CMPESTRZ_UBYTE_DATA_LEN   2
 
#define TEST_MM_CMPESTRZ_SBYTE_DATA_LEN   2
 
#define TEST_MM_CMPESTRZ_UWORD_DATA_LEN   2
 
#define TEST_MM_CMPESTRZ_SWORD_DATA_LEN   2
 
#define MM_CMPESTRZ_UBYTE_TEST_CASES(_, ...)
 
#define MM_CMPESTRZ_SBYTE_TEST_CASES(_, ...)
 
#define MM_CMPESTRZ_UWORD_TEST_CASES(_, ...)
 
#define MM_CMPESTRZ_SWORD_TEST_CASES(_, ...)
 
#define GENERATE_MM_CMPESTRZ_TEST_CASES
 
#define IS_CMPISTRI   1
 
#define DEF_ENUM_MM_CMPISTRX_VARIANT(c, ...)   c,
 
#define EVAL_MM_CMPISTRX_TEST_CASE(c, type, data_type, im, IM)
 
#define ENUM_MM_CMPISTRX_TEST_CASES(type, type_lower, data_type, func, FUNC, IM)
 
#define TEST_MM_CMPISTRA_UBYTE_DATA_LEN   4
 
#define TEST_MM_CMPISTRA_SBYTE_DATA_LEN   4
 
#define TEST_MM_CMPISTRA_UWORD_DATA_LEN   4
 
#define TEST_MM_CMPISTRA_SWORD_DATA_LEN   4
 
#define MM_CMPISTRA_UBYTE_TEST_CASES(_, ...)
 
#define MM_CMPISTRA_SBYTE_TEST_CASES(_, ...)
 
#define MM_CMPISTRA_UWORD_TEST_CASES(_, ...)
 
#define MM_CMPISTRA_SWORD_TEST_CASES(_, ...)
 
#define GENERATE_MM_CMPISTRA_TEST_CASES
 
#define TEST_MM_CMPISTRC_UBYTE_DATA_LEN   4
 
#define TEST_MM_CMPISTRC_SBYTE_DATA_LEN   4
 
#define TEST_MM_CMPISTRC_UWORD_DATA_LEN   4
 
#define TEST_MM_CMPISTRC_SWORD_DATA_LEN   4
 
#define MM_CMPISTRC_UBYTE_TEST_CASES(_, ...)
 
#define MM_CMPISTRC_SBYTE_TEST_CASES(_, ...)
 
#define MM_CMPISTRC_UWORD_TEST_CASES(_, ...)
 
#define MM_CMPISTRC_SWORD_TEST_CASES(_, ...)
 
#define GENERATE_MM_CMPISTRC_TEST_CASES
 
#define TEST_MM_CMPISTRI_UBYTE_DATA_LEN   4
 
#define TEST_MM_CMPISTRI_SBYTE_DATA_LEN   4
 
#define TEST_MM_CMPISTRI_UWORD_DATA_LEN   4
 
#define TEST_MM_CMPISTRI_SWORD_DATA_LEN   4
 
#define MM_CMPISTRI_UBYTE_TEST_CASES(_, ...)
 
#define MM_CMPISTRI_SBYTE_TEST_CASES(_, ...)
 
#define MM_CMPISTRI_UWORD_TEST_CASES(_, ...)
 
#define MM_CMPISTRI_SWORD_TEST_CASES(_, ...)
 
#define GENERATE_MM_CMPISTRI_TEST_CASES
 
#define IS_CMPISTRM   0
 
#define TEST_MM_CMPISTRM_UBYTE_DATA_LEN   4
 
#define TEST_MM_CMPISTRM_SBYTE_DATA_LEN   4
 
#define TEST_MM_CMPISTRM_UWORD_DATA_LEN   4
 
#define TEST_MM_CMPISTRM_SWORD_DATA_LEN   4
 
#define MM_CMPISTRM_UBYTE_TEST_CASES(_, ...)
 
#define MM_CMPISTRM_SBYTE_TEST_CASES(_, ...)
 
#define MM_CMPISTRM_UWORD_TEST_CASES(_, ...)
 
#define MM_CMPISTRM_SWORD_TEST_CASES(_, ...)
 
#define GENERATE_MM_CMPISTRM_TEST_CASES
 
#define TEST_MM_CMPISTRO_UBYTE_DATA_LEN   4
 
#define TEST_MM_CMPISTRO_SBYTE_DATA_LEN   4
 
#define TEST_MM_CMPISTRO_UWORD_DATA_LEN   4
 
#define TEST_MM_CMPISTRO_SWORD_DATA_LEN   4
 
#define MM_CMPISTRO_UBYTE_TEST_CASES(_, ...)
 
#define MM_CMPISTRO_SBYTE_TEST_CASES(_, ...)
 
#define MM_CMPISTRO_UWORD_TEST_CASES(_, ...)
 
#define MM_CMPISTRO_SWORD_TEST_CASES(_, ...)
 
#define GENERATE_MM_CMPISTRO_TEST_CASES
 
#define TEST_MM_CMPISTRS_UBYTE_DATA_LEN   4
 
#define TEST_MM_CMPISTRS_SBYTE_DATA_LEN   4
 
#define TEST_MM_CMPISTRS_UWORD_DATA_LEN   4
 
#define TEST_MM_CMPISTRS_SWORD_DATA_LEN   4
 
#define MM_CMPISTRS_UBYTE_TEST_CASES(_, ...)
 
#define MM_CMPISTRS_SBYTE_TEST_CASES(_, ...)
 
#define MM_CMPISTRS_UWORD_TEST_CASES(_, ...)
 
#define MM_CMPISTRS_SWORD_TEST_CASES(_, ...)
 
#define GENERATE_MM_CMPISTRS_TEST_CASES
 
#define TEST_MM_CMPISTRZ_UBYTE_DATA_LEN   4
 
#define TEST_MM_CMPISTRZ_SBYTE_DATA_LEN   4
 
#define TEST_MM_CMPISTRZ_UWORD_DATA_LEN   4
 
#define TEST_MM_CMPISTRZ_SWORD_DATA_LEN   4
 
#define MM_CMPISTRZ_UBYTE_TEST_CASES(_, ...)
 
#define MM_CMPISTRZ_SBYTE_TEST_CASES(_, ...)
 
#define MM_CMPISTRZ_UWORD_TEST_CASES(_, ...)
 
#define MM_CMPISTRZ_SWORD_TEST_CASES(_, ...)
 
#define GENERATE_MM_CMPISTRZ_TEST_CASES
 
#define TEST_IMPL(IDX)
 
#define _(x)
 

Functions

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

Variables

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

Macro Definition Documentation

◆ _ [1/2]

#define _ (   x)    #x,

◆ _ [2/2]

#define _ (   x)
Value:
case it_##x: \
ret = test_##x(*this, i); \
break;
for i
Definition: volk_config_fixed.tmpl.h:13

◆ DEF_ENUM_MM_CMPESTRX_VARIANT

#define DEF_ENUM_MM_CMPESTRX_VARIANT (   c,
  ... 
)    c,

◆ DEF_ENUM_MM_CMPISTRX_VARIANT

#define DEF_ENUM_MM_CMPISTRX_VARIANT (   c,
  ... 
)    c,

◆ ENUM_MM_CMPESTRX_TEST_CASES

#define ENUM_MM_CMPESTRX_TEST_CASES (   type,
  type_lower,
  data_type,
  func,
  FUNC,
  IM 
)
Value:
enum { MM_##FUNC##_##type##_TEST_CASES(DEF_ENUM_MM_CMPESTRX_VARIANT) }; \
MM_##FUNC##_##type##_TEST_CASES(EVAL_MM_CMPESTRX_TEST_CASE, type_lower, \
data_type, func, IM)
#define DEF_ENUM_MM_CMPESTRX_VARIANT(c,...)
Definition: impl.cpp:9284
#define EVAL_MM_CMPESTRX_TEST_CASE(c, type, data_type, im, IM)
Definition: impl.cpp:9286
#define _(x)

◆ ENUM_MM_CMPISTRX_TEST_CASES

#define ENUM_MM_CMPISTRX_TEST_CASES (   type,
  type_lower,
  data_type,
  func,
  FUNC,
  IM 
)
Value:
enum { MM_##FUNC##_##type##_TEST_CASES(DEF_ENUM_MM_CMPISTRX_VARIANT) }; \
MM_##FUNC##_##type##_TEST_CASES(EVAL_MM_CMPISTRX_TEST_CASE, type_lower, \
data_type, func, IM)
#define EVAL_MM_CMPISTRX_TEST_CASE(c, type, data_type, im, IM)
Definition: impl.cpp:10621
#define DEF_ENUM_MM_CMPISTRX_VARIANT(c,...)
Definition: impl.cpp:10619

◆ EVAL_MM_CMPESTRX_TEST_CASE

#define EVAL_MM_CMPESTRX_TEST_CASE (   c,
  type,
  data_type,
  im,
  IM 
)
Value:
do { \
data_type *a = test_mm_##im##_##type##_data[c].a, \
*b = test_mm_##im##_##type##_data[c].b; \
int la = test_mm_##im##_##type##_data[c].la, \
lb = test_mm_##im##_##type##_data[c].lb; \
const int imm8 = IMM_##c; \
IIF(IM) \
(int expect = test_mm_##im##_##type##_data[c].expect, \
data_type *expect = test_mm_##im##_##type##_data[c].expect); \
__m128i ma, mb; \
memcpy(&ma, a, sizeof(ma)); \
memcpy(&mb, b, sizeof(mb)); \
IIF(IM) \
(int res = _mm_##im(ma, la, mb, lb, imm8), \
__m128i res = _mm_##im(ma, la, mb, lb, imm8)); \
if (IIF(IM)(res != expect, memcmp(expect, &res, sizeof(__m128i)))) \
return TEST_FAIL; \
} while (0);
#define IIF(c)
Definition: impl.cpp:25
int64x2_t __m128i
Definition: sse2neon.h:375

◆ EVAL_MM_CMPISTRX_TEST_CASE

#define EVAL_MM_CMPISTRX_TEST_CASE (   c,
  type,
  data_type,
  im,
  IM 
)
Value:
do { \
data_type *a = test_mm_##im##_##type##_data[c].a, \
*b = test_mm_##im##_##type##_data[c].b; \
const int imm8 = IMM_##c; \
IIF(IM) \
(int expect = test_mm_##im##_##type##_data[c].expect, \
data_type *expect = test_mm_##im##_##type##_data[c].expect); \
__m128i ma, mb; \
memcpy(&ma, a, sizeof(ma)); \
memcpy(&mb, b, sizeof(mb)); \
IIF(IM) \
(int res = _mm_##im(ma, mb, imm8), \
__m128i res = _mm_##im(ma, mb, imm8)); \
if (IIF(IM)(res != expect, memcmp(expect, &res, sizeof(__m128i)))) \
return TEST_FAIL; \
} while (0);

◆ GENERATE_MM_CMPESTRA_TEST_CASES

#define GENERATE_MM_CMPESTRA_TEST_CASES
Value:
ENUM_MM_CMPESTRX_TEST_CASES(UBYTE, ubyte, uint8_t, cmpestra, CMPESTRA, \
ENUM_MM_CMPESTRX_TEST_CASES(SBYTE, sbyte, int8_t, cmpestra, CMPESTRA, \
ENUM_MM_CMPESTRX_TEST_CASES(UWORD, uword, uint16_t, cmpestra, CMPESTRA, \
ENUM_MM_CMPESTRX_TEST_CASES(SWORD, sword, int16_t, cmpestra, CMPESTRA, \
#define IS_CMPESTRI
Definition: impl.cpp:9282
#define ENUM_MM_CMPESTRX_TEST_CASES(type, type_lower, data_type, func, FUNC, IM)
Definition: impl.cpp:9306

◆ GENERATE_MM_CMPESTRC_TEST_CASES

#define GENERATE_MM_CMPESTRC_TEST_CASES
Value:
ENUM_MM_CMPESTRX_TEST_CASES(UBYTE, ubyte, uint8_t, cmpestrc, CMPESTRC, \
ENUM_MM_CMPESTRX_TEST_CASES(SBYTE, sbyte, int8_t, cmpestrc, CMPESTRC, \
ENUM_MM_CMPESTRX_TEST_CASES(UWORD, uword, uint16_t, cmpestrc, CMPESTRC, \
ENUM_MM_CMPESTRX_TEST_CASES(SWORD, sword, int16_t, cmpestrc, CMPESTRC, \

◆ GENERATE_MM_CMPESTRI_TEST_CASES

#define GENERATE_MM_CMPESTRI_TEST_CASES
Value:
ENUM_MM_CMPESTRX_TEST_CASES(UBYTE, ubyte, uint8_t, cmpestri, CMPESTRI, \
ENUM_MM_CMPESTRX_TEST_CASES(SBYTE, sbyte, int8_t, cmpestri, CMPESTRI, \
ENUM_MM_CMPESTRX_TEST_CASES(UWORD, uword, uint16_t, cmpestri, CMPESTRI, \
ENUM_MM_CMPESTRX_TEST_CASES(SWORD, sword, int16_t, cmpestri, CMPESTRI, \

◆ GENERATE_MM_CMPESTRM_TEST_CASES

#define GENERATE_MM_CMPESTRM_TEST_CASES
Value:
ENUM_MM_CMPESTRX_TEST_CASES(UBYTE, ubyte, uint8_t, cmpestrm, CMPESTRM, \
ENUM_MM_CMPESTRX_TEST_CASES(SBYTE, sbyte, int8_t, cmpestrm, CMPESTRM, \
ENUM_MM_CMPESTRX_TEST_CASES(UWORD, uword, uint16_t, cmpestrm, CMPESTRM, \
ENUM_MM_CMPESTRX_TEST_CASES(SWORD, sword, int16_t, cmpestrm, CMPESTRM, \
#define IS_CMPESTRM
Definition: impl.cpp:10014

◆ GENERATE_MM_CMPESTRO_TEST_CASES

#define GENERATE_MM_CMPESTRO_TEST_CASES
Value:
ENUM_MM_CMPESTRX_TEST_CASES(UBYTE, ubyte, uint8_t, cmpestro, CMPESTRO, \
ENUM_MM_CMPESTRX_TEST_CASES(SBYTE, sbyte, int8_t, cmpestro, CMPESTRO, \
ENUM_MM_CMPESTRX_TEST_CASES(UWORD, uword, uint16_t, cmpestro, CMPESTRO, \
ENUM_MM_CMPESTRX_TEST_CASES(SWORD, sword, int16_t, cmpestro, CMPESTRO, \

◆ GENERATE_MM_CMPESTRS_TEST_CASES

#define GENERATE_MM_CMPESTRS_TEST_CASES
Value:
ENUM_MM_CMPESTRX_TEST_CASES(UBYTE, ubyte, uint8_t, cmpestrs, CMPESTRS, \
ENUM_MM_CMPESTRX_TEST_CASES(SBYTE, sbyte, int8_t, cmpestrs, CMPESTRS, \
ENUM_MM_CMPESTRX_TEST_CASES(UWORD, uword, uint16_t, cmpestrs, CMPESTRS, \
ENUM_MM_CMPESTRX_TEST_CASES(SWORD, sword, int16_t, cmpestrs, CMPESTRS, \

◆ GENERATE_MM_CMPESTRZ_TEST_CASES

#define GENERATE_MM_CMPESTRZ_TEST_CASES
Value:
ENUM_MM_CMPESTRX_TEST_CASES(UBYTE, ubyte, uint8_t, cmpestrz, CMPESTRZ, \
ENUM_MM_CMPESTRX_TEST_CASES(SBYTE, sbyte, int8_t, cmpestrz, CMPESTRZ, \
ENUM_MM_CMPESTRX_TEST_CASES(UWORD, uword, uint16_t, cmpestrz, CMPESTRZ, \
ENUM_MM_CMPESTRX_TEST_CASES(SWORD, sword, int16_t, cmpestrz, CMPESTRZ, \

◆ GENERATE_MM_CMPISTRA_TEST_CASES

#define GENERATE_MM_CMPISTRA_TEST_CASES
Value:
ENUM_MM_CMPISTRX_TEST_CASES(UBYTE, ubyte, uint8_t, cmpistra, CMPISTRA, \
ENUM_MM_CMPISTRX_TEST_CASES(SBYTE, sbyte, int8_t, cmpistra, CMPISTRA, \
ENUM_MM_CMPISTRX_TEST_CASES(UWORD, uword, uint16_t, cmpistra, CMPISTRA, \
ENUM_MM_CMPISTRX_TEST_CASES(SWORD, sword, int16_t, cmpistra, CMPISTRA, \
#define IS_CMPISTRI
Definition: impl.cpp:10617
#define ENUM_MM_CMPISTRX_TEST_CASES(type, type_lower, data_type, func, FUNC, IM)
Definition: impl.cpp:10639

◆ GENERATE_MM_CMPISTRC_TEST_CASES

#define GENERATE_MM_CMPISTRC_TEST_CASES
Value:
ENUM_MM_CMPISTRX_TEST_CASES(UBYTE, ubyte, uint8_t, cmpistrc, CMPISTRC, \
ENUM_MM_CMPISTRX_TEST_CASES(SBYTE, sbyte, int8_t, cmpistrc, CMPISTRC, \
ENUM_MM_CMPISTRX_TEST_CASES(UWORD, uword, uint16_t, cmpistrc, CMPISTRC, \
ENUM_MM_CMPISTRX_TEST_CASES(SWORD, sword, int16_t, cmpistrc, CMPISTRC, \

◆ GENERATE_MM_CMPISTRI_TEST_CASES

#define GENERATE_MM_CMPISTRI_TEST_CASES
Value:
ENUM_MM_CMPISTRX_TEST_CASES(UBYTE, ubyte, uint8_t, cmpistri, CMPISTRI, \
ENUM_MM_CMPISTRX_TEST_CASES(SBYTE, sbyte, int8_t, cmpistri, CMPISTRI, \
ENUM_MM_CMPISTRX_TEST_CASES(UWORD, uword, uint16_t, cmpistri, CMPISTRI, \
ENUM_MM_CMPISTRX_TEST_CASES(SWORD, sword, int16_t, cmpistri, CMPISTRI, \

◆ GENERATE_MM_CMPISTRM_TEST_CASES

#define GENERATE_MM_CMPISTRM_TEST_CASES
Value:
ENUM_MM_CMPISTRX_TEST_CASES(UBYTE, ubyte, uint8_t, cmpistrm, CMPISTRM, \
ENUM_MM_CMPISTRX_TEST_CASES(SBYTE, sbyte, int8_t, cmpistrm, CMPISTRM, \
ENUM_MM_CMPISTRX_TEST_CASES(UWORD, uword, uint16_t, cmpistrm, CMPISTRM, \
ENUM_MM_CMPISTRX_TEST_CASES(SWORD, sword, int16_t, cmpistrm, CMPISTRM, \
#define IS_CMPISTRM
Definition: impl.cpp:11036

◆ GENERATE_MM_CMPISTRO_TEST_CASES

#define GENERATE_MM_CMPISTRO_TEST_CASES
Value:
ENUM_MM_CMPISTRX_TEST_CASES(UBYTE, ubyte, uint8_t, cmpistro, CMPISTRO, \
ENUM_MM_CMPISTRX_TEST_CASES(SBYTE, sbyte, int8_t, cmpistro, CMPISTRO, \
ENUM_MM_CMPISTRX_TEST_CASES(UWORD, uword, uint16_t, cmpistro, CMPISTRO, \
ENUM_MM_CMPISTRX_TEST_CASES(SWORD, sword, int16_t, cmpistro, CMPISTRO, \

◆ GENERATE_MM_CMPISTRS_TEST_CASES

#define GENERATE_MM_CMPISTRS_TEST_CASES
Value:
ENUM_MM_CMPISTRX_TEST_CASES(UBYTE, ubyte, uint8_t, cmpistrs, CMPISTRS, \
ENUM_MM_CMPISTRX_TEST_CASES(SBYTE, sbyte, int8_t, cmpistrs, CMPISTRS, \
ENUM_MM_CMPISTRX_TEST_CASES(UWORD, uword, uint16_t, cmpistrs, CMPISTRS, \
ENUM_MM_CMPISTRX_TEST_CASES(SWORD, sword, int16_t, cmpistrs, CMPISTRS, \

◆ GENERATE_MM_CMPISTRZ_TEST_CASES

#define GENERATE_MM_CMPISTRZ_TEST_CASES
Value:
ENUM_MM_CMPISTRX_TEST_CASES(UBYTE, ubyte, uint8_t, cmpistrz, CMPISTRZ, \
ENUM_MM_CMPISTRX_TEST_CASES(SBYTE, sbyte, int8_t, cmpistrz, CMPISTRZ, \
ENUM_MM_CMPISTRX_TEST_CASES(UWORD, uword, uint16_t, cmpistrz, CMPISTRZ, \
ENUM_MM_CMPISTRX_TEST_CASES(SWORD, sword, int16_t, cmpistrz, CMPISTRZ, \

◆ GENERATE_MM_DP_PD_TEST_CASES

#define GENERATE_MM_DP_PD_TEST_CASES
Value:
MM_DP_PD_TEST_CASE_WITH(0xF1); \
MM_DP_PD_TEST_CASE_WITH(0xF2); \
MM_DP_PD_TEST_CASE_WITH(0xFF); \
MM_DP_PD_TEST_CASE_WITH(0x10); \
MM_DP_PD_TEST_CASE_WITH(0x11); \
MM_DP_PD_TEST_CASE_WITH(0x12); \
MM_DP_PD_TEST_CASE_WITH(0x13); \
MM_DP_PD_TEST_CASE_WITH(0x00); \
MM_DP_PD_TEST_CASE_WITH(0x01); \
MM_DP_PD_TEST_CASE_WITH(0x02); \
MM_DP_PD_TEST_CASE_WITH(0x03); \
MM_DP_PD_TEST_CASE_WITH(0x20); \
MM_DP_PD_TEST_CASE_WITH(0x21); \
MM_DP_PD_TEST_CASE_WITH(0x22); \
MM_DP_PD_TEST_CASE_WITH(0x23);
#define MM_DP_PD_TEST_CASE_WITH(imm8)
Definition: impl.cpp:8347

◆ GENERATE_MM_DP_PS_TEST_CASES

#define GENERATE_MM_DP_PS_TEST_CASES
Value:
MM_DP_PS_TEST_CASE_WITH(0x7F); \
MM_DP_PS_TEST_CASE_WITH(0x9F); \
MM_DP_PS_TEST_CASE_WITH(0x2F); \
MM_DP_PS_TEST_CASE_WITH(0x0F); \
MM_DP_PS_TEST_CASE_WITH(0x23); \
MM_DP_PS_TEST_CASE_WITH(0xB5);
#define MM_DP_PS_TEST_CASE_WITH(IMM)
Definition: impl.cpp:8389

◆ IIF

#define IIF (   c)    PRIMITIVE_CAT(IIF_, c)

◆ IIF_0

#define IIF_0 (   t,
  ... 
)    __VA_ARGS__

◆ IIF_1

#define IIF_1 (   t,
  ... 
)    t

◆ IMM_SBYTE_ANY_LEAST

#define IMM_SBYTE_ANY_LEAST    (_SIDD_SBYTE_OPS | _SIDD_CMP_EQUAL_ANY | _SIDD_LEAST_SIGNIFICANT)

◆ IMM_SBYTE_ANY_LEAST_NEGATIVE

#define IMM_SBYTE_ANY_LEAST_NEGATIVE
Value:
#define _SIDD_LEAST_SIGNIFICANT
Definition: sse2neon.h:7675
#define _SIDD_NEGATIVE_POLARITY
Definition: sse2neon.h:7670
#define _SIDD_SBYTE_OPS
Definition: sse2neon.h:7658
#define _SIDD_CMP_EQUAL_ANY
Definition: sse2neon.h:7662

◆ IMM_SBYTE_ANY_MOST

#define IMM_SBYTE_ANY_MOST    (_SIDD_SBYTE_OPS | _SIDD_CMP_EQUAL_ANY | _SIDD_MOST_SIGNIFICANT)

◆ IMM_SBYTE_ANY_MOST_MASKED_NEGATIVE

#define IMM_SBYTE_ANY_MOST_MASKED_NEGATIVE
Value:
#define _SIDD_MASKED_NEGATIVE_POLARITY
Definition: sse2neon.h:7671

◆ IMM_SBYTE_ANY_UNIT

#define IMM_SBYTE_ANY_UNIT    (_SIDD_SBYTE_OPS | _SIDD_CMP_EQUAL_ANY | _SIDD_UNIT_MASK)

◆ IMM_SBYTE_ANY_UNIT_MASKED_NEGATIVE

#define IMM_SBYTE_ANY_UNIT_MASKED_NEGATIVE
Value:
#define _SIDD_UNIT_MASK
Definition: sse2neon.h:7680

◆ IMM_SBYTE_EACH_BIT_MASKED_NEGATIVE

#define IMM_SBYTE_EACH_BIT_MASKED_NEGATIVE
Value:
#define _SIDD_BIT_MASK
Definition: sse2neon.h:7679
#define _SIDD_CMP_EQUAL_EACH
Definition: sse2neon.h:7664

◆ IMM_SBYTE_EACH_LEAST

#define IMM_SBYTE_EACH_LEAST    (_SIDD_SBYTE_OPS | _SIDD_CMP_EQUAL_EACH | _SIDD_LEAST_SIGNIFICANT)

◆ IMM_SBYTE_EACH_LEAST_MASKED_NEGATIVE

#define IMM_SBYTE_EACH_LEAST_MASKED_NEGATIVE

◆ IMM_SBYTE_EACH_LEAST_NEGATIVE

#define IMM_SBYTE_EACH_LEAST_NEGATIVE

◆ IMM_SBYTE_EACH_MOST

#define IMM_SBYTE_EACH_MOST    (_SIDD_SBYTE_OPS | _SIDD_CMP_EQUAL_EACH | _SIDD_MOST_SIGNIFICANT)

◆ IMM_SBYTE_EACH_MOST_MASKED_NEGATIVE

#define IMM_SBYTE_EACH_MOST_MASKED_NEGATIVE
Value:
#define _SIDD_MOST_SIGNIFICANT
Definition: sse2neon.h:7676

◆ IMM_SBYTE_EACH_MOST_NEGATIVE

#define IMM_SBYTE_EACH_MOST_NEGATIVE

◆ IMM_SBYTE_EACH_UNIT

#define IMM_SBYTE_EACH_UNIT    (_SIDD_SBYTE_OPS | _SIDD_CMP_EQUAL_EACH | _SIDD_UNIT_MASK)

◆ IMM_SBYTE_ORDERED_LEAST

#define IMM_SBYTE_ORDERED_LEAST    (_SIDD_SBYTE_OPS | _SIDD_CMP_EQUAL_ORDERED | _SIDD_LEAST_SIGNIFICANT)

◆ IMM_SBYTE_ORDERED_LEAST_MASKED_NEGATIVE

#define IMM_SBYTE_ORDERED_LEAST_MASKED_NEGATIVE
Value:

◆ IMM_SBYTE_ORDERED_LEAST_NEGATIVE

#define IMM_SBYTE_ORDERED_LEAST_NEGATIVE

◆ IMM_SBYTE_ORDERED_MOST

#define IMM_SBYTE_ORDERED_MOST    (_SIDD_SBYTE_OPS | _SIDD_CMP_EQUAL_ORDERED | _SIDD_MOST_SIGNIFICANT)

◆ IMM_SBYTE_ORDERED_MOST_MASKED_NEGATIVE

#define IMM_SBYTE_ORDERED_MOST_MASKED_NEGATIVE

◆ IMM_SBYTE_ORDERED_MOST_NEGATIVE

#define IMM_SBYTE_ORDERED_MOST_NEGATIVE

◆ IMM_SBYTE_ORDERED_UNIT

#define IMM_SBYTE_ORDERED_UNIT    (_SIDD_SBYTE_OPS | _SIDD_CMP_EQUAL_ORDERED | _SIDD_UNIT_MASK)

◆ IMM_SBYTE_RANGES_LEAST

#define IMM_SBYTE_RANGES_LEAST    (_SIDD_SBYTE_OPS | _SIDD_CMP_RANGES | _SIDD_LEAST_SIGNIFICANT)

◆ IMM_SBYTE_RANGES_LEAST_MASKED_NEGATIVE

#define IMM_SBYTE_RANGES_LEAST_MASKED_NEGATIVE
Value:
#define _SIDD_CMP_RANGES
Definition: sse2neon.h:7663

◆ IMM_SBYTE_RANGES_LEAST_NEGATIVE

#define IMM_SBYTE_RANGES_LEAST_NEGATIVE

◆ IMM_SBYTE_RANGES_MOST

#define IMM_SBYTE_RANGES_MOST    (_SIDD_SBYTE_OPS | _SIDD_CMP_RANGES | _SIDD_MOST_SIGNIFICANT)

◆ IMM_SBYTE_RANGES_MOST_MASKED_NEGATIVE

#define IMM_SBYTE_RANGES_MOST_MASKED_NEGATIVE

◆ IMM_SBYTE_RANGES_MOST_NEGATIVE

#define IMM_SBYTE_RANGES_MOST_NEGATIVE

◆ IMM_SBYTE_RANGES_UNIT

#define IMM_SBYTE_RANGES_UNIT    (_SIDD_SBYTE_OPS | _SIDD_CMP_RANGES | _SIDD_UNIT_MASK)

◆ IMM_SWORD_ANY_LEAST

#define IMM_SWORD_ANY_LEAST    (_SIDD_SWORD_OPS | _SIDD_CMP_EQUAL_ANY | _SIDD_LEAST_SIGNIFICANT)

◆ IMM_SWORD_ANY_LEAST_MASKED_NEGATIVE

#define IMM_SWORD_ANY_LEAST_MASKED_NEGATIVE
Value:

◆ IMM_SWORD_ANY_LEAST_NEGATIVE

#define IMM_SWORD_ANY_LEAST_NEGATIVE    (_SIDD_SWORD_OPS | _SIDD_CMP_EQUAL_ANY | _SIDD_LEAST_SIGNIFICANT)

◆ IMM_SWORD_ANY_MOST

#define IMM_SWORD_ANY_MOST    (_SIDD_SWORD_OPS | _SIDD_CMP_EQUAL_ANY | _SIDD_MOST_SIGNIFICANT)

◆ IMM_SWORD_ANY_MOST_MASKED_NEGATIVE [1/2]

#define IMM_SWORD_ANY_MOST_MASKED_NEGATIVE

◆ IMM_SWORD_ANY_MOST_MASKED_NEGATIVE [2/2]

#define IMM_SWORD_ANY_MOST_MASKED_NEGATIVE

◆ IMM_SWORD_ANY_MOST_NEGATIVE

#define IMM_SWORD_ANY_MOST_NEGATIVE

◆ IMM_SWORD_ANY_UNIT

#define IMM_SWORD_ANY_UNIT    (_SIDD_SWORD_OPS | _SIDD_CMP_EQUAL_ANY | _SIDD_UNIT_MASK)

◆ IMM_SWORD_EACH_LEAST

#define IMM_SWORD_EACH_LEAST    (_SIDD_SWORD_OPS | _SIDD_CMP_EQUAL_EACH | _SIDD_LEAST_SIGNIFICANT)

◆ IMM_SWORD_EACH_LEAST_MASKED_NEGATIVE

#define IMM_SWORD_EACH_LEAST_MASKED_NEGATIVE

◆ IMM_SWORD_EACH_LEAST_NEGATIVE

#define IMM_SWORD_EACH_LEAST_NEGATIVE

◆ IMM_SWORD_EACH_MOST

#define IMM_SWORD_EACH_MOST    (_SIDD_SWORD_OPS | _SIDD_CMP_EQUAL_EACH | _SIDD_MOST_SIGNIFICANT)

◆ IMM_SWORD_EACH_MOST_MASKED_NEGATIVE

#define IMM_SWORD_EACH_MOST_MASKED_NEGATIVE

◆ IMM_SWORD_EACH_MOST_NEGATIVE

#define IMM_SWORD_EACH_MOST_NEGATIVE

◆ IMM_SWORD_EACH_UNIT

#define IMM_SWORD_EACH_UNIT    (_SIDD_SWORD_OPS | _SIDD_CMP_EQUAL_EACH | _SIDD_UNIT_MASK)

◆ IMM_SWORD_ORDERED_LEAST

#define IMM_SWORD_ORDERED_LEAST    (_SIDD_SWORD_OPS | _SIDD_CMP_EQUAL_ORDERED | _SIDD_LEAST_SIGNIFICANT)

◆ IMM_SWORD_ORDERED_LEAST_MASKED_NEGATIVE

#define IMM_SWORD_ORDERED_LEAST_MASKED_NEGATIVE

◆ IMM_SWORD_ORDERED_LEAST_NEGATIVE

#define IMM_SWORD_ORDERED_LEAST_NEGATIVE

◆ IMM_SWORD_ORDERED_MOST

#define IMM_SWORD_ORDERED_MOST    (_SIDD_SWORD_OPS | _SIDD_CMP_EQUAL_ORDERED | _SIDD_MOST_SIGNIFICANT)

◆ IMM_SWORD_ORDERED_MOST_MASKED_NEGATIVE

#define IMM_SWORD_ORDERED_MOST_MASKED_NEGATIVE

◆ IMM_SWORD_ORDERED_UNIT

#define IMM_SWORD_ORDERED_UNIT    (_SIDD_SWORD_OPS | _SIDD_CMP_EQUAL_ORDERED | _SIDD_UNIT_MASK)

◆ IMM_SWORD_RANGES_BIT

#define IMM_SWORD_RANGES_BIT    (_SIDD_SWORD_OPS | _SIDD_CMP_RANGES | _SIDD_BIT_MASK)

◆ IMM_SWORD_RANGES_LEAST

#define IMM_SWORD_RANGES_LEAST    (_SIDD_SWORD_OPS | _SIDD_CMP_RANGES | _SIDD_LEAST_SIGNIFICANT)

◆ IMM_SWORD_RANGES_LEAST_MASKED_NEGATIVE

#define IMM_SWORD_RANGES_LEAST_MASKED_NEGATIVE

◆ IMM_SWORD_RANGES_LEAST_NEGATIVE

#define IMM_SWORD_RANGES_LEAST_NEGATIVE

◆ IMM_SWORD_RANGES_MOST

#define IMM_SWORD_RANGES_MOST    (_SIDD_SWORD_OPS | _SIDD_CMP_RANGES | _SIDD_MOST_SIGNIFICANT)

◆ IMM_SWORD_RANGES_MOST_MASKED_NEGATIVE

#define IMM_SWORD_RANGES_MOST_MASKED_NEGATIVE

◆ IMM_SWORD_RANGES_UNIT

#define IMM_SWORD_RANGES_UNIT    (_SIDD_SWORD_OPS | _SIDD_CMP_RANGES | _SIDD_UNIT_MASK)

◆ IMM_UBYTE_ANY_BIT

#define IMM_UBYTE_ANY_BIT    (_SIDD_UBYTE_OPS | _SIDD_CMP_EQUAL_ANY | _SIDD_BIT_MASK)

◆ IMM_UBYTE_ANY_LEAST

#define IMM_UBYTE_ANY_LEAST    (_SIDD_UBYTE_OPS | _SIDD_CMP_EQUAL_ANY | _SIDD_LEAST_SIGNIFICANT)

◆ IMM_UBYTE_ANY_LEAST_MASKED_NEGATIVE

#define IMM_UBYTE_ANY_LEAST_MASKED_NEGATIVE
Value:

◆ IMM_UBYTE_ANY_LEAST_NEGATIVE

#define IMM_UBYTE_ANY_LEAST_NEGATIVE

◆ IMM_UBYTE_ANY_MOST

#define IMM_UBYTE_ANY_MOST    (_SIDD_UBYTE_OPS | _SIDD_CMP_EQUAL_ANY | _SIDD_MOST_SIGNIFICANT)

◆ IMM_UBYTE_ANY_MOST_MASKED_NEGATIVE

#define IMM_UBYTE_ANY_MOST_MASKED_NEGATIVE

◆ IMM_UBYTE_ANY_MOST_NEGATIVE

#define IMM_UBYTE_ANY_MOST_NEGATIVE

◆ IMM_UBYTE_ANY_UNIT

#define IMM_UBYTE_ANY_UNIT    (_SIDD_UBYTE_OPS | _SIDD_CMP_EQUAL_ANY | _SIDD_UNIT_MASK)

◆ IMM_UBYTE_EACH_LEAST

#define IMM_UBYTE_EACH_LEAST    (_SIDD_UBYTE_OPS | _SIDD_CMP_EQUAL_EACH | _SIDD_LEAST_SIGNIFICANT)

◆ IMM_UBYTE_EACH_LEAST_MASKED_NEGATIVE

#define IMM_UBYTE_EACH_LEAST_MASKED_NEGATIVE

◆ IMM_UBYTE_EACH_LEAST_NEGATIVE

#define IMM_UBYTE_EACH_LEAST_NEGATIVE

◆ IMM_UBYTE_EACH_MOST

#define IMM_UBYTE_EACH_MOST    (_SIDD_UBYTE_OPS | _SIDD_CMP_EQUAL_EACH | _SIDD_MOST_SIGNIFICANT)

◆ IMM_UBYTE_EACH_MOST_MASKED_NEGATIVE

#define IMM_UBYTE_EACH_MOST_MASKED_NEGATIVE

◆ IMM_UBYTE_EACH_MOST_NEGATIVE

#define IMM_UBYTE_EACH_MOST_NEGATIVE

◆ IMM_UBYTE_EACH_UNIT

#define IMM_UBYTE_EACH_UNIT    (_SIDD_UBYTE_OPS | _SIDD_CMP_EQUAL_EACH | _SIDD_UNIT_MASK)

◆ IMM_UBYTE_EACH_UNIT_NEGATIVE

#define IMM_UBYTE_EACH_UNIT_NEGATIVE

◆ IMM_UBYTE_ORDERED_LEAST

#define IMM_UBYTE_ORDERED_LEAST    (_SIDD_UBYTE_OPS | _SIDD_CMP_EQUAL_ORDERED | _SIDD_LEAST_SIGNIFICANT)

◆ IMM_UBYTE_ORDERED_LEAST_NEGATIVE

#define IMM_UBYTE_ORDERED_LEAST_NEGATIVE

◆ IMM_UBYTE_ORDERED_MOST

#define IMM_UBYTE_ORDERED_MOST    (_SIDD_UBYTE_OPS | _SIDD_CMP_EQUAL_ORDERED | _SIDD_MOST_SIGNIFICANT)

◆ IMM_UBYTE_ORDERED_MOST_MASKED_NEGATIVE

#define IMM_UBYTE_ORDERED_MOST_MASKED_NEGATIVE

◆ IMM_UBYTE_ORDERED_MOST_NEGATIVE

#define IMM_UBYTE_ORDERED_MOST_NEGATIVE

◆ IMM_UBYTE_ORDERED_UNIT

#define IMM_UBYTE_ORDERED_UNIT    (_SIDD_UBYTE_OPS | _SIDD_CMP_EQUAL_ORDERED | _SIDD_UNIT_MASK)

◆ IMM_UBYTE_RANGES_LEAST

#define IMM_UBYTE_RANGES_LEAST    (_SIDD_UBYTE_OPS | _SIDD_CMP_RANGES | _SIDD_LEAST_SIGNIFICANT)

◆ IMM_UBYTE_RANGES_LEAST_MASKED_NEGATIVE

#define IMM_UBYTE_RANGES_LEAST_MASKED_NEGATIVE

◆ IMM_UBYTE_RANGES_LEAST_NEGATIVE

#define IMM_UBYTE_RANGES_LEAST_NEGATIVE

◆ IMM_UBYTE_RANGES_MOST

#define IMM_UBYTE_RANGES_MOST    (_SIDD_UBYTE_OPS | _SIDD_CMP_RANGES | _SIDD_MOST_SIGNIFICANT)

◆ IMM_UBYTE_RANGES_MOST_MASKED_NEGATIVE

#define IMM_UBYTE_RANGES_MOST_MASKED_NEGATIVE

◆ IMM_UBYTE_RANGES_MOST_NEGATIVE

#define IMM_UBYTE_RANGES_MOST_NEGATIVE

◆ IMM_UBYTE_RANGES_UNIT

#define IMM_UBYTE_RANGES_UNIT    (_SIDD_UBYTE_OPS | _SIDD_CMP_RANGES | _SIDD_UNIT_MASK)

◆ IMM_UWORD_ANY_BIT

#define IMM_UWORD_ANY_BIT    (_SIDD_UWORD_OPS | _SIDD_CMP_EQUAL_ANY | _SIDD_BIT_MASK)

◆ IMM_UWORD_ANY_LEAST

#define IMM_UWORD_ANY_LEAST    (_SIDD_UWORD_OPS | _SIDD_CMP_EQUAL_ANY | _SIDD_LEAST_SIGNIFICANT)

◆ IMM_UWORD_ANY_LEAST_MASKED_NEGATIVE

#define IMM_UWORD_ANY_LEAST_MASKED_NEGATIVE
Value:

◆ IMM_UWORD_ANY_LEAST_NEGATIVE

#define IMM_UWORD_ANY_LEAST_NEGATIVE

◆ IMM_UWORD_ANY_MOST

#define IMM_UWORD_ANY_MOST    (_SIDD_UWORD_OPS | _SIDD_CMP_EQUAL_ANY | _SIDD_MOST_SIGNIFICANT)

◆ IMM_UWORD_ANY_MOST_NEGATIVE

#define IMM_UWORD_ANY_MOST_NEGATIVE

◆ IMM_UWORD_ANY_UNIT

#define IMM_UWORD_ANY_UNIT    (_SIDD_UWORD_OPS | _SIDD_CMP_EQUAL_ANY | _SIDD_UNIT_MASK)

◆ IMM_UWORD_EACH_LEAST

#define IMM_UWORD_EACH_LEAST    (_SIDD_UWORD_OPS | _SIDD_CMP_EQUAL_EACH | _SIDD_LEAST_SIGNIFICANT)

◆ IMM_UWORD_EACH_LEAST_MASKED_NEGATIVE

#define IMM_UWORD_EACH_LEAST_MASKED_NEGATIVE

◆ IMM_UWORD_EACH_LEAST_NEGATIVE

#define IMM_UWORD_EACH_LEAST_NEGATIVE

◆ IMM_UWORD_EACH_MOST

#define IMM_UWORD_EACH_MOST    (_SIDD_UWORD_OPS | _SIDD_CMP_EQUAL_EACH | _SIDD_MOST_SIGNIFICANT)

◆ IMM_UWORD_EACH_MOST_MASKED_NEGATIVE

#define IMM_UWORD_EACH_MOST_MASKED_NEGATIVE

◆ IMM_UWORD_EACH_UNIT

#define IMM_UWORD_EACH_UNIT    (_SIDD_UWORD_OPS | _SIDD_CMP_EQUAL_EACH | _SIDD_UNIT_MASK)

◆ IMM_UWORD_ORDERED_LEAST

#define IMM_UWORD_ORDERED_LEAST    (_SIDD_UWORD_OPS | _SIDD_CMP_EQUAL_ORDERED | _SIDD_LEAST_SIGNIFICANT)

◆ IMM_UWORD_ORDERED_LEAST_MASKED_NEGATIVE

#define IMM_UWORD_ORDERED_LEAST_MASKED_NEGATIVE

◆ IMM_UWORD_ORDERED_LEAST_NEGATIVE

#define IMM_UWORD_ORDERED_LEAST_NEGATIVE

◆ IMM_UWORD_ORDERED_MOST

#define IMM_UWORD_ORDERED_MOST    (_SIDD_UWORD_OPS | _SIDD_CMP_EQUAL_ORDERED | _SIDD_MOST_SIGNIFICANT)

◆ IMM_UWORD_ORDERED_MOST_MASKED_NEGATIVE

#define IMM_UWORD_ORDERED_MOST_MASKED_NEGATIVE

◆ IMM_UWORD_ORDERED_MOST_NEGATIVE

#define IMM_UWORD_ORDERED_MOST_NEGATIVE

◆ IMM_UWORD_ORDERED_UNIT

#define IMM_UWORD_ORDERED_UNIT    (_SIDD_UWORD_OPS | _SIDD_CMP_EQUAL_ORDERED | _SIDD_UNIT_MASK)

◆ IMM_UWORD_ORDERED_UNIT_NEGATIVE

#define IMM_UWORD_ORDERED_UNIT_NEGATIVE

◆ IMM_UWORD_RANGES_LEAST

#define IMM_UWORD_RANGES_LEAST    (_SIDD_UWORD_OPS | _SIDD_CMP_RANGES | _SIDD_LEAST_SIGNIFICANT)

◆ IMM_UWORD_RANGES_LEAST_MASKED_NEGATIVE

#define IMM_UWORD_RANGES_LEAST_MASKED_NEGATIVE

◆ IMM_UWORD_RANGES_LEAST_NEGATIVE

#define IMM_UWORD_RANGES_LEAST_NEGATIVE

◆ IMM_UWORD_RANGES_MOST

#define IMM_UWORD_RANGES_MOST    (_SIDD_UWORD_OPS | _SIDD_CMP_RANGES | _SIDD_MOST_SIGNIFICANT)

◆ IMM_UWORD_RANGES_MOST_MASKED_NEGATIVE

#define IMM_UWORD_RANGES_MOST_MASKED_NEGATIVE

◆ IMM_UWORD_RANGES_MOST_NEGATIVE

#define IMM_UWORD_RANGES_MOST_NEGATIVE

◆ IMM_UWORD_RANGES_UNIT

#define IMM_UWORD_RANGES_UNIT    (_SIDD_UWORD_OPS | _SIDD_CMP_RANGES | _SIDD_UNIT_MASK)

◆ IS_CMPESTRI

#define IS_CMPESTRI   1

◆ IS_CMPESTRM

#define IS_CMPESTRM   0

◆ IS_CMPISTRI

#define IS_CMPISTRI   1

◆ IS_CMPISTRM

#define IS_CMPISTRM   0

◆ MAX_TEST_VALUE

#define MAX_TEST_VALUE   10000

◆ MM_CMPESTRA_SBYTE_TEST_CASES

#define MM_CMPESTRA_SBYTE_TEST_CASES (   _,
  ... 
)
Value:
_(SBYTE_RANGES_LEAST, __VA_ARGS__) \
_(SBYTE_ORDERED_MOST_NEGATIVE, __VA_ARGS__) \
_(SBYTE_ANY_LEAST, __VA_ARGS__)

◆ MM_CMPESTRA_SWORD_TEST_CASES

#define MM_CMPESTRA_SWORD_TEST_CASES (   _,
  ... 
)
Value:
_(SWORD_RANGES_LEAST_NEGATIVE, __VA_ARGS__) \
_(SWORD_EACH_MOST, __VA_ARGS__) \
_(SWORD_ANY_LEAST_MASKED_NEGATIVE, __VA_ARGS__)

◆ MM_CMPESTRA_UBYTE_TEST_CASES

#define MM_CMPESTRA_UBYTE_TEST_CASES (   _,
  ... 
)
Value:
_(UBYTE_ORDERED_MOST, __VA_ARGS__) \
_(UBYTE_EACH_LEAST_NEGATIVE, __VA_ARGS__) \
_(UBYTE_ANY_LEAST_MASKED_NEGATIVE, __VA_ARGS__)

◆ MM_CMPESTRA_UWORD_TEST_CASES

#define MM_CMPESTRA_UWORD_TEST_CASES (   _,
  ... 
)
Value:
_(UWORD_ORDERED_LEAST, __VA_ARGS__) \
_(UWORD_RANGES_LEAST_MASKED_NEGATIVE, __VA_ARGS__) \
_(UWORD_EACH_MOST, __VA_ARGS__)

◆ MM_CMPESTRC_SBYTE_TEST_CASES

#define MM_CMPESTRC_SBYTE_TEST_CASES (   _,
  ... 
)
Value:
_(SBYTE_RANGES_MOST, __VA_ARGS__) \
_(SBYTE_ORDERED_MOST_MASKED_NEGATIVE, __VA_ARGS__) \
_(SBYTE_ANY_MOST_MASKED_NEGATIVE, __VA_ARGS__) \
_(SBYTE_EACH_MOST, __VA_ARGS__)

◆ MM_CMPESTRC_SWORD_TEST_CASES

#define MM_CMPESTRC_SWORD_TEST_CASES (   _,
  ... 
)
Value:
_(SWORD_RANGES_LEAST, __VA_ARGS__) \
_(SWORD_EACH_MOST_NEGATIVE, __VA_ARGS__) \
_(SWORD_ANY_LEAST_NEGATIVE, __VA_ARGS__) \
_(SWORD_ORDERED_MOST, __VA_ARGS__)

◆ MM_CMPESTRC_UBYTE_TEST_CASES

#define MM_CMPESTRC_UBYTE_TEST_CASES (   _,
  ... 
)
Value:
_(UBYTE_ORDERED_MOST_MASKED_NEGATIVE, __VA_ARGS__) \
_(UBYTE_EACH_MOST, __VA_ARGS__) \
_(UBYTE_ANY_LEAST, __VA_ARGS__) \
_(UBYTE_RANGES_LEAST_NEGATIVE, __VA_ARGS__)

◆ MM_CMPESTRC_UWORD_TEST_CASES

#define MM_CMPESTRC_UWORD_TEST_CASES (   _,
  ... 
)
Value:
_(UWORD_ORDERED_LEAST_NEGATIVE, __VA_ARGS__) \
_(UWORD_RANGES_MOST, __VA_ARGS__) \
_(UWORD_EACH_LEAST_MASKED_NEGATIVE, __VA_ARGS__) \
_(UWORD_ANY_MOST, __VA_ARGS__)

◆ MM_CMPESTRI_SBYTE_TEST_CASES

#define MM_CMPESTRI_SBYTE_TEST_CASES (   _,
  ... 
)
Value:
_(SBYTE_EACH_LEAST, __VA_ARGS__) \
_(SBYTE_ANY_LEAST, __VA_ARGS__) \
_(SBYTE_RANGES_LEAST, __VA_ARGS__) \
_(SBYTE_ORDERED_LEAST, __VA_ARGS__)

◆ MM_CMPESTRI_SWORD_TEST_CASES

#define MM_CMPESTRI_SWORD_TEST_CASES (   _,
  ... 
)
Value:
_(SWORD_RANGES_MOST, __VA_ARGS__) \
_(SWORD_EACH_LEAST, __VA_ARGS__) \
_(SWORD_ANY_LEAST, __VA_ARGS__) \
_(SWORD_ORDERED_LEAST, __VA_ARGS__)

◆ MM_CMPESTRI_UBYTE_TEST_CASES

#define MM_CMPESTRI_UBYTE_TEST_CASES (   _,
  ... 
)
Value:
_(UBYTE_ANY_LEAST_NEGATIVE, __VA_ARGS__) \
_(UBYTE_EACH_LEAST, __VA_ARGS__) \
_(UBYTE_RANGES_LEAST, __VA_ARGS__) \
_(UBYTE_ORDERED_LEAST, __VA_ARGS__)

◆ MM_CMPESTRI_UWORD_TEST_CASES

#define MM_CMPESTRI_UWORD_TEST_CASES (   _,
  ... 
)
Value:
_(UWORD_EACH_LEAST, __VA_ARGS__) \
_(UWORD_ANY_LEAST, __VA_ARGS__) \
_(UWORD_RANGES_LEAST, __VA_ARGS__) \
_(UWORD_ORDERED_LEAST, __VA_ARGS__)

◆ MM_CMPESTRM_SBYTE_TEST_CASES

#define MM_CMPESTRM_SBYTE_TEST_CASES (   _,
  ... 
)
Value:
_(SBYTE_EACH_UNIT, __VA_ARGS__) \
_(SBYTE_ANY_UNIT_MASKED_NEGATIVE, __VA_ARGS__) \
_(SBYTE_RANGES_UNIT, __VA_ARGS__) \
_(SBYTE_ORDERED_UNIT, __VA_ARGS__)

◆ MM_CMPESTRM_SWORD_TEST_CASES

#define MM_CMPESTRM_SWORD_TEST_CASES (   _,
  ... 
)
Value:
_(SWORD_RANGES_UNIT, __VA_ARGS__) \
_(SWORD_EACH_UNIT, __VA_ARGS__) \
_(SWORD_ANY_UNIT, __VA_ARGS__) \
_(SWORD_ORDERED_UNIT, __VA_ARGS__)

◆ MM_CMPESTRM_UBYTE_TEST_CASES

#define MM_CMPESTRM_UBYTE_TEST_CASES (   _,
  ... 
)
Value:
_(UBYTE_EACH_UNIT_NEGATIVE, __VA_ARGS__) \
_(UBYTE_ANY_UNIT, __VA_ARGS__) \
_(UBYTE_RANGES_UNIT, __VA_ARGS__) \
_(UBYTE_ORDERED_UNIT, __VA_ARGS__)

◆ MM_CMPESTRM_UWORD_TEST_CASES

#define MM_CMPESTRM_UWORD_TEST_CASES (   _,
  ... 
)
Value:
_(UWORD_RANGES_UNIT, __VA_ARGS__) \
_(UWORD_EACH_UNIT, __VA_ARGS__) \
_(UWORD_ANY_BIT, __VA_ARGS__) \
_(UWORD_ORDERED_UNIT, __VA_ARGS__)

◆ MM_CMPESTRO_SBYTE_TEST_CASES

#define MM_CMPESTRO_SBYTE_TEST_CASES (   _,
  ... 
)
Value:
_(SBYTE_EACH_MOST_NEGATIVE, __VA_ARGS__) \
_(SBYTE_ANY_MOST, __VA_ARGS__) \
_(SBYTE_RANGES_MOST_MASKED_NEGATIVE, __VA_ARGS__) \
_(SBYTE_ORDERED_MOST, __VA_ARGS__)

◆ MM_CMPESTRO_SWORD_TEST_CASES

#define MM_CMPESTRO_SWORD_TEST_CASES (   _,
  ... 
)
Value:
_(SWORD_RANGES_MOST_MASKED_NEGATIVE, __VA_ARGS__) \
_(SWORD_EACH_MOST_MASKED_NEGATIVE, __VA_ARGS__) \
_(SWORD_ANY_MOST_MASKED_NEGATIVE, __VA_ARGS__) \
_(SWORD_ORDERED_MOST_MASKED_NEGATIVE, __VA_ARGS__)

◆ MM_CMPESTRO_UBYTE_TEST_CASES

#define MM_CMPESTRO_UBYTE_TEST_CASES (   _,
  ... 
)
Value:
_(UBYTE_ANY_MOST_NEGATIVE, __VA_ARGS__) \
_(UBYTE_EACH_LEAST_MASKED_NEGATIVE, __VA_ARGS__) \
_(UBYTE_RANGES_LEAST_MASKED_NEGATIVE, __VA_ARGS__) \
_(UBYTE_ORDERED_LEAST_NEGATIVE, __VA_ARGS__)

◆ MM_CMPESTRO_UWORD_TEST_CASES

#define MM_CMPESTRO_UWORD_TEST_CASES (   _,
  ... 
)
Value:
_(UWORD_EACH_MOST_MASKED_NEGATIVE, __VA_ARGS__) \
_(UWORD_ANY_LEAST_MASKED_NEGATIVE, __VA_ARGS__) \
_(UWORD_RANGES_LEAST_NEGATIVE, __VA_ARGS__) \
_(UWORD_ORDERED_MOST, __VA_ARGS__)

◆ MM_CMPESTRS_SBYTE_TEST_CASES

#define MM_CMPESTRS_SBYTE_TEST_CASES (   _,
  ... 
)
Value:
_(SBYTE_EACH_LEAST_MASKED_NEGATIVE, __VA_ARGS__) \
_(SBYTE_ORDERED_LEAST_MASKED_NEGATIVE, __VA_ARGS__)

◆ MM_CMPESTRS_SWORD_TEST_CASES

#define MM_CMPESTRS_SWORD_TEST_CASES (   _,
  ... 
)
Value:
_(SWORD_ANY_LEAST_MASKED_NEGATIVE, __VA_ARGS__) \
_(SWORD_EACH_LEAST_NEGATIVE, __VA_ARGS__)

◆ MM_CMPESTRS_UBYTE_TEST_CASES

#define MM_CMPESTRS_UBYTE_TEST_CASES (   _,
  ... 
)
Value:
_(UBYTE_ANY_MOST, __VA_ARGS__) \
_(UBYTE_RANGES_MOST, __VA_ARGS__)

◆ MM_CMPESTRS_UWORD_TEST_CASES

#define MM_CMPESTRS_UWORD_TEST_CASES (   _,
  ... 
)
Value:
_(UWORD_ANY_MOST_NEGATIVE, __VA_ARGS__) \
_(UWORD_RANGES_MOST_MASKED_NEGATIVE, __VA_ARGS__)

◆ MM_CMPESTRZ_SBYTE_TEST_CASES

#define MM_CMPESTRZ_SBYTE_TEST_CASES (   _,
  ... 
)
Value:
_(SBYTE_EACH_LEAST_NEGATIVE, __VA_ARGS__) \
_(SBYTE_ORDERED_LEAST_NEGATIVE, __VA_ARGS__)

◆ MM_CMPESTRZ_SWORD_TEST_CASES

#define MM_CMPESTRZ_SWORD_TEST_CASES (   _,
  ... 
)
Value:
_(SWORD_ANY_LEAST_MASKED_NEGATIVE, __VA_ARGS__) \
_(SWORD_EACH_LEAST_MASKED_NEGATIVE, __VA_ARGS__)

◆ MM_CMPESTRZ_UBYTE_TEST_CASES

#define MM_CMPESTRZ_UBYTE_TEST_CASES (   _,
  ... 
)
Value:
_(UBYTE_ANY_MOST, __VA_ARGS__) \
_(UBYTE_RANGES_MOST, __VA_ARGS__)

◆ MM_CMPESTRZ_UWORD_TEST_CASES

#define MM_CMPESTRZ_UWORD_TEST_CASES (   _,
  ... 
)
Value:
_(UWORD_ANY_LEAST_NEGATIVE, __VA_ARGS__) \
_(UWORD_RANGES_MOST_NEGATIVE, __VA_ARGS__)

◆ MM_CMPISTRA_SBYTE_TEST_CASES

#define MM_CMPISTRA_SBYTE_TEST_CASES (   _,
  ... 
)
Value:
_(SBYTE_EACH_LEAST, __VA_ARGS__) \
_(SBYTE_ANY_LEAST_NEGATIVE, __VA_ARGS__) \
_(SBYTE_RANGES_LEAST, __VA_ARGS__) \
_(SBYTE_ORDERED_LEAST, __VA_ARGS__)

◆ MM_CMPISTRA_SWORD_TEST_CASES

#define MM_CMPISTRA_SWORD_TEST_CASES (   _,
  ... 
)
Value:
_(SWORD_RANGES_LEAST_MASKED_NEGATIVE, __VA_ARGS__) \
_(SWORD_EACH_LEAST, __VA_ARGS__) \
_(SWORD_ANY_LEAST, __VA_ARGS__) \
_(SWORD_ORDERED_LEAST, __VA_ARGS__)

◆ MM_CMPISTRA_UBYTE_TEST_CASES

#define MM_CMPISTRA_UBYTE_TEST_CASES (   _,
  ... 
)
Value:
_(UBYTE_ANY_LEAST, __VA_ARGS__) \
_(UBYTE_EACH_LEAST, __VA_ARGS__) \
_(UBYTE_RANGES_LEAST, __VA_ARGS__) \
_(UBYTE_ORDERED_MOST_NEGATIVE, __VA_ARGS__)

◆ MM_CMPISTRA_UWORD_TEST_CASES

#define MM_CMPISTRA_UWORD_TEST_CASES (   _,
  ... 
)
Value:
_(UWORD_EACH_LEAST_NEGATIVE, __VA_ARGS__) \
_(UWORD_ANY_LEAST, __VA_ARGS__) \
_(UWORD_RANGES_LEAST, __VA_ARGS__) \
_(UWORD_ORDERED_LEAST, __VA_ARGS__)

◆ MM_CMPISTRC_SBYTE_TEST_CASES

#define MM_CMPISTRC_SBYTE_TEST_CASES (   _,
  ... 
)
Value:
_(SBYTE_EACH_MOST_MASKED_NEGATIVE, __VA_ARGS__) \
_(SBYTE_ANY_LEAST, __VA_ARGS__) \
_(SBYTE_RANGES_LEAST, __VA_ARGS__) \
_(SBYTE_ORDERED_LEAST, __VA_ARGS__)

◆ MM_CMPISTRC_SWORD_TEST_CASES

#define MM_CMPISTRC_SWORD_TEST_CASES (   _,
  ... 
)
Value:
_(SWORD_RANGES_LEAST, __VA_ARGS__) \
_(SWORD_EACH_LEAST, __VA_ARGS__) \
_(SWORD_ANY_MOST_NEGATIVE, __VA_ARGS__) \
_(SWORD_ORDERED_LEAST, __VA_ARGS__)

◆ MM_CMPISTRC_UBYTE_TEST_CASES

#define MM_CMPISTRC_UBYTE_TEST_CASES (   _,
  ... 
)
Value:
_(UBYTE_ANY_LEAST, __VA_ARGS__) \
_(UBYTE_EACH_LEAST, __VA_ARGS__) \
_(UBYTE_RANGES_MOST_NEGATIVE, __VA_ARGS__) \
_(UBYTE_ORDERED_LEAST, __VA_ARGS__)

◆ MM_CMPISTRC_UWORD_TEST_CASES

#define MM_CMPISTRC_UWORD_TEST_CASES (   _,
  ... 
)
Value:
_(UWORD_EACH_LEAST, __VA_ARGS__) \
_(UWORD_ANY_LEAST, __VA_ARGS__) \
_(UWORD_RANGES_LEAST, __VA_ARGS__) \
_(UWORD_ORDERED_LEAST_MASKED_NEGATIVE, __VA_ARGS__)

◆ MM_CMPISTRI_SBYTE_TEST_CASES

#define MM_CMPISTRI_SBYTE_TEST_CASES (   _,
  ... 
)
Value:
_(SBYTE_EACH_LEAST, __VA_ARGS__) \
_(SBYTE_ANY_LEAST, __VA_ARGS__) \
_(SBYTE_RANGES_LEAST_NEGATIVE, __VA_ARGS__) \
_(SBYTE_ORDERED_LEAST, __VA_ARGS__)

◆ MM_CMPISTRI_SWORD_TEST_CASES

#define MM_CMPISTRI_SWORD_TEST_CASES (   _,
  ... 
)
Value:
_(SWORD_RANGES_LEAST, __VA_ARGS__) \
_(SWORD_EACH_LEAST, __VA_ARGS__) \
_(SWORD_ANY_MOST, __VA_ARGS__) \
_(SWORD_ORDERED_LEAST, __VA_ARGS__)

◆ MM_CMPISTRI_UBYTE_TEST_CASES

#define MM_CMPISTRI_UBYTE_TEST_CASES (   _,
  ... 
)
Value:
_(UBYTE_ANY_LEAST, __VA_ARGS__) \
_(UBYTE_EACH_MOST_MASKED_NEGATIVE, __VA_ARGS__) \
_(UBYTE_RANGES_LEAST, __VA_ARGS__) \
_(UBYTE_ORDERED_LEAST, __VA_ARGS__)

◆ MM_CMPISTRI_UWORD_TEST_CASES

#define MM_CMPISTRI_UWORD_TEST_CASES (   _,
  ... 
)
Value:
_(UWORD_EACH_LEAST, __VA_ARGS__) \
_(UWORD_ANY_LEAST, __VA_ARGS__) \
_(UWORD_RANGES_LEAST, __VA_ARGS__) \
_(UWORD_ORDERED_MOST_NEGATIVE, __VA_ARGS__)

◆ MM_CMPISTRM_SBYTE_TEST_CASES

#define MM_CMPISTRM_SBYTE_TEST_CASES (   _,
  ... 
)
Value:
_(SBYTE_EACH_BIT_MASKED_NEGATIVE, __VA_ARGS__) \
_(SBYTE_ANY_UNIT, __VA_ARGS__) \
_(SBYTE_RANGES_UNIT, __VA_ARGS__) \
_(SBYTE_ORDERED_UNIT, __VA_ARGS__)

◆ MM_CMPISTRM_SWORD_TEST_CASES

#define MM_CMPISTRM_SWORD_TEST_CASES (   _,
  ... 
)
Value:
_(SWORD_RANGES_UNIT, __VA_ARGS__) \
_(SWORD_EACH_UNIT, __VA_ARGS__) \
_(SWORD_ANY_UNIT, __VA_ARGS__) \
_(SWORD_ORDERED_UNIT, __VA_ARGS__)

◆ MM_CMPISTRM_UBYTE_TEST_CASES

#define MM_CMPISTRM_UBYTE_TEST_CASES (   _,
  ... 
)
Value:
_(UBYTE_EACH_UNIT, __VA_ARGS__) \
_(UBYTE_ANY_BIT, __VA_ARGS__) \
_(UBYTE_RANGES_UNIT, __VA_ARGS__) \
_(UBYTE_ORDERED_UNIT, __VA_ARGS__)

◆ MM_CMPISTRM_UWORD_TEST_CASES

#define MM_CMPISTRM_UWORD_TEST_CASES (   _,
  ... 
)
Value:
_(UWORD_RANGES_UNIT, __VA_ARGS__) \
_(UWORD_EACH_UNIT, __VA_ARGS__) \
_(UWORD_ANY_UNIT, __VA_ARGS__) \
_(UWORD_ORDERED_UNIT_NEGATIVE, __VA_ARGS__)

◆ MM_CMPISTRO_SBYTE_TEST_CASES

#define MM_CMPISTRO_SBYTE_TEST_CASES (   _,
  ... 
)
Value:
_(SBYTE_EACH_LEAST, __VA_ARGS__) \
_(SBYTE_ANY_LEAST, __VA_ARGS__) \
_(SBYTE_RANGES_MOST_NEGATIVE, __VA_ARGS__) \
_(SBYTE_ORDERED_LEAST, __VA_ARGS__)

◆ MM_CMPISTRO_SWORD_TEST_CASES

#define MM_CMPISTRO_SWORD_TEST_CASES (   _,
  ... 
)
Value:
_(SWORD_RANGES_LEAST, __VA_ARGS__) \
_(SWORD_EACH_LEAST, __VA_ARGS__) \
_(SWORD_ANY_MOST_MASKED_NEGATIVE, __VA_ARGS__) \
_(SWORD_ORDERED_LEAST, __VA_ARGS__)

◆ MM_CMPISTRO_UBYTE_TEST_CASES

#define MM_CMPISTRO_UBYTE_TEST_CASES (   _,
  ... 
)
Value:
_(UBYTE_ANY_LEAST, __VA_ARGS__) \
_(UBYTE_EACH_MOST_NEGATIVE, __VA_ARGS__) \
_(UBYTE_RANGES_LEAST, __VA_ARGS__) \
_(UBYTE_ORDERED_LEAST, __VA_ARGS__)

◆ MM_CMPISTRO_UWORD_TEST_CASES

#define MM_CMPISTRO_UWORD_TEST_CASES (   _,
  ... 
)
Value:
_(UWORD_EACH_LEAST, __VA_ARGS__) \
_(UWORD_ANY_LEAST, __VA_ARGS__) \
_(UWORD_RANGES_LEAST, __VA_ARGS__) \
_(UWORD_ORDERED_MOST_MASKED_NEGATIVE, __VA_ARGS__)

◆ MM_CMPISTRS_SBYTE_TEST_CASES

#define MM_CMPISTRS_SBYTE_TEST_CASES (   _,
  ... 
)
Value:
_(SBYTE_EACH_LEAST, __VA_ARGS__) \
_(SBYTE_ANY_LEAST, __VA_ARGS__) \
_(SBYTE_RANGES_LEAST, __VA_ARGS__) \
_(SBYTE_ORDERED_LEAST, __VA_ARGS__)

◆ MM_CMPISTRS_SWORD_TEST_CASES

#define MM_CMPISTRS_SWORD_TEST_CASES (   _,
  ... 
)
Value:
_(SWORD_RANGES_LEAST, __VA_ARGS__) \
_(SWORD_EACH_LEAST, __VA_ARGS__) \
_(SWORD_ANY_LEAST, __VA_ARGS__) \
_(SWORD_ORDERED_LEAST, __VA_ARGS__)

◆ MM_CMPISTRS_UBYTE_TEST_CASES

#define MM_CMPISTRS_UBYTE_TEST_CASES (   _,
  ... 
)
Value:
_(UBYTE_ANY_LEAST, __VA_ARGS__) \
_(UBYTE_EACH_LEAST, __VA_ARGS__) \
_(UBYTE_RANGES_LEAST, __VA_ARGS__) \
_(UBYTE_ORDERED_LEAST, __VA_ARGS__)

◆ MM_CMPISTRS_UWORD_TEST_CASES

#define MM_CMPISTRS_UWORD_TEST_CASES (   _,
  ... 
)
Value:
_(UWORD_EACH_LEAST, __VA_ARGS__) \
_(UWORD_ANY_LEAST, __VA_ARGS__) \
_(UWORD_RANGES_LEAST, __VA_ARGS__) \
_(UWORD_ORDERED_LEAST, __VA_ARGS__)

◆ MM_CMPISTRZ_SBYTE_TEST_CASES

#define MM_CMPISTRZ_SBYTE_TEST_CASES (   _,
  ... 
)
Value:
_(SBYTE_EACH_LEAST, __VA_ARGS__) \
_(SBYTE_ANY_LEAST, __VA_ARGS__) \
_(SBYTE_RANGES_LEAST, __VA_ARGS__) \
_(SBYTE_ORDERED_LEAST, __VA_ARGS__)

◆ MM_CMPISTRZ_SWORD_TEST_CASES

#define MM_CMPISTRZ_SWORD_TEST_CASES (   _,
  ... 
)
Value:
_(SWORD_RANGES_LEAST, __VA_ARGS__) \
_(SWORD_EACH_LEAST, __VA_ARGS__) \
_(SWORD_ANY_LEAST, __VA_ARGS__) \
_(SWORD_ORDERED_LEAST, __VA_ARGS__)

◆ MM_CMPISTRZ_UBYTE_TEST_CASES

#define MM_CMPISTRZ_UBYTE_TEST_CASES (   _,
  ... 
)
Value:
_(UBYTE_ANY_LEAST, __VA_ARGS__) \
_(UBYTE_EACH_LEAST, __VA_ARGS__) \
_(UBYTE_RANGES_LEAST, __VA_ARGS__) \
_(UBYTE_ORDERED_LEAST, __VA_ARGS__)

◆ MM_CMPISTRZ_UWORD_TEST_CASES

#define MM_CMPISTRZ_UWORD_TEST_CASES (   _,
  ... 
)
Value:
_(UWORD_EACH_LEAST, __VA_ARGS__) \
_(UWORD_ANY_LEAST, __VA_ARGS__) \
_(UWORD_RANGES_LEAST, __VA_ARGS__) \
_(UWORD_ORDERED_LEAST, __VA_ARGS__)

◆ MM_DP_PD_TEST_CASE_WITH

#define MM_DP_PD_TEST_CASE_WITH (   imm8)
Value:
do { \
const double *_a = (const double *) impl.mTestFloatPointer1; \
const double *_b = (const double *) impl.mTestFloatPointer2; \
const int imm = imm8; \
double d[2]; \
double sum = 0; \
for (size_t i = 0; i < 2; i++) \
sum += ((imm) & (1 << (i + 4))) ? _a[i] * _b[i] : 0; \
for (size_t i = 0; i < 2; i++) \
d[i] = (imm & (1 << i)) ? sum : 0; \
__m128d a = load_m128d(_a); \
__m128d b = load_m128d(_b); \
__m128d ret = _mm_dp_pd(a, b, imm); \
if (validateDouble(ret, d[0], d[1]) != TEST_SUCCESS) \
return TEST_FAIL; \
} while (0)
float32x4_t __m128d
Definition: sse2neon.h:373
FORCE_INLINE __m128d _mm_dp_pd(__m128d a, __m128d b, const int imm)
Definition: sse2neon.h:6949

◆ MM_DP_PS_TEST_CASE_WITH

#define MM_DP_PS_TEST_CASE_WITH (   IMM)
Value:
do { \
const float *_a = impl.mTestFloatPointer1; \
const float *_b = impl.mTestFloatPointer2; \
const int imm = IMM; \
__m128 a = load_m128(_a); \
__m128 b = load_m128(_b); \
__m128 out = _mm_dp_ps(a, b, imm); \
float r[4]; /* the reference */ \
float sum = 0; \
for (size_t i = 0; i < 4; i++) \
sum += ((imm) & (1 << (i + 4))) ? _a[i] * _b[i] : 0; \
for (size_t i = 0; i < 4; i++) \
r[i] = (imm & (1 << i)) ? sum : 0; \
/* the epsilon has to be large enough, otherwise test suite fails. */ \
if (validateFloatEpsilon(out, r[0], r[1], r[2], r[3], 2050.0f) != \
TEST_SUCCESS) \
return TEST_FAIL; \
} while (0)
float32x4_t __m128
Definition: sse2neon.h:366
FORCE_INLINE __m128 _mm_dp_ps(__m128 a, __m128 b, const int imm)
Definition: sse2neon.h:6995

◆ MULTIPLY

#define MULTIPLY (   x,
 
)
Value:
(((y & 1) * x) ^ ((y >> 1 & 1) * XT(x)) ^ ((y >> 2 & 1) * XT(XT(x))) ^ \
((y >> 3 & 1) * XT(XT(XT(x)))) ^ ((y >> 4 & 1) * XT(XT(XT(XT(x))))))
#define XT(x)
Definition: impl.cpp:612

◆ PRIMITIVE_CAT

#define PRIMITIVE_CAT (   a,
  ... 
)    a##__VA_ARGS__

◆ SSE2NEON_INIT_RNG

#define SSE2NEON_INIT_RNG (   seed)
Value:
do { \
state = seed; \
} while (0)

◆ TEST_IMPL [1/24]

#define TEST_IMPL (   IDX)
Value:
int16_t d##IDX[4]; \
for (int i = 0; i < 4; i++) { \
d##IDX[i] = _a[i]; \
} \
d##IDX[IDX] = insert; \
\
a = load_m64(_a); \
b = _mm_insert_pi16(a, insert, IDX); \
CHECK_RESULT(VALIDATE_INT16_M64(b, d##IDX))
#define VALIDATE_INT16_M64(A, B)
Definition: common.h:209
#define _mm_insert_pi16(a, b, imm)
Definition: sse2neon.h:1836

◆ TEST_IMPL [2/24]

#define TEST_IMPL (   IDX)
Value:
a = load_m64(_a); \
d = _mm_shuffle_pi16(a, IDX); \
\
int16_t _d##IDX[4]; \
_d##IDX[0] = _a[IDX & 0x3]; \
_d##IDX[1] = _a[(IDX >> 2) & 0x3]; \
_d##IDX[2] = _a[(IDX >> 4) & 0x3]; \
_d##IDX[3] = _a[(IDX >> 6) & 0x3]; \
if (VALIDATE_INT16_M64(d, _d##IDX) != TEST_SUCCESS) { \
return TEST_FAIL; \
}
#define _mm_shuffle_pi16(a, imm)
Definition: sse2neon.h:2514

◆ TEST_IMPL [3/24]

#define TEST_IMPL (   IDX)
Value:
int16_t d##IDX[8]; \
for (int i = 0; i < 8; i++) { \
d##IDX[i] = _a[i]; \
} \
d##IDX[IDX] = insert; \
\
__m128i a##IDX = load_m128i(_a); \
__m128i b##IDX = _mm_insert_epi16(a##IDX, insert, IDX); \
CHECK_RESULT(VALIDATE_INT16_M128(b##IDX, d##IDX))
#define VALIDATE_INT16_M128(A, B)
Definition: common.h:198
#define _mm_insert_epi16(a, b, imm)
Definition: sse2neon.h:4218

◆ TEST_IMPL [4/24]

#define TEST_IMPL (   IDX)
Value:
int32_t d##IDX[4]; \
d##IDX[0] = _a[((IDX) &0x3)]; \
d##IDX[1] = _a[((IDX >> 2) & 0x3)]; \
d##IDX[2] = _a[((IDX >> 4) & 0x3)]; \
d##IDX[3] = _a[((IDX >> 6) & 0x3)]; \
\
a = load_m128i(_a); \
c = _mm_shuffle_epi32(a, IDX); \
CHECK_RESULT(VALIDATE_INT32_M128(c, d##IDX))
#define VALIDATE_INT32_M128(A, B)
Definition: common.h:202
#define _mm_shuffle_epi32(a, imm)
Definition: sse2neon.h:5063

◆ TEST_IMPL [5/24]

#define TEST_IMPL (   IDX)
Value:
a = load_m128d(_a); \
b = load_m128d(_b); \
c = _mm_shuffle_pd(a, b, IDX); \
\
double d0##IDX = _a[IDX & 0x1]; \
double d1##IDX = _b[(IDX & 0x2) >> 1]; \
CHECK_RESULT(validateDouble(c, d0##IDX, d1##IDX))
#define _mm_shuffle_pd(a, b, imm8)
Definition: sse2neon.h:5123

◆ TEST_IMPL [6/24]

#define TEST_IMPL (   IDX)
Value:
int16_t d##IDX[8]; \
d##IDX[0] = _a[0]; \
d##IDX[1] = _a[1]; \
d##IDX[2] = _a[2]; \
d##IDX[3] = _a[3]; \
d##IDX[4] = (int16_t) (((const int64_t *) _a)[1] >> ((IDX & 0x3) * 16)); \
d##IDX[5] = \
(int16_t) (((const int64_t *) _a)[1] >> (((IDX >> 2) & 0x3) * 16)); \
d##IDX[6] = \
(int16_t) (((const int64_t *) _a)[1] >> (((IDX >> 4) & 0x3) * 16)); \
d##IDX[7] = \
(int16_t) (((const int64_t *) _a)[1] >> (((IDX >> 6) & 0x3) * 16)); \
\
a = load_m128i(_a); \
c = _mm_shufflehi_epi16(a, IDX); \
\
CHECK_RESULT(VALIDATE_INT16_M128(c, d##IDX))
#define _mm_shufflehi_epi16(a, imm)
Definition: sse2neon.h:5142

◆ TEST_IMPL [7/24]

#define TEST_IMPL (   IDX)
Value:
int16_t d##IDX[8]; \
d##IDX[0] = (int16_t) (((const int64_t *) _a)[0] >> ((IDX & 0x3) * 16)); \
d##IDX[1] = \
(int16_t) (((const int64_t *) _a)[0] >> (((IDX >> 2) & 0x3) * 16)); \
d##IDX[2] = \
(int16_t) (((const int64_t *) _a)[0] >> (((IDX >> 4) & 0x3) * 16)); \
d##IDX[3] = \
(int16_t) (((const int64_t *) _a)[0] >> (((IDX >> 6) & 0x3) * 16)); \
d##IDX[4] = _a[4]; \
d##IDX[5] = _a[5]; \
d##IDX[6] = _a[6]; \
d##IDX[7] = _a[7]; \
\
a = load_m128i(_a); \
c = _mm_shufflelo_epi16(a, IDX); \
\
CHECK_RESULT(VALIDATE_INT16_M128(c, d##IDX))
#define _mm_shufflelo_epi16(a, imm)
Definition: sse2neon.h:5157

◆ TEST_IMPL [8/24]

#define TEST_IMPL (   IDX)
Value:
uint16_t d##IDX[8]; \
idx = IDX; \
d##IDX[0] = (idx > 15) ? 0 : _a[0] << idx; \
d##IDX[1] = (idx > 15) ? 0 : _a[1] << idx; \
d##IDX[2] = (idx > 15) ? 0 : _a[2] << idx; \
d##IDX[3] = (idx > 15) ? 0 : _a[3] << idx; \
d##IDX[4] = (idx > 15) ? 0 : _a[4] << idx; \
d##IDX[5] = (idx > 15) ? 0 : _a[5] << idx; \
d##IDX[6] = (idx > 15) ? 0 : _a[6] << idx; \
d##IDX[7] = (idx > 15) ? 0 : _a[7] << idx; \
\
a = load_m128i(_a); \
b = _mm_set1_epi64x(IDX); \
c = _mm_sll_epi16(a, b); \
CHECK_RESULT(VALIDATE_INT16_M128(c, d##IDX))
FORCE_INLINE __m128i _mm_set1_epi64x(int64_t _i)
Definition: sse2neon.h:4941
FORCE_INLINE __m128i _mm_sll_epi16(__m128i a, __m128i count)
Definition: sse2neon.h:5163

◆ TEST_IMPL [9/24]

#define TEST_IMPL (   IDX)
Value:
uint32_t d##IDX[4]; \
idx = IDX; \
d##IDX[0] = (idx > 31) ? 0 : _a[0] << idx; \
d##IDX[1] = (idx > 31) ? 0 : _a[1] << idx; \
d##IDX[2] = (idx > 31) ? 0 : _a[2] << idx; \
d##IDX[3] = (idx > 31) ? 0 : _a[3] << idx; \
\
a = load_m128i(_a); \
b = _mm_set1_epi64x(IDX); \
c = _mm_sll_epi32(a, b); \
CHECK_RESULT(VALIDATE_INT32_M128(c, d##IDX))
FORCE_INLINE __m128i _mm_sll_epi32(__m128i a, __m128i count)
Definition: sse2neon.h:5176

◆ TEST_IMPL [10/24]

#define TEST_IMPL (   IDX)
Value:
uint64_t d0##IDX = (IDX & ~63) ? 0 : _a[0] << IDX; \
uint64_t d1##IDX = (IDX & ~63) ? 0 : _a[1] << IDX; \
\
a = load_m128i(_a); \
b = _mm_set1_epi64x(IDX); \
c = _mm_sll_epi64(a, b); \
\
CHECK_RESULT(validateInt64(c, d0##IDX, d1##IDX))
FORCE_INLINE __m128i _mm_sll_epi64(__m128i a, __m128i count)
Definition: sse2neon.h:5189

◆ TEST_IMPL [11/24]

#define TEST_IMPL (   IDX)
Value:
int16_t d##IDX[8]; \
idx = IDX; \
d##IDX[0] = (idx > 15) ? 0 : _a[0] << idx; \
d##IDX[1] = (idx > 15) ? 0 : _a[1] << idx; \
d##IDX[2] = (idx > 15) ? 0 : _a[2] << idx; \
d##IDX[3] = (idx > 15) ? 0 : _a[3] << idx; \
d##IDX[4] = (idx > 15) ? 0 : _a[4] << idx; \
d##IDX[5] = (idx > 15) ? 0 : _a[5] << idx; \
d##IDX[6] = (idx > 15) ? 0 : _a[6] << idx; \
d##IDX[7] = (idx > 15) ? 0 : _a[7] << idx; \
\
a = load_m128i(_a); \
c = _mm_slli_epi16(a, IDX); \
CHECK_RESULT(VALIDATE_INT16_M128(c, d##IDX))
FORCE_INLINE __m128i _mm_slli_epi16(__m128i a, int imm)
Definition: sse2neon.h:5202

◆ TEST_IMPL [12/24]

#define TEST_IMPL (   IDX)
Value:
for (int j = 0; j < 8; j++) { \
if ((IDX >> j) & 0x1) { \
_c[j] = _b[j]; \
} else { \
_c[j] = _a[j]; \
} \
} \
a = load_m128i(_a); \
b = load_m128i(_b); \
c = _mm_blend_epi16(a, b, IDX); \
CHECK_RESULT(VALIDATE_INT16_M128(c, _c));
__m128i load_m128i(const T *p)
Definition: impl.cpp:414
#define _mm_blend_epi16(a, b, imm)
Definition: sse2neon.h:6664

◆ TEST_IMPL [13/24]

#define TEST_IMPL (   IDX)
Value:
double _c##IDX[2]; \
for (int j = 0; j < 2; j++) { \
if ((IDX >> j) & 0x1) { \
_c##IDX[j] = _b[j]; \
} else { \
_c##IDX[j] = _a[j]; \
} \
} \
\
a = load_m128d(_a); \
b = load_m128d(_b); \
c = _mm_blend_pd(a, b, IDX); \
CHECK_RESULT(validateDouble(c, _c##IDX[0], _c##IDX[1]))
result_t validateDouble(__m128d a, double d0, double d1)
Definition: common.cpp:387
__m128d load_m128d(const T *p)
Definition: impl.cpp:424
#define _mm_blend_pd(a, b, imm)
Definition: sse2neon.h:6684

◆ TEST_IMPL [14/24]

#define TEST_IMPL (   IDX)
Value:
float _c##IDX[4]; \
for (int i = 0; i < 4; i++) { \
if (IDX & (1 << i)) { \
_c##IDX[i] = _b[i]; \
} else { \
_c##IDX[i] = _a[i]; \
} \
} \
\
c = _mm_blend_ps(a, b, IDX); \
CHECK_RESULT( \
validateFloat(c, _c##IDX[0], _c##IDX[1], _c##IDX[2], _c##IDX[3]))
result_t validateFloat(__m128 a, float f0, float f1, float f2, float f3)
Definition: common.cpp:297
FORCE_INLINE __m128 _mm_blend_ps(__m128 _a, __m128 _b, const char imm8)
Definition: sse2neon.h:6698

◆ TEST_IMPL [15/24]

#define TEST_IMPL (   IDX)
Value:
c = _mm_extract_epi32(a, IDX); \
ASSERT_RETURN(c == *(_a + IDX));
#define _mm_extract_epi32(a, imm)
Definition: sse2neon.h:7043

◆ TEST_IMPL [16/24]

#define TEST_IMPL (   IDX)
Value:
c = _mm_extract_epi64(a, IDX); \
ASSERT_RETURN(c == *(_a + IDX));
#define _mm_extract_epi64(a, imm)
Definition: sse2neon.h:7050

◆ TEST_IMPL [17/24]

#define TEST_IMPL (   IDX)
Value:
c = _mm_extract_epi8(a, IDX); \
ASSERT_RETURN(c == *(_a + IDX));
#define _mm_extract_epi8(a, imm)
Definition: sse2neon.h:7057

◆ TEST_IMPL [18/24]

#define TEST_IMPL (   IDX)
Value:
c = _mm_extract_ps(a, IDX); \
ASSERT_RETURN(c == *(const int32_t *) (_a + IDX));
#define _mm_extract_ps(a, imm)
Definition: sse2neon.h:7061

◆ TEST_IMPL [19/24]

#define TEST_IMPL (   IDX)
Value:
int32_t d##IDX[4]; \
for (int i = 0; i < 4; i++) { \
d##IDX[i] = _a[i]; \
} \
d##IDX[IDX] = insert; \
\
a = load_m128i(_a); \
b = _mm_insert_epi32(a, (int) insert, IDX); \
CHECK_RESULT(VALIDATE_INT32_M128(b, d##IDX));
#define _mm_insert_epi32(a, b, imm)
Definition: sse2neon.h:7117

◆ TEST_IMPL [20/24]

#define TEST_IMPL (   IDX)
Value:
d[0] = _a[0]; \
d[1] = _a[1]; \
d[IDX] = insert; \
a = load_m128i(_a); \
b = _mm_insert_epi64(a, insert, IDX); \
CHECK_RESULT(validateInt64(b, d[0], d[1]));
#define _mm_insert_epi64(a, b, imm)
Definition: sse2neon.h:7126

◆ TEST_IMPL [21/24]

#define TEST_IMPL (   IDX)
Value:
for (int i = 0; i < 16; i++) { \
d[i] = _a[i]; \
} \
d[IDX] = insert; \
a = load_m128i(_a); \
b = _mm_insert_epi8(a, insert, IDX); \
CHECK_RESULT(VALIDATE_INT8_M128(b, d));
#define VALIDATE_INT8_M128(A, B)
Definition: common.h:192
#define _mm_insert_epi8(a, b, imm)
Definition: sse2neon.h:7135

◆ TEST_IMPL [22/24]

#define TEST_IMPL (   IDX)
Value:
float d##IDX[4] = {_a[0], _a[1], _a[2], _a[3]}; \
d##IDX[(IDX >> 4) & 0x3] = _b[(IDX >> 6) & 0x3]; \
\
for (int j = 0; j < 4; j++) { \
if (IDX & (1 << j)) { \
d##IDX[j] = 0; \
} \
} \
\
a = _mm_load_ps(_a); \
b = _mm_load_ps(_b); \
c = _mm_insert_ps(a, b, IDX); \
CHECK_RESULT(validateFloat(c, d##IDX[0], d##IDX[1], d##IDX[2], d##IDX[3]));
FORCE_INLINE __m128 _mm_load_ps(const float *p)
Definition: sse2neon.h:1843
#define _mm_insert_ps(a, b, imm8)
Definition: sse2neon.h:7142

◆ TEST_IMPL [23/24]

#define TEST_IMPL (   IDX)
Value:
uint8_t a_offset##IDX = ((IDX >> 2) & 0x1) * 4; \
uint8_t b_offset##IDX = (IDX & 0x3) * 4; \
\
uint16_t d##IDX[8] = {}; \
for (int i = 0; i < 8; i++) { \
for (int j = 0; j < 4; j++) { \
d##IDX[i] += \
abs(_a[(a_offset##IDX + i) + j] - _b[b_offset##IDX + j]); \
} \
} \
c = _mm_mpsadbw_epu8(a, b, IDX); \
CHECK_RESULT(VALIDATE_UINT16_M128(c, d##IDX));
#define VALIDATE_UINT16_M128(A, B)
Definition: common.h:200
FORCE_INLINE __m128i _mm_mpsadbw_epu8(__m128i a, __m128i b, const int imm)
Definition: sse2neon.h:7287

◆ TEST_IMPL [24/24]

#define TEST_IMPL (   IDX)
Value:
uint32_t res##IDX[4] = { \
sub_x1, \
rotr(sub_x1, 8) ^ IDX, \
sub_x3, \
rotr(sub_x3, 8) ^ IDX, \
}; \
result_reference = load_m128i(res##IDX); \
result_intrinsic = _mm_aeskeygenassist_si128(data, IDX); \
CHECK_RESULT(validate128(result_reference, result_intrinsic));
FORCE_INLINE __m128i _mm_aeskeygenassist_si128(__m128i a, const int rcon)
Definition: sse2neon.h:8914

◆ TEST_MM_CMPESTRA_SBYTE_DATA_LEN

#define TEST_MM_CMPESTRA_SBYTE_DATA_LEN   3

◆ TEST_MM_CMPESTRA_SWORD_DATA_LEN

#define TEST_MM_CMPESTRA_SWORD_DATA_LEN   3

◆ TEST_MM_CMPESTRA_UBYTE_DATA_LEN

#define TEST_MM_CMPESTRA_UBYTE_DATA_LEN   3

◆ TEST_MM_CMPESTRA_UWORD_DATA_LEN

#define TEST_MM_CMPESTRA_UWORD_DATA_LEN   3

◆ TEST_MM_CMPESTRC_SBYTE_DATA_LEN

#define TEST_MM_CMPESTRC_SBYTE_DATA_LEN   4

◆ TEST_MM_CMPESTRC_SWORD_DATA_LEN

#define TEST_MM_CMPESTRC_SWORD_DATA_LEN   4

◆ TEST_MM_CMPESTRC_UBYTE_DATA_LEN

#define TEST_MM_CMPESTRC_UBYTE_DATA_LEN   4

◆ TEST_MM_CMPESTRC_UWORD_DATA_LEN

#define TEST_MM_CMPESTRC_UWORD_DATA_LEN   4

◆ TEST_MM_CMPESTRI_SBYTE_DATA_LEN

#define TEST_MM_CMPESTRI_SBYTE_DATA_LEN   4

◆ TEST_MM_CMPESTRI_SWORD_DATA_LEN

#define TEST_MM_CMPESTRI_SWORD_DATA_LEN   4

◆ TEST_MM_CMPESTRI_UBYTE_DATA_LEN

#define TEST_MM_CMPESTRI_UBYTE_DATA_LEN   4

◆ TEST_MM_CMPESTRI_UWORD_DATA_LEN

#define TEST_MM_CMPESTRI_UWORD_DATA_LEN   4

◆ TEST_MM_CMPESTRM_SBYTE_DATA_LEN

#define TEST_MM_CMPESTRM_SBYTE_DATA_LEN   4

◆ TEST_MM_CMPESTRM_SWORD_DATA_LEN

#define TEST_MM_CMPESTRM_SWORD_DATA_LEN   4

◆ TEST_MM_CMPESTRM_UBYTE_DATA_LEN

#define TEST_MM_CMPESTRM_UBYTE_DATA_LEN   4

◆ TEST_MM_CMPESTRM_UWORD_DATA_LEN

#define TEST_MM_CMPESTRM_UWORD_DATA_LEN   4

◆ TEST_MM_CMPESTRO_SBYTE_DATA_LEN

#define TEST_MM_CMPESTRO_SBYTE_DATA_LEN   4

◆ TEST_MM_CMPESTRO_SWORD_DATA_LEN

#define TEST_MM_CMPESTRO_SWORD_DATA_LEN   4

◆ TEST_MM_CMPESTRO_UBYTE_DATA_LEN

#define TEST_MM_CMPESTRO_UBYTE_DATA_LEN   4

◆ TEST_MM_CMPESTRO_UWORD_DATA_LEN

#define TEST_MM_CMPESTRO_UWORD_DATA_LEN   4

◆ TEST_MM_CMPESTRS_SBYTE_DATA_LEN

#define TEST_MM_CMPESTRS_SBYTE_DATA_LEN   2

◆ TEST_MM_CMPESTRS_SWORD_DATA_LEN

#define TEST_MM_CMPESTRS_SWORD_DATA_LEN   2

◆ TEST_MM_CMPESTRS_UBYTE_DATA_LEN

#define TEST_MM_CMPESTRS_UBYTE_DATA_LEN   2

◆ TEST_MM_CMPESTRS_UWORD_DATA_LEN

#define TEST_MM_CMPESTRS_UWORD_DATA_LEN   2

◆ TEST_MM_CMPESTRZ_SBYTE_DATA_LEN

#define TEST_MM_CMPESTRZ_SBYTE_DATA_LEN   2

◆ TEST_MM_CMPESTRZ_SWORD_DATA_LEN

#define TEST_MM_CMPESTRZ_SWORD_DATA_LEN   2

◆ TEST_MM_CMPESTRZ_UBYTE_DATA_LEN

#define TEST_MM_CMPESTRZ_UBYTE_DATA_LEN   2

◆ TEST_MM_CMPESTRZ_UWORD_DATA_LEN

#define TEST_MM_CMPESTRZ_UWORD_DATA_LEN   2

◆ TEST_MM_CMPISTRA_SBYTE_DATA_LEN

#define TEST_MM_CMPISTRA_SBYTE_DATA_LEN   4

◆ TEST_MM_CMPISTRA_SWORD_DATA_LEN

#define TEST_MM_CMPISTRA_SWORD_DATA_LEN   4

◆ TEST_MM_CMPISTRA_UBYTE_DATA_LEN

#define TEST_MM_CMPISTRA_UBYTE_DATA_LEN   4

◆ TEST_MM_CMPISTRA_UWORD_DATA_LEN

#define TEST_MM_CMPISTRA_UWORD_DATA_LEN   4

◆ TEST_MM_CMPISTRC_SBYTE_DATA_LEN

#define TEST_MM_CMPISTRC_SBYTE_DATA_LEN   4

◆ TEST_MM_CMPISTRC_SWORD_DATA_LEN

#define TEST_MM_CMPISTRC_SWORD_DATA_LEN   4

◆ TEST_MM_CMPISTRC_UBYTE_DATA_LEN

#define TEST_MM_CMPISTRC_UBYTE_DATA_LEN   4

◆ TEST_MM_CMPISTRC_UWORD_DATA_LEN

#define TEST_MM_CMPISTRC_UWORD_DATA_LEN   4

◆ TEST_MM_CMPISTRI_SBYTE_DATA_LEN

#define TEST_MM_CMPISTRI_SBYTE_DATA_LEN   4

◆ TEST_MM_CMPISTRI_SWORD_DATA_LEN

#define TEST_MM_CMPISTRI_SWORD_DATA_LEN   4

◆ TEST_MM_CMPISTRI_UBYTE_DATA_LEN

#define TEST_MM_CMPISTRI_UBYTE_DATA_LEN   4

◆ TEST_MM_CMPISTRI_UWORD_DATA_LEN

#define TEST_MM_CMPISTRI_UWORD_DATA_LEN   4

◆ TEST_MM_CMPISTRM_SBYTE_DATA_LEN

#define TEST_MM_CMPISTRM_SBYTE_DATA_LEN   4

◆ TEST_MM_CMPISTRM_SWORD_DATA_LEN

#define TEST_MM_CMPISTRM_SWORD_DATA_LEN   4

◆ TEST_MM_CMPISTRM_UBYTE_DATA_LEN

#define TEST_MM_CMPISTRM_UBYTE_DATA_LEN   4

◆ TEST_MM_CMPISTRM_UWORD_DATA_LEN

#define TEST_MM_CMPISTRM_UWORD_DATA_LEN   4

◆ TEST_MM_CMPISTRO_SBYTE_DATA_LEN

#define TEST_MM_CMPISTRO_SBYTE_DATA_LEN   4

◆ TEST_MM_CMPISTRO_SWORD_DATA_LEN

#define TEST_MM_CMPISTRO_SWORD_DATA_LEN   4

◆ TEST_MM_CMPISTRO_UBYTE_DATA_LEN

#define TEST_MM_CMPISTRO_UBYTE_DATA_LEN   4

◆ TEST_MM_CMPISTRO_UWORD_DATA_LEN

#define TEST_MM_CMPISTRO_UWORD_DATA_LEN   4

◆ TEST_MM_CMPISTRS_SBYTE_DATA_LEN

#define TEST_MM_CMPISTRS_SBYTE_DATA_LEN   4

◆ TEST_MM_CMPISTRS_SWORD_DATA_LEN

#define TEST_MM_CMPISTRS_SWORD_DATA_LEN   4

◆ TEST_MM_CMPISTRS_UBYTE_DATA_LEN

#define TEST_MM_CMPISTRS_UBYTE_DATA_LEN   4

◆ TEST_MM_CMPISTRS_UWORD_DATA_LEN

#define TEST_MM_CMPISTRS_UWORD_DATA_LEN   4

◆ TEST_MM_CMPISTRZ_SBYTE_DATA_LEN

#define TEST_MM_CMPISTRZ_SBYTE_DATA_LEN   4

◆ TEST_MM_CMPISTRZ_SWORD_DATA_LEN

#define TEST_MM_CMPISTRZ_SWORD_DATA_LEN   4

◆ TEST_MM_CMPISTRZ_UBYTE_DATA_LEN

#define TEST_MM_CMPISTRZ_UBYTE_DATA_LEN   4

◆ TEST_MM_CMPISTRZ_UWORD_DATA_LEN

#define TEST_MM_CMPISTRZ_UWORD_DATA_LEN   4

◆ XT

#define XT (   x)    (((x) << 1) ^ ((((x) >> 7) & 1) * 0x1b))