1 #include <arm_neon.h>
2 #include "arm-neon-ref.h"
3 #include "compute-ref-data.h"
4
5 /* Expected results with signed input. */
6 VECT_VAR_DECL(expected_signed,uint,8,8) [] = { 0x0, 0xff, 0xff, 0xff,
7 0xff, 0xff, 0xff, 0xff };
8 VECT_VAR_DECL(expected_signed,uint,16,4) [] = { 0x0, 0xffff, 0x0, 0xffff };
9 VECT_VAR_DECL(expected_signed,uint,32,2) [] = { 0x0, 0xffffffff };
10 VECT_VAR_DECL(expected_signed,uint,8,16) [] = { 0x0, 0xff, 0xff, 0xff,
11 0xff, 0xff, 0xff, 0xff,
12 0xff, 0xff, 0xff, 0xff,
13 0xff, 0xff, 0xff, 0xff };
14 VECT_VAR_DECL(expected_signed,uint,16,8) [] = { 0x0, 0xffff, 0x0, 0xffff,
15 0xffff, 0xffff, 0xffff, 0xffff };
16 VECT_VAR_DECL(expected_signed,uint,32,4) [] = { 0x0, 0xffffffff,
17 0x0, 0xffffffff };
18
19 /* Expected results with unsigned input. */
20 VECT_VAR_DECL(expected_unsigned,uint,8,8) [] = { 0x0, 0xff, 0xff, 0xff,
21 0xff, 0xff, 0xff, 0xff };
22 VECT_VAR_DECL(expected_unsigned,uint,16,4) [] = { 0x0, 0xffff, 0x0, 0xffff };
23 VECT_VAR_DECL(expected_unsigned,uint,32,2) [] = { 0x0, 0xffffffff };
24 VECT_VAR_DECL(expected_unsigned,uint,8,16) [] = { 0x0, 0xff, 0xff, 0xff,
25 0xff, 0xff, 0xff, 0xff,
26 0xff, 0xff, 0xff, 0xff,
27 0xff, 0xff, 0xff, 0xff };
28 VECT_VAR_DECL(expected_unsigned,uint,16,8) [] = { 0x0, 0xffff,
29 0x0, 0xffff,
30 0xffff, 0xffff,
31 0xffff, 0xffff };
32 VECT_VAR_DECL(expected_unsigned,uint,32,4) [] = { 0x0, 0xffffffff,
33 0x0, 0xffffffff };
34
35 /* Expected results with poly input. */
36 VECT_VAR_DECL(expected_poly,uint,8,8) [] = { 0x0, 0xff, 0xff, 0xff,
37 0xff, 0xff, 0xff, 0xff };
38 VECT_VAR_DECL(expected_poly,uint,8,16) [] = { 0x0, 0xff, 0xff, 0xff,
39 0xff, 0xff, 0xff, 0xff,
40 0xff, 0xff, 0xff, 0xff,
41 0xff, 0xff, 0xff, 0xff };
42 VECT_VAR_DECL(expected_poly,uint,16,4) [] = { 0x0, 0xffff, 0x0, 0xffff };
43 VECT_VAR_DECL(expected_poly,uint,16,8) [] = { 0x0, 0xffff,
44 0x0, 0xffff,
45 0xffff, 0xffff,
46 0xffff, 0xffff };
47
48 #define INSN_NAME vtst
49 #define TEST_MSG "VTST/VTSTQ"
50
51 /* We can't use the standard ref_v_binary_op.c template because vtst
52 has no 64 bits variant, and outputs are always of uint type. */
53 #define FNNAME1(NAME) void exec_ ## NAME (void)
54 #define FNNAME(NAME) FNNAME1(NAME)
55
56 FNNAME (INSN_NAME)
57 {
58 /* Basic test: y=OP(x,x), then store the result. */
59 #define TEST_BINARY_OP1(INSN, Q, T1, T2, W, N) \
60 VECT_VAR(vector_res, uint, W, N) = \
61 INSN##Q##_##T2##W(VECT_VAR(vector, T1, W, N), \
62 VECT_VAR(vector2, T1, W, N)); \
63 vst1##Q##_u##W(VECT_VAR(result, uint, W, N), \
64 VECT_VAR(vector_res, uint, W, N))
65
66 #define TEST_BINARY_OP(INSN, Q, T1, T2, W, N) \
67 TEST_BINARY_OP1(INSN, Q, T1, T2, W, N) \
68
69 DECL_VARIABLE_ALL_VARIANTS(vector);
70 DECL_VARIABLE_ALL_VARIANTS(vector2);
71 DECL_VARIABLE_UNSIGNED_VARIANTS(vector_res);
72
73
74 clean_results ();
75
76 /* Initialize input "vector" from "buffer". */
77 TEST_MACRO_ALL_VARIANTS_2_5(VLOAD, vector, buffer);
78
79 /* Choose init value arbitrarily, will be used as comparison
80 value. */
81 VDUP(vector2, , int, s, 8, 8, 15);
82 VDUP(vector2, , int, s, 16, 4, 5);
83 VDUP(vector2, , int, s, 32, 2, 1);
84 VDUP(vector2, , uint, u, 8, 8, 15);
85 VDUP(vector2, , uint, u, 16, 4, 5);
86 VDUP(vector2, , uint, u, 32, 2, 1);
87 VDUP(vector2, , poly, p, 8, 8, 15);
88 VDUP(vector2, , poly, p, 16, 4, 5);
89 VDUP(vector2, q, int, s, 8, 16, 15);
90 VDUP(vector2, q, int, s, 16, 8, 5);
91 VDUP(vector2, q, int, s, 32, 4, 1);
92 VDUP(vector2, q, uint, u, 8, 16, 15);
93 VDUP(vector2, q, uint, u, 16, 8, 5);
94 VDUP(vector2, q, uint, u, 32, 4, 1);
95 VDUP(vector2, q, poly, p, 8, 16, 15);
96 VDUP(vector2, q, poly, p, 16, 8, 5);
97
98 #define TEST_MACRO_NO64BIT_VARIANT_1_5(MACRO, VAR, T1, T2) \
99 MACRO(VAR, , T1, T2, 8, 8); \
100 MACRO(VAR, , T1, T2, 16, 4); \
101 MACRO(VAR, , T1, T2, 32, 2); \
102 MACRO(VAR, q, T1, T2, 8, 16); \
103 MACRO(VAR, q, T1, T2, 16, 8); \
104 MACRO(VAR, q, T1, T2, 32, 4)
105
106 /* Split the test, as both signed and unsigned variants output their
107 result in an unsigned form (thus the same output variable is used
108 in these tests). */
109 TEST_MACRO_NO64BIT_VARIANT_1_5(TEST_BINARY_OP, INSN_NAME, int, s);
110
111 #define CMT " (signed input)"
112 CHECK(TEST_MSG, uint, 8, 8, PRIx8, expected_signed, CMT);
113 CHECK(TEST_MSG, uint, 16, 4, PRIx16, expected_signed, CMT);
114 CHECK(TEST_MSG, uint, 32, 2, PRIx32, expected_signed, CMT);
115 CHECK(TEST_MSG, uint, 8, 16, PRIx8, expected_signed, CMT);
116 CHECK(TEST_MSG, uint, 16, 8, PRIx16, expected_signed, CMT);
117 CHECK(TEST_MSG, uint, 32, 4, PRIx32, expected_signed, CMT);
118
119 TEST_MACRO_NO64BIT_VARIANT_1_5(TEST_BINARY_OP, INSN_NAME, uint, u);
120
121 #undef CMT
122 #define CMT " (unsigned input)"
123 CHECK(TEST_MSG, uint, 8, 8, PRIx8, expected_unsigned, CMT);
124 CHECK(TEST_MSG, uint, 16, 4, PRIx16, expected_unsigned, CMT);
125 CHECK(TEST_MSG, uint, 32, 2, PRIx32, expected_unsigned, CMT);
126 CHECK(TEST_MSG, uint, 8, 16, PRIx8, expected_unsigned, CMT);
127 CHECK(TEST_MSG, uint, 16, 8, PRIx16, expected_unsigned, CMT);
128 CHECK(TEST_MSG, uint, 32, 4, PRIx32, expected_unsigned, CMT);
129
130 /* Now, test the variants with poly8 and poly16 as input. */
131 #undef CMT
132 #define CMT " (poly input)"
133 TEST_BINARY_OP(INSN_NAME, , poly, p, 8, 8);
134 TEST_BINARY_OP(INSN_NAME, , poly, p, 16, 4);
135 TEST_BINARY_OP(INSN_NAME, q, poly, p, 8, 16);
136 TEST_BINARY_OP(INSN_NAME, q, poly, p, 16, 8);
137 CHECK(TEST_MSG, uint, 8, 8, PRIx8, expected_poly, CMT);
138 CHECK(TEST_MSG, uint, 16, 4, PRIx16, expected_poly, CMT);
139 CHECK(TEST_MSG, uint, 8, 16, PRIx8, expected_poly, CMT);
140 CHECK(TEST_MSG, uint, 16, 8, PRIx16, expected_poly, CMT);
141 }
142
143 int main (void)
144 {
145 exec_vtst ();
146 return 0;
147 }