| /* |
| * Test min, max and shift instructions |
| * This test was created to check the correctness |
| * of the following intrinsics support: |
| * _mm512_[mask|maskz]_[abs|min|max] |
| * _mm512_[mask|maskz]_[sll|slli|srai|srli|sra|srl]_* |
| * _mm512_[mask|maskz]_cvtep*_ep* |
| * _mm256_cvtepi16_epi64 |
| * _mm256_sll |
| * _mm_cvtepi16_epi64 |
| * _mm_sll |
| */ |
| #include "m512_test_util.h" |
| #include <stdio.h> |
| #include <string.h> |
| |
| V512 i8; |
| V512 i8_mix; |
| V512 i8_big; |
| V512 i16; |
| V512 i16_mix; |
| V512 i16_big; |
| V512 i32; |
| V512 i32_mix; |
| V512 i32_big; |
| V512 i64; |
| V512 i64_mix; |
| V512 i64_big; |
| volatile int vol0 = 0; |
| /* |
| * Use this between tests to make compiler think src was updated. |
| * Prevents PRE'ing of a load of src, thus allowing ciscization. |
| */ |
| #define soft_update(src) (src).xmmi[vol0] = (src).xmmi[vol0] |
| |
| void NOINLINE init() { |
| volatile int i; |
| |
| for (i = 0; i < 64; i++) { |
| i8.s8[i] = i; |
| i8_mix.s8[i] = (i & 1) ? i : -i; |
| i8_big.s8[i] = 1000 * (i + 1); |
| if ((i & 1) != 0) { |
| i8_big.s8[i] = -i8_big.s8[i]; |
| } |
| } |
| |
| for (i = 0; i < 32; i++) { |
| i16.s16[i] = i; |
| i16_mix.s16[i] = (i & 1) ? i : -i; |
| i16_big.s16[i] = 1000 * (i + 1); |
| if ((i & 1) != 0) { |
| i16_big.s16[i] = -i16_big.s16[i]; |
| } |
| } |
| |
| for (i = 0; i < 16; i++) { |
| i32.s32[i] = i; |
| i32_mix.s32[i] = (i & 1) ? i : -i; |
| i32_big.s32[i] = 1000 * (i + 1); |
| if ((i & 1) != 0) { |
| i32_big.s32[i] = -i32_big.s32[i]; |
| } |
| } |
| |
| for (i = 0; i < 8; i++) { |
| i64.s64[i] = i; |
| i64_mix.s64[i] = (i & 1) ? i : -i; |
| i64_big.s64[i] = 1000 * (i + 1); |
| if ((i & 1) != 0) { |
| i64_big.s64[i] = -i64_big.s64[i]; |
| } |
| } |
| } |
| |
| void NOINLINE do_absd() { |
| V512 res; |
| V512 expected; |
| __mmask16 k; |
| |
| res.zmmi = _mm512_abs_epi32(i32_mix.zmmi); |
| check_equal_nd(&res, &i32, 16, "_mm512_abs_epi32", __LINE__); |
| |
| k = 0x1234; |
| res.zmmi = _mm512_mask_abs_epi32(_mm512_setzero_epi32(), k, i32_mix.zmmi); |
| expected.zmmi = _mm512_mask_mov_epi32(_mm512_setzero_epi32(), k, i32.zmmi); |
| check_equal_nd(&res, &expected, 16, "_mm512_mask_abs_epi32", __LINE__); |
| } |
| |
| void NOINLINE do_absq() { |
| V512 res; |
| V512 expected; |
| __mmask8 k; |
| |
| res.zmmi = _mm512_abs_epi64(i64_mix.zmmi); |
| check_equal_nd(&res, &i64, 16, "_mm512_abs_epi64", __LINE__); |
| |
| k = 0x73; |
| res.zmmi = _mm512_mask_abs_epi64(_mm512_setzero_epi32(), k, i64_mix.zmmi); |
| expected.zmmi = _mm512_mask_mov_epi64(_mm512_setzero_epi32(), k, i64.zmmi); |
| check_equal_nd(&res, &expected, 16, "_mm512_mask_abs_epi64", __LINE__); |
| } |
| |
| void NOINLINE do_movsxwq() { |
| V512 xres, yres, zres; |
| V512 expected, expected_save; |
| volatile int i; |
| __mmask8 k8 = 0xe7; |
| |
| /* Non-masked. */ |
| |
| zres.zmmi = _mm512_cvtepi16_epi64(i16_mix.xmmi[0]); |
| for (i = 0; i < 8; i++) { |
| expected.s64[i] = i16_mix.s16[i]; |
| } |
| expected_save = expected; |
| soft_update(i16_mix); |
| soft_update(i16_mix); |
| check_equal_nd(&zres, &expected, 16, "_mm512_cvtepi16_epi64", __LINE__); |
| check_equal_nd(&yres, &expected, 8, "_mm256_cvtepi16_epi64", __LINE__); |
| check_equal_nd(&xres, &expected, 4, "_mm_cvtepi16_epi64", __LINE__); |
| |
| /* Masked. */ |
| |
| soft_update(i16_mix); |
| zres.zmmi = _mm512_setzero_epi32(); |
| yres = zres; |
| xres = zres; |
| zres.zmmi = _mm512_mask_cvtepi16_epi64(zres.zmmi, k8, i16_mix.xmmi[0]); |
| expected = expected_save; |
| for (i = 0; i < 8; i++) { |
| if ((k8 & (1 << i)) == 0) { |
| expected.s64[i] = 0; |
| } |
| } |
| soft_update(i16_mix); |
| soft_update(i16_mix); |
| check_equal_nd(&zres, &expected, 16, "_mm512_mask_cvtepi16_epi64", __LINE__); |
| |
| /* Zero-masked. */ |
| |
| zres = i8_mix; |
| yres = zres; |
| xres = zres; |
| soft_update(i16_mix); |
| zres.zmmi = _mm512_maskz_cvtepi16_epi64(k8, i16_mix.xmmi[0]); |
| for (i = 0; i < 8; i++) { |
| if ((k8 & (1 << i)) == 0) { |
| expected.s64[i] = 0; |
| } |
| } |
| soft_update(i16_mix); |
| soft_update(i16_mix); |
| soft_update(i16_mix); |
| check_equal_nd(&zres, &expected, 16, "_mm512_maskz_cvtepi16_epi64", __LINE__); |
| } |
| |
| void NOINLINE do_movsxdq() { |
| V512 xres, yres, zres; |
| V512 expected; |
| __mmask8 k8 = 0x5d; |
| |
| /* Non-masked. */ |
| |
| zres.zmmi = _mm512_cvtepi32_epi64(i32_mix.ymmi[0]); |
| expected.zmmi = _mm512_set_epi64(7, -6, 5, -4, 3, -2, 1, 0); |
| check_equal_nd(&zres, &expected, 16, "_mm512_cvtepi32_epi64", __LINE__); |
| |
| /* Masked. */ |
| |
| soft_update(i32_mix); |
| zres.zmmi = _mm512_setzero_epi32(); |
| yres = zres; |
| xres = zres; |
| zres.zmmi = _mm512_mask_cvtepi32_epi64(zres.zmmi, k8, i32_mix.ymmi[0]); |
| expected.zmmi = _mm512_set_epi64(0, -6, 0, -4, 3, -2, 0, 0); |
| soft_update(i32_mix); |
| soft_update(i32_mix); |
| check_equal_nd(&zres, &expected, 16, "_mm512_mask_cvtepi32_epi64", __LINE__); |
| |
| /* Zero-masked. */ |
| |
| k8 = 0x79; |
| soft_update(i32_mix); |
| zres = i8_mix; |
| yres = zres; |
| xres = zres; |
| zres.zmmi = _mm512_maskz_cvtepi32_epi64(k8, i32_mix.ymmi[0]); |
| soft_update(i32_mix); |
| soft_update(i32_mix); |
| expected.zmmi = _mm512_set_epi64(7, -6, 5, -4, 3, -2, 1, 0); |
| expected.zmmi = _mm512_maskz_mov_epi64(k8, expected.zmmi); |
| check_equal_nd(&zres, &expected, 16, "_mm512_maskz_cvtepi32_epi64", __LINE__); |
| } |
| |
| void NOINLINE do_movsxbd() { |
| V512 xres, yres, zres; |
| V512 expected, expected_save; |
| volatile int i; |
| __mmask16 k16 = 0xfefe; |
| __mmask8 k8 = (__mmask8)k16; |
| |
| /* Non-masked. */ |
| |
| zres.zmmi = _mm512_cvtepi8_epi32(i8_mix.xmmi[0]); |
| for (i = 0; i < 16; i++) { |
| expected.s32[i] = i8_mix.s8[i]; |
| } |
| expected_save = expected; |
| check_equal_nd(&zres, &expected, 16, "_mm512_cvtepi8_epi32", __LINE__); |
| soft_update(i8_mix); |
| |
| /* Masked. */ |
| |
| soft_update(i8_mix); |
| zres.zmmi = _mm512_setzero_epi32(); |
| yres = zres; |
| xres = zres; |
| zres.zmmi = _mm512_mask_cvtepi8_epi32(zres.zmmi, k16, i8_mix.xmmi[0]); |
| expected = expected_save; |
| for (i = 0; i < 16; i++) { |
| if ((k16 & (1 << i)) == 0) { |
| expected.s32[i] = 0; |
| } |
| } |
| check_equal_nd(&zres, &expected, 16, "_mm512_mask_cvtepi8_epi32", __LINE__); |
| soft_update(i8_mix); |
| |
| /* Zero-masked. */ |
| |
| soft_update(i8_mix); |
| k16 <<= 1; |
| k8 = (__mmask8)k16; |
| zres.zmmi = _mm512_maskz_cvtepi8_epi32(k16, i8_mix.xmmi[0]); |
| expected = expected_save; |
| for (i = 0; i < 16; i++) { |
| if ((k16 & (1 << i)) == 0) { |
| expected.s32[i] = 0; |
| } |
| } |
| check_equal_nd(&zres, &expected, 16, "_mm512_maskz_cvtepi8_epi32", __LINE__); |
| soft_update(i8_mix); |
| } |
| |
| void NOINLINE do_movsxbq() { |
| V512 xres, yres, zres; |
| V512 expected, expected_save; |
| volatile int i; |
| __mmask8 k8 = 0xfe; |
| |
| /* Non-masked. */ |
| |
| zres.zmmi = _mm512_cvtepi8_epi64(i8_mix.xmmi[0]); |
| for (i = 0; i < 8; i++) { |
| expected.s64[i] = i8_mix.s8[i]; |
| } |
| expected_save = expected; |
| check_equal_nd(&zres, &expected, 16, "_mm512_cvtepi8_epi64", __LINE__); |
| soft_update(i8_mix); |
| |
| /* Masked. */ |
| |
| soft_update(i8_mix); |
| zres.zmmi = _mm512_setzero_epi32(); |
| yres = zres; |
| xres = zres; |
| zres.zmmi = _mm512_mask_cvtepi8_epi64(zres.zmmi, k8, i8_mix.xmmi[0]); |
| expected = expected_save; |
| for (i = 0; i < 8; i++) { |
| if ((k8 & (1 << i)) == 0) { |
| expected.s64[i] = 0; |
| } |
| } |
| check_equal_nd(&zres, &expected, 16, "_mm512_mask_cvtepi8_epi64", __LINE__); |
| soft_update(i8_mix); |
| |
| /* Zero-masked. */ |
| |
| soft_update(i8_mix); |
| k8 <<= 1; |
| zres.zmmi = _mm512_maskz_cvtepi8_epi64(k8, i8_mix.xmmi[0]); |
| expected = expected_save; |
| for (i = 0; i < 8; i++) { |
| if ((k8 & (1 << i)) == 0) { |
| expected.s64[i] = 0; |
| } |
| } |
| check_equal_nd(&zres, &expected, 16, "_mm512_maskz_cvtepi8_epi64", __LINE__); |
| soft_update(i8_mix); |
| } |
| |
| void NOINLINE do_movzxwd() { |
| V512 xres, yres, zres; |
| V512 expected; |
| __mmask16 k16 = 0xc936; |
| __mmask8 k8 = (__mmask8)k16; |
| ; |
| |
| /* Non-masked. */ |
| |
| zres.zmmi = _mm512_cvtepu16_epi32(i16_mix.ymmi[0]); |
| expected.zmmi = |
| _mm512_set_epi32(15, 0xfff2, 13, 0xfff4, 11, 0xfff6, 9, 0xfff8, 7, 0xfffa, |
| 5, 0xfffc, 3, 0xfffe, 1, 0); |
| check_equal_nd(&zres, &expected, 16, "_mm512_cvtepu16_epi32", __LINE__); |
| |
| /* Masked. */ |
| |
| soft_update(i16_mix); |
| zres.zmmi = _mm512_setzero_epi32(); |
| yres = zres; |
| xres = zres; |
| zres.zmmi = _mm512_mask_cvtepu16_epi32(zres.zmmi, k16, i16_mix.ymmi[0]); |
| expected.zmmi = _mm512_set_epi32(15, 0xfff2, 0, 0, 11, 0, 0, 0xfff8, 0, 0, 5, |
| 0xfffc, 0, 0xfffe, 1, 0); |
| check_equal_nd(&zres, &expected, 16, "_mm512_mask_cvtepu16_epi32", __LINE__); |
| |
| /* Zero-masked. */ |
| |
| zres = i8_mix; |
| yres = zres; |
| xres = zres; |
| soft_update(i16_mix); |
| zres.zmmi = _mm512_maskz_cvtepu16_epi32(k16, i16_mix.ymmi[0]); |
| expected.zmmi = |
| _mm512_set_epi32(15, 0xfff2, 13, 0xfff4, 11, 0xfff6, 9, 0xfff8, 7, 0xfffa, |
| 5, 0xfffc, 3, 0xfffe, 1, 0); |
| expected.zmmi = _mm512_maskz_mov_epi32(k16, expected.zmmi); |
| check_equal_nd(&zres, &expected, 16, "_mm512_maskz_cvtepu16_epi32", __LINE__); |
| } |
| |
| void NOINLINE do_movzxwq() { |
| V512 xres, yres, zres; |
| V512 expected, expected_save; |
| volatile int i; |
| __mmask8 k8 = 0xe7; |
| |
| /* Non-masked. */ |
| |
| zres.zmmi = _mm512_cvtepu16_epi64(i16_mix.xmmi[0]); |
| for (i = 0; i < 8; i++) { |
| expected.u64[i] = i16_mix.u16[i]; |
| } |
| expected_save = expected; |
| soft_update(i16_mix); |
| check_equal_nd(&zres, &expected, 16, "_mm512_cvtepu16_epi64", __LINE__); |
| |
| /* Masked. */ |
| |
| soft_update(i16_mix); |
| zres.zmmi = _mm512_setzero_epi32(); |
| yres = zres; |
| xres = zres; |
| zres.zmmi = _mm512_mask_cvtepu16_epi64(zres.zmmi, k8, i16_mix.xmmi[0]); |
| expected = expected_save; |
| for (i = 0; i < 8; i++) { |
| if ((k8 & (1 << i)) == 0) { |
| expected.u64[i] = 0; |
| } |
| } |
| soft_update(i16_mix); |
| check_equal_nd(&zres, &expected, 16, "_mm512_mask_cvtepu16_epi64", __LINE__); |
| |
| /* Zero-masked. */ |
| |
| zres = i8_mix; |
| yres = zres; |
| xres = zres; |
| soft_update(i16_mix); |
| zres.zmmi = _mm512_maskz_cvtepu16_epi64(k8, i16_mix.xmmi[0]); |
| for (i = 0; i < 8; i++) { |
| if ((k8 & (1 << i)) == 0) { |
| expected.u64[i] = 0; |
| } |
| } |
| soft_update(i16_mix); |
| soft_update(i16_mix); |
| check_equal_nd(&zres, &expected, 16, "_mm512_maskz_cvtepu16_epi64", __LINE__); |
| } |
| |
| void NOINLINE do_movzxdq() { |
| V512 xres, yres, zres; |
| V512 expected; |
| __mmask8 k8 = 0xeb; |
| |
| /* Non-masked. */ |
| |
| zres.zmmi = _mm512_cvtepu32_epi64(i32_mix.ymmi[0]); |
| expected.zmmi = _mm512_set_epi64(7, (unsigned int)-6, 5, (unsigned int)-4, 3, |
| (unsigned int)-2, 1, 0); |
| soft_update(i32_mix); |
| check_equal_nd(&zres, &expected, 16, "_mm512_cvtepu32_epi64", __LINE__); |
| |
| /* Masked. */ |
| |
| soft_update(i32_mix); |
| zres.zmmi = _mm512_setzero_epi32(); |
| yres = zres; |
| xres = zres; |
| zres.zmmi = _mm512_mask_cvtepu32_epi64(zres.zmmi, k8, i32_mix.ymmi[0]); |
| expected.zmmi = _mm512_set_epi64(0, -6, 0, -4, 3, -2, 0, 0); |
| expected.zmmi = _mm512_set_epi64(7, (unsigned int)-6, 5, 0, 3, 0, 1, 0); |
| soft_update(i32_mix); |
| check_equal_nd(&zres, &expected, 16, "_mm512_mask_cvtepu32_epi64", __LINE__); |
| |
| /* Zero-masked. */ |
| |
| k8 = 0xe7; |
| soft_update(i32_mix); |
| zres = i8_mix; |
| yres = zres; |
| xres = zres; |
| zres.zmmi = _mm512_maskz_cvtepu32_epi64(k8, i32_mix.ymmi[0]); |
| soft_update(i32_mix); |
| expected.zmmi = _mm512_set_epi64(7, (unsigned int)-6, 5, (unsigned int)-4, 3, |
| (unsigned int)-2, 1, 0); |
| expected.zmmi = _mm512_maskz_mov_epi64(k8, expected.zmmi); |
| check_equal_nd(&zres, &expected, 16, "_mm512_maskz_cvtepu32_epi64", __LINE__); |
| } |
| |
| void NOINLINE do_movzxbd() { |
| V512 xres, yres, zres; |
| V512 expected, expected_save; |
| volatile int i; |
| __mmask16 k16 = 0xfefe; |
| __mmask8 k8 = (__mmask8)k16; |
| |
| /* Non-masked. */ |
| |
| zres.zmmi = _mm512_cvtepu8_epi32(i8_mix.xmmi[0]); |
| for (i = 0; i < 16; i++) { |
| expected.u32[i] = i8_mix.u8[i]; |
| } |
| expected_save = expected; |
| check_equal_nd(&zres, &expected, 16, "_mm512_cvtepu8_epi32", __LINE__); |
| soft_update(i8_mix); |
| |
| /* Masked. */ |
| |
| soft_update(i8_mix); |
| zres.zmmi = _mm512_setzero_epi32(); |
| yres = zres; |
| xres = zres; |
| zres.zmmi = _mm512_mask_cvtepu8_epi32(zres.zmmi, k16, i8_mix.xmmi[0]); |
| expected = expected_save; |
| for (i = 0; i < 16; i++) { |
| if ((k16 & (1 << i)) == 0) { |
| expected.u32[i] = 0; |
| } |
| } |
| check_equal_nd(&zres, &expected, 16, "_mm512_mask_cvtepu8_epi32", __LINE__); |
| soft_update(i8_mix); |
| |
| /* Zero-masked. */ |
| |
| soft_update(i8_mix); |
| k16 <<= 1; |
| k8 = (__mmask8)k16; |
| zres.zmmi = _mm512_maskz_cvtepu8_epi32(k16, i8_mix.xmmi[0]); |
| expected = expected_save; |
| for (i = 0; i < 16; i++) { |
| if ((k16 & (1 << i)) == 0) { |
| expected.u32[i] = 0; |
| } |
| } |
| check_equal_nd(&zres, &expected, 16, "_mm512_maskz_cvtepu8_epi32", __LINE__); |
| soft_update(i8_mix); |
| } |
| |
| void NOINLINE do_movzxbq() { |
| V512 xres, yres, zres; |
| V512 expected, expected_save; |
| volatile int i; |
| __mmask8 k8 = 0xfe; |
| |
| /* Non-masked. */ |
| |
| zres.zmmi = _mm512_cvtepu8_epi64(i8_mix.xmmi[0]); |
| for (i = 0; i < 8; i++) { |
| expected.u64[i] = i8_mix.u8[i]; |
| } |
| expected_save = expected; |
| check_equal_nd(&zres, &expected, 16, "_mm512_cvtepu8_epi64", __LINE__); |
| soft_update(i8_mix); |
| |
| /* Masked. */ |
| |
| soft_update(i8_mix); |
| zres.zmmi = _mm512_setzero_epi32(); |
| yres = zres; |
| xres = zres; |
| zres.zmmi = _mm512_mask_cvtepu8_epi64(zres.zmmi, k8, i8_mix.xmmi[0]); |
| expected = expected_save; |
| for (i = 0; i < 8; i++) { |
| if ((k8 & (1 << i)) == 0) { |
| expected.u64[i] = 0; |
| } |
| } |
| check_equal_nd(&zres, &expected, 16, "_mm512_mask_cvtepu8_epi64", __LINE__); |
| soft_update(i8_mix); |
| |
| /* Zero-masked. */ |
| |
| soft_update(i8_mix); |
| k8 <<= 1; |
| zres.zmmi = _mm512_maskz_cvtepu8_epi64(k8, i8_mix.xmmi[0]); |
| expected = expected_save; |
| for (i = 0; i < 8; i++) { |
| if ((k8 & (1 << i)) == 0) { |
| expected.u64[i] = 0; |
| } |
| } |
| check_equal_nd(&zres, &expected, 16, "_mm512_maskz_cvtepu8_epi64", __LINE__); |
| soft_update(i8_mix); |
| } |
| |
| void NOINLINE do_maxsd() { |
| V512 res; |
| V512 expected; |
| __mmask8 k = 0x5d; |
| |
| res.zmmi = _mm512_max_epi32(i32.zmmi, i32_mix.zmmi); |
| check_equal_nd(&res, &i32, 16, "_mm512_max_epi32", __LINE__); |
| |
| res.zmmi = _mm512_setzero_epi32(); |
| res.zmmi = _mm512_mask_max_epi32(res.zmmi, k, i32.zmmi, i32_mix.zmmi); |
| expected.zmm = _mm512_mask_mov_ps(_mm512_setzero_ps(), k, i32.zmm); |
| check_equal_nd(&res, &expected, 16, "_mm512_mask_max_epi32", __LINE__); |
| } |
| |
| void NOINLINE do_maxud() { |
| V512 res; |
| V512 expected; |
| __mmask16 k = 0x5d; |
| |
| res.zmmi = _mm512_max_epu32(i32.zmmi, i32_mix.zmmi); |
| check_equal_nd(&res, &i32_mix, 16, "_mm512_max_epu32", __LINE__); |
| |
| res.zmmi = _mm512_setzero_epi32(); |
| res.zmmi = _mm512_mask_max_epu32(res.zmmi, k, i32.zmmi, i32_mix.zmmi); |
| expected.zmm = _mm512_mask_mov_ps(_mm512_setzero_ps(), k, i32_mix.zmm); |
| check_equal_nd(&res, &expected, 16, "_mm512_mask_max_epu32", __LINE__); |
| } |
| |
| void NOINLINE do_minsd() { |
| V512 res; |
| V512 expected; |
| __mmask8 k = 0x5d; |
| |
| res.zmmi = _mm512_min_epi32(i32.zmmi, i32_mix.zmmi); |
| check_equal_nd(&res, &i32_mix, 16, "_mm512_min_epi32", __LINE__); |
| |
| res.zmmi = _mm512_setzero_epi32(); |
| res.zmmi = _mm512_mask_min_epi32(res.zmmi, k, i32.zmmi, i32_mix.zmmi); |
| expected.zmm = _mm512_mask_mov_ps(_mm512_setzero_ps(), k, i32_mix.zmm); |
| check_equal_nd(&res, &expected, 16, "_mm512_mask_min_epi32", __LINE__); |
| } |
| |
| void NOINLINE do_minud() { |
| V512 res; |
| V512 expected; |
| __mmask16 k = 0x5d; |
| |
| res.zmmi = _mm512_min_epu32(i32.zmmi, i32_mix.zmmi); |
| check_equal_nd(&res, &i32, 16, "_mm512_min_epu32", __LINE__); |
| |
| res.zmmi = _mm512_setzero_epi32(); |
| res.zmmi = _mm512_mask_min_epu32(res.zmmi, k, i32.zmmi, i32_mix.zmmi); |
| expected.zmm = _mm512_mask_mov_ps(_mm512_setzero_ps(), k, i32.zmm); |
| check_equal_nd(&res, &expected, 16, "_mm512_mask_min_epu32", __LINE__); |
| } |
| |
| void NOINLINE do_pslld() { |
| V512 res; |
| V512 vcount; |
| V512 expected; |
| volatile int i; |
| int count = 7; |
| __mmask16 k; |
| __mmask8 k8; |
| |
| i = 0; |
| vcount.zmm = _mm512_setzero_ps(); |
| vcount.u64[i] = count; |
| |
| res.zmmi = _mm512_sll_epi32(i32_big.zmmi, vcount.xmmi[0]); |
| for (i = 0; i < 16; i++) { |
| expected.u32[i] = (count > 31) ? 0 : (i32_big.u32[i] << count); |
| } |
| check_equal_nd(&res, &expected, 16, "_mm512_sll_epi32", __LINE__); |
| |
| soft_update(vcount); |
| res.ymmi[0] = _mm256_sll_epi32(i32_big.ymmi[0], vcount.xmmi[0]); |
| check_equal_nd(&res, &expected, 8, "_mm256_sll_epi32", __LINE__); |
| |
| soft_update(vcount); |
| res.xmmi[0] = _mm_sll_epi32(i32_big.xmmi[0], vcount.xmmi[0]); |
| check_equal_nd(&res, &expected, 4, "_mm_sll_epi32", __LINE__); |
| |
| k = 0x7fdb; |
| k8 = (__mmask8)k; |
| res.zmmi = _mm512_setzero_epi32(); |
| res.zmmi = _mm512_mask_sll_epi32(res.zmmi, k, i32_mix.zmmi, vcount.xmmi[0]); |
| for (i = 0; i < 16; i++) { |
| expected.u32[i] = 0; |
| if ((k & (1 << i)) != 0) { |
| expected.u32[i] = (count > 31) ? 0 : (i32_mix.u32[i] << count); |
| } |
| } |
| check_equal_nd(&res, &expected, 16, "_mm512_mask_sll_epi32", __LINE__); |
| |
| soft_update(vcount); |
| res.ymmi[0] = _mm256_setzero_si256(); |
| |
| soft_update(vcount); |
| res.xmmi[0] = _mm_setzero_si128(); |
| |
| res = i8_mix; |
| res.zmmi = _mm512_maskz_sll_epi32(k, i32_mix.zmmi, vcount.xmmi[0]); |
| check_equal_nd(&res, &expected, 16, "_mm512_maskz_sll_epi32", __LINE__); |
| |
| soft_update(vcount); |
| res = i8_mix; |
| |
| soft_update(vcount); |
| res = i8_mix; |
| } |
| |
| void NOINLINE do_psllq() { |
| V512 res; |
| V512 vcount; |
| V512 expected; |
| volatile int i; |
| int count = 7; |
| __mmask8 k; |
| |
| i = 0; |
| vcount.zmm = _mm512_setzero_ps(); |
| vcount.u64[i] = count; |
| |
| res.zmmi = _mm512_sll_epi64(i64_big.zmmi, vcount.xmmi[0]); |
| for (i = 0; i < 8; i++) { |
| expected.u64[i] = (count > 63) ? 0 : (i64_big.u64[i] << count); |
| } |
| check_equal_nd(&res, &expected, 16, "_mm512_sll_epi64", __LINE__); |
| |
| soft_update(vcount); |
| res.ymmi[0] = _mm256_sll_epi64(i64_big.ymmi[0], vcount.xmmi[0]); |
| check_equal_nd(&res, &expected, 8, "_mm256_sll_epi64", __LINE__); |
| |
| soft_update(vcount); |
| res.xmmi[0] = _mm_sll_epi64(i64_big.xmmi[0], vcount.xmmi[0]); |
| check_equal_nd(&res, &expected, 4, "_mm_sll_epi64", __LINE__); |
| |
| k = 0xc3; |
| res.zmmi = _mm512_setzero_epi32(); |
| res.zmmi = _mm512_mask_sll_epi64(res.zmmi, k, i64_mix.zmmi, vcount.xmmi[0]); |
| for (i = 0; i < 8; i++) { |
| expected.u64[i] = 0; |
| if ((k & (1 << i)) != 0) { |
| expected.u64[i] = (count > 63) ? 0 : (i64_mix.u64[i] << count); |
| } |
| } |
| check_equal_nd(&res, &expected, 16, "_mm512_mask_sll_epi64", __LINE__); |
| |
| soft_update(vcount); |
| res.ymmi[0] = _mm256_setzero_si256(); |
| |
| soft_update(vcount); |
| res.xmmi[0] = _mm_setzero_si128(); |
| |
| res = i8_mix; |
| res.zmmi = _mm512_maskz_sll_epi64(k, i64_mix.zmmi, vcount.xmmi[0]); |
| check_equal_nd(&res, &expected, 16, "_mm512_maskz_sll_epi64", __LINE__); |
| |
| soft_update(vcount); |
| res = i8_mix; |
| |
| soft_update(vcount); |
| res = i8_mix; |
| } |
| |
| void NOINLINE do_pslldi(int cnt) { |
| V512 res; |
| V512 expected; |
| __mmask16 k; |
| volatile int i; |
| |
| res.zmmi = _mm512_slli_epi32(i32_big.zmmi, 3); |
| for (i = 0; i < 16; i++) { |
| expected.u32[i] = i32_big.u32[i] << 3; |
| } |
| check_equal_nd(&res, &expected, 16, "_mm512_slli_epi32", __LINE__); |
| |
| k = 0x9786; |
| res.zmmi = _mm512_setzero_epi32(); |
| res.zmmi = _mm512_mask_slli_epi32(res.zmmi, k, i32_mix.zmmi, 6); |
| for (i = 0; i < 16; i++) { |
| expected.u32[i] = 0; |
| if ((k & (1 << i)) != 0) { |
| expected.u32[i] = (i32_mix.u32[i] << 6); |
| } |
| } |
| check_equal_nd(&res, &expected, 16, "_mm512_mask_slli_epi32", __LINE__); |
| |
| res.zmmi = _mm512_slli_epi32(i32_big.zmmi, cnt); |
| for (i = 0; i < 16; i++) { |
| expected.u32[i] = i32_big.u32[i] << cnt; |
| } |
| check_equal_nd(&res, &expected, 16, "_mm512_slli_epi32", __LINE__); |
| |
| k = 0x9786; |
| res.zmmi = _mm512_setzero_epi32(); |
| res.zmmi = _mm512_mask_slli_epi32(res.zmmi, k, i32_mix.zmmi, cnt); |
| for (i = 0; i < 16; i++) { |
| expected.u32[i] = 0; |
| if ((k & (1 << i)) != 0) { |
| expected.u32[i] = (i32_mix.u32[i] << cnt); |
| } |
| } |
| check_equal_nd(&res, &expected, 16, "_mm512_mask_slli_epi32", __LINE__); |
| } |
| |
| void NOINLINE do_psllqi(int cnt) { |
| V512 res; |
| V512 expected; |
| __mmask8 k; |
| volatile int i; |
| |
| res.zmmi = _mm512_slli_epi64(i64_big.zmmi, 3); |
| for (i = 0; i < 8; i++) { |
| expected.u64[i] = i64_big.u64[i] << 3; |
| } |
| check_equal_nd(&res, &expected, 16, "_mm512_slli_epi64", __LINE__); |
| |
| k = 0x97; |
| res.zmmi = _mm512_setzero_epi32(); |
| res.zmmi = _mm512_mask_slli_epi64(res.zmmi, k, i64_mix.zmmi, 6); |
| for (i = 0; i < 8; i++) { |
| expected.u64[i] = 0; |
| if ((k & (1 << i)) != 0) { |
| expected.u64[i] = (i64_mix.u64[i] << 6); |
| } |
| } |
| check_equal_nd(&res, &expected, 16, "_mm512_mask_slli_epi64", __LINE__); |
| |
| res.zmmi = _mm512_slli_epi64(i64_big.zmmi, cnt); |
| for (i = 0; i < 8; i++) { |
| expected.u64[i] = i64_big.u64[i] << cnt; |
| } |
| check_equal_nd(&res, &expected, 16, "_mm512_slli_epi64", __LINE__); |
| |
| k = 0x97; |
| res.zmmi = _mm512_setzero_epi32(); |
| res.zmmi = _mm512_mask_slli_epi64(res.zmmi, k, i64_mix.zmmi, cnt); |
| for (i = 0; i < 8; i++) { |
| expected.u64[i] = 0; |
| if ((k & (1 << i)) != 0) { |
| expected.u64[i] = (i64_mix.u64[i] << cnt); |
| } |
| } |
| check_equal_nd(&res, &expected, 16, "_mm512_mask_slli_epi64", __LINE__); |
| } |
| |
| void NOINLINE do_psradi(int cnt) { |
| V512 res; |
| V512 expected; |
| __mmask16 k; |
| volatile int i; |
| |
| res.zmmi = _mm512_srai_epi32(i32_big.zmmi, 3); |
| for (i = 0; i < 16; i++) { |
| expected.s32[i] = i32_big.s32[i] >> 3; |
| } |
| check_equal_nd(&res, &expected, 16, "_mm512_srai_epi32", __LINE__); |
| |
| k = 0x9786; |
| res.zmmi = _mm512_setzero_epi32(); |
| res.zmmi = _mm512_mask_srai_epi32(res.zmmi, k, i32_mix.zmmi, 6); |
| for (i = 0; i < 16; i++) { |
| expected.s32[i] = 0; |
| if ((k & (1 << i)) != 0) { |
| expected.s32[i] = (i32_mix.s32[i] >> 6); |
| } |
| } |
| check_equal_nd(&res, &expected, 16, "_mm512_mask_srai_epi32", __LINE__); |
| |
| res.zmmi = _mm512_srai_epi32(i32_big.zmmi, cnt); |
| for (i = 0; i < 16; i++) { |
| expected.s32[i] = i32_big.s32[i] >> cnt; |
| } |
| check_equal_nd(&res, &expected, 16, "_mm512_srai_epi32", __LINE__); |
| |
| k = 0x9786; |
| res.zmmi = _mm512_setzero_epi32(); |
| res.zmmi = _mm512_mask_srai_epi32(res.zmmi, k, i32_mix.zmmi, cnt); |
| for (i = 0; i < 16; i++) { |
| expected.s32[i] = 0; |
| if ((k & (1 << i)) != 0) { |
| expected.s32[i] = (i32_mix.s32[i] >> cnt); |
| } |
| } |
| check_equal_nd(&res, &expected, 16, "_mm512_mask_srai_epi32", __LINE__); |
| } |
| |
| void NOINLINE do_psrldi(int cnt) { |
| V512 res; |
| V512 expected; |
| __mmask16 k; |
| volatile int i; |
| |
| res.zmmi = _mm512_srli_epi32(i32_big.zmmi, 3); |
| for (i = 0; i < 16; i++) { |
| expected.u32[i] = i32_big.u32[i] >> 3; |
| } |
| check_equal_nd(&res, &expected, 16, "_mm512_srli_epi32", __LINE__); |
| |
| k = 0x9786; |
| res.zmmi = _mm512_setzero_epi32(); |
| res.zmmi = _mm512_mask_srli_epi32(res.zmmi, k, i32_mix.zmmi, 6); |
| for (i = 0; i < 16; i++) { |
| expected.u32[i] = 0; |
| if ((k & (1 << i)) != 0) { |
| expected.u32[i] = (i32_mix.u32[i] >> 6); |
| } |
| } |
| check_equal_nd(&res, &expected, 16, "_mm512_mask_srli_epi32", __LINE__); |
| |
| res.zmmi = _mm512_srli_epi32(i32_big.zmmi, cnt); |
| for (i = 0; i < 16; i++) { |
| expected.u32[i] = i32_big.u32[i] >> cnt; |
| } |
| check_equal_nd(&res, &expected, 16, "_mm512_srli_epi32", __LINE__); |
| |
| k = 0x9786; |
| res.zmmi = _mm512_setzero_epi32(); |
| res.zmmi = _mm512_mask_srli_epi32(res.zmmi, k, i32_mix.zmmi, cnt); |
| for (i = 0; i < 16; i++) { |
| expected.u32[i] = 0; |
| if ((k & (1 << i)) != 0) { |
| expected.u32[i] = (i32_mix.u32[i] >> cnt); |
| } |
| } |
| check_equal_nd(&res, &expected, 16, "_mm512_mask_srli_epi32 #2", __LINE__); |
| } |
| |
| void NOINLINE do_psraqi(int cnt) { |
| V512 res; |
| V512 expected; |
| __mmask8 k; |
| volatile int i; |
| |
| res.zmmi = _mm512_srai_epi64(i64_big.zmmi, 3); |
| for (i = 0; i < 8; i++) { |
| expected.s64[i] = i64_big.s64[i] >> 3; |
| } |
| check_equal_nd(&res, &expected, 16, "_mm512_srai_epi64", __LINE__); |
| |
| k = 0x97; |
| res.zmmi = _mm512_setzero_epi32(); |
| res.zmmi = _mm512_mask_srai_epi64(res.zmmi, k, i64_mix.zmmi, 6); |
| for (i = 0; i < 8; i++) { |
| expected.u64[i] = 0; |
| if ((k & (1 << i)) != 0) { |
| expected.s64[i] = (i64_mix.s64[i] >> 6); |
| } |
| } |
| check_equal_nd(&res, &expected, 16, "_mm512_mask_srai_epi64", __LINE__); |
| |
| res.zmmi = _mm512_srai_epi64(i64_big.zmmi, cnt); |
| for (i = 0; i < 8; i++) { |
| expected.s64[i] = i64_big.s64[i] >> cnt; |
| } |
| check_equal_nd(&res, &expected, 16, "_mm512_srai_epi64", __LINE__); |
| |
| k = 0x97; |
| res.zmmi = _mm512_setzero_epi32(); |
| res.zmmi = _mm512_mask_srai_epi64(res.zmmi, k, i64_mix.zmmi, cnt); |
| for (i = 0; i < 8; i++) { |
| expected.u64[i] = 0; |
| if ((k & (1 << i)) != 0) { |
| expected.s64[i] = (i64_mix.s64[i] >> cnt); |
| } |
| } |
| check_equal_nd(&res, &expected, 16, "_mm512_mask_srai_epi64", __LINE__); |
| } |
| |
| void NOINLINE do_psrlqi(int cnt) { |
| V512 res; |
| V512 expected; |
| __mmask8 k; |
| volatile int i; |
| |
| res.zmmi = _mm512_srli_epi64(i64_big.zmmi, 3); |
| for (i = 0; i < 8; i++) { |
| expected.u64[i] = i64_big.u64[i] >> 3; |
| } |
| check_equal_nd(&res, &expected, 16, "_mm512_srli_epi64", __LINE__); |
| |
| k = 0x97; |
| res.zmmi = _mm512_setzero_epi32(); |
| res.zmmi = _mm512_mask_srli_epi64(res.zmmi, k, i64_mix.zmmi, 6); |
| for (i = 0; i < 8; i++) { |
| expected.u64[i] = 0; |
| if ((k & (1 << i)) != 0) { |
| expected.u64[i] = (i64_mix.u64[i] >> 6); |
| } |
| } |
| check_equal_nd(&res, &expected, 16, "_mm512_mask_srli_epi64", __LINE__); |
| |
| res.zmmi = _mm512_srli_epi64(i64_big.zmmi, cnt); |
| for (i = 0; i < 8; i++) { |
| expected.u64[i] = i64_big.u64[i] >> cnt; |
| } |
| check_equal_nd(&res, &expected, 16, "_mm512_srli_epi64", __LINE__); |
| |
| k = 0x97; |
| res.zmmi = _mm512_setzero_epi32(); |
| res.zmmi = _mm512_mask_srli_epi64(res.zmmi, k, i64_mix.zmmi, cnt); |
| for (i = 0; i < 8; i++) { |
| expected.u64[i] = 0; |
| if ((k & (1 << i)) != 0) { |
| expected.u64[i] = (i64_mix.u64[i] >> cnt); |
| } |
| } |
| check_equal_nd(&res, &expected, 16, "_mm512_mask_srli_epi64", __LINE__); |
| } |
| |
| void NOINLINE do_psrad() { |
| V512 res; |
| V512 vcount; |
| V512 expected; |
| volatile int i; |
| int count = 7; |
| __mmask16 k; |
| __mmask8 k8; |
| |
| i = 0; |
| vcount.zmm = _mm512_setzero_ps(); |
| vcount.u64[i] = count; |
| |
| res.zmmi = _mm512_sra_epi32(i32_big.zmmi, vcount.xmmi[0]); |
| for (i = 0; i < 16; i++) { |
| expected.s32[i] = (count > 31) ? 0 : (i32_big.s32[i] >> count); |
| } |
| check_equal_nd(&res, &expected, 16, "_mm512_sra_epi32", __LINE__); |
| |
| k = 0x7fdb; |
| k8 = (__mmask8)k; |
| res.zmmi = _mm512_setzero_epi32(); |
| res.zmmi = _mm512_mask_sra_epi32(res.zmmi, k, i32_mix.zmmi, vcount.xmmi[0]); |
| for (i = 0; i < 16; i++) { |
| expected.u32[i] = 0; |
| if ((k & (1 << i)) != 0) { |
| expected.s32[i] = (count > 31) ? 0 : (i32_mix.s32[i] >> count); |
| } |
| } |
| check_equal_nd(&res, &expected, 16, "_mm512_mask_sra_epi32", __LINE__); |
| |
| res = i8_mix; |
| res.zmmi = _mm512_maskz_sra_epi32(k, i32_mix.zmmi, vcount.xmmi[0]); |
| check_equal_nd(&res, &expected, 16, "_mm512_maskz_sra_epi32", __LINE__); |
| } |
| |
| void NOINLINE do_psrld() { |
| V512 res; |
| V512 vcount; |
| V512 expected; |
| volatile int i; |
| int count = 7; |
| __mmask16 k; |
| __mmask8 k8; |
| |
| i = 0; |
| vcount.zmm = _mm512_setzero_ps(); |
| vcount.u64[i] = count; |
| |
| res.zmmi = _mm512_srl_epi32(i32_big.zmmi, vcount.xmmi[0]); |
| for (i = 0; i < 16; i++) { |
| expected.u32[i] = (count > 31) ? 0 : (i32_big.u32[i] >> count); |
| } |
| check_equal_nd(&res, &expected, 16, "_mm512_srl_epi32", __LINE__); |
| |
| k = 0x7fdb; |
| k8 = (__mmask8)k; |
| res.zmmi = _mm512_setzero_epi32(); |
| res.zmmi = _mm512_mask_srl_epi32(res.zmmi, k, i32_mix.zmmi, vcount.xmmi[0]); |
| for (i = 0; i < 16; i++) { |
| expected.u32[i] = 0; |
| if ((k & (1 << i)) != 0) { |
| expected.u32[i] = (count > 31) ? 0 : (i32_mix.u32[i] >> count); |
| } |
| } |
| check_equal_nd(&res, &expected, 16, "_mm512_mask_srl_epi32", __LINE__); |
| |
| res = i8_mix; |
| res.zmmi = _mm512_maskz_srl_epi32(k, i32_mix.zmmi, vcount.xmmi[0]); |
| check_equal_nd(&res, &expected, 16, "_mm512_maskz_srl_epi32", __LINE__); |
| } |
| |
| void NOINLINE do_psraq() { |
| V512 res; |
| V512 vcount; |
| V512 expected; |
| volatile int i; |
| int count = 7; |
| __mmask8 k; |
| |
| i = 0; |
| vcount.zmm = _mm512_setzero_ps(); |
| vcount.u64[i] = count; |
| |
| res.zmmi = _mm512_sra_epi64(i64_big.zmmi, vcount.xmmi[0]); |
| for (i = 0; i < 8; i++) { |
| expected.s64[i] = (count > 63) ? 0 : (i64_big.s64[i] >> count); |
| } |
| check_equal_nd(&res, &expected, 16, "_mm512_sra_epi64", __LINE__); |
| |
| k = 0xc3; |
| res.zmmi = _mm512_setzero_epi32(); |
| res.zmmi = _mm512_mask_sra_epi64(res.zmmi, k, i64_mix.zmmi, vcount.xmmi[0]); |
| for (i = 0; i < 8; i++) { |
| expected.s64[i] = 0; |
| if ((k & (1 << i)) != 0) { |
| expected.s64[i] = (count > 63) ? 0 : (i64_mix.s64[i] >> count); |
| } |
| } |
| check_equal_nd(&res, &expected, 16, "_mm512_mask_sra_epi64", __LINE__); |
| |
| res = i8_mix; |
| res.zmmi = _mm512_maskz_sra_epi64(k, i64_mix.zmmi, vcount.xmmi[0]); |
| check_equal_nd(&res, &expected, 16, "_mm512_maskz_sra_epi64", __LINE__); |
| } |
| |
| void NOINLINE do_psrlq() { |
| V512 res; |
| V512 vcount; |
| V512 expected; |
| volatile int i; |
| int count = 7; |
| __mmask8 k; |
| |
| i = 0; |
| vcount.zmm = _mm512_setzero_ps(); |
| vcount.u64[i] = count; |
| |
| res.zmmi = _mm512_srl_epi64(i64_big.zmmi, vcount.xmmi[0]); |
| for (i = 0; i < 8; i++) { |
| expected.u64[i] = (count > 63) ? 0 : (i64_big.u64[i] >> count); |
| } |
| check_equal_nd(&res, &expected, 16, "_mm512_srl_epi64", __LINE__); |
| |
| k = 0xc3; |
| res.zmmi = _mm512_setzero_epi32(); |
| res.zmmi = _mm512_mask_srl_epi64(res.zmmi, k, i64_mix.zmmi, vcount.xmmi[0]); |
| for (i = 0; i < 8; i++) { |
| expected.u64[i] = 0; |
| if ((k & (1 << i)) != 0) { |
| expected.u64[i] = (count > 63) ? 0 : (i64_mix.u64[i] >> count); |
| } |
| } |
| check_equal_nd(&res, &expected, 16, "_mm512_mask_srl_epi64", __LINE__); |
| |
| res.zmmi = _mm512_maskz_srl_epi64(k, i64_mix.zmmi, vcount.xmmi[0]); |
| check_equal_nd(&res, &expected, 16, "_mm512_maskz_srl_epi64", __LINE__); |
| |
| soft_update(vcount); |
| res = i8_mix; |
| } |
| |
| void NOINLINE do_movsxwd() { |
| V512 xres, yres, zres; |
| V512 expected; |
| __mmask16 k16 = 0x7e5d; |
| __mmask8 k8 = (__mmask8)k16; |
| ; |
| |
| /* Non-masked. */ |
| |
| zres.zmmi = _mm512_cvtepi16_epi32(i16_mix.ymmi[0]); |
| expected.zmmi = _mm512_set_epi32(15, -14, 13, -12, 11, -10, 9, -8, 7, -6, 5, |
| -4, 3, -2, 1, 0); |
| check_equal_nd(&zres, &expected, 16, "_mm512_cvtepi16_epi32", __LINE__); |
| |
| /* Masked. */ |
| |
| soft_update(i16_mix); |
| zres.zmmi = _mm512_setzero_epi32(); |
| yres = zres; |
| xres = zres; |
| zres.zmmi = _mm512_mask_cvtepi16_epi32(zres.zmmi, k16, i16_mix.ymmi[0]); |
| expected.zmmi = _mm512_set_epi32(0, -14, 13, -12, 11, -10, 9, 0, 0, -6, 0, -4, |
| 3, -2, 0, 0); |
| check_equal_nd(&zres, &expected, 16, "_mm512_mask_cvtepi16_epi32", __LINE__); |
| |
| /* Zero-masked. */ |
| |
| zres = i8_mix; |
| yres = zres; |
| xres = zres; |
| soft_update(i16_mix); |
| zres.zmmi = _mm512_maskz_cvtepi16_epi32(k16, i16_mix.ymmi[0]); |
| expected.zmmi = _mm512_set_epi32(15, -14, 13, -12, 11, -10, 9, -8, 7, -6, 5, |
| -4, 3, -2, 1, 0); |
| expected.zmmi = _mm512_maskz_mov_epi32(k16, expected.zmmi); |
| check_equal_nd(&zres, &expected, 16, "_mm512_maskz_cvtepi16_epi32", __LINE__); |
| } |
| |
| int main(int argc, char *argv[]) { |
| int cnt; |
| |
| init(); |
| |
| do_absd(); |
| do_absq(); |
| |
| do_movsxwd(); |
| do_movsxdq(); |
| do_movsxbd(); |
| do_movsxbq(); |
| do_movzxwd(); |
| do_movzxwq(); |
| |
| do_movzxbd(); |
| do_movzxbq(); |
| |
| do_maxsd(); |
| do_maxud(); |
| do_minsd(); |
| do_minud(); |
| |
| do_pslld(); |
| do_psllq(); |
| |
| for (cnt = 0; cnt <= 8; cnt++) { |
| do_pslldi(cnt); |
| do_psradi(cnt); |
| do_psrldi(cnt); |
| |
| do_psllqi(cnt); |
| do_psraqi(cnt); |
| do_psrlqi(cnt); |
| } |
| |
| do_psrlq(); |
| do_psraq(); |
| do_psrld(); |
| do_psrad(); |
| |
| if (n_errs != 0) { |
| printf("FAILED\n"); |
| return 1; |
| } |
| |
| printf("PASSED\n"); |
| return 0; |
| } |
