Debian Codegraph @

gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/binary_op_no64.inc

raw
1 /* Can't use the standard binary_op.inc template because vmax has no
2 64 bits variant. */
3
4 #include <math.h>
5
6 #define FNNAME1(NAME) exec_ ## NAME
7 #define FNNAME(NAME) FNNAME1(NAME)
8
9 void FNNAME (INSN_NAME) (void)
10 {
11 int i;
12
13 /* Basic test: y=vmax(x,x), then store the result. */
14 #define TEST_BINARY_OP1(INSN, Q, T1, T2, W, N) \
15 VECT_VAR(vector_res, T1, W, N) = \
16 INSN##Q##_##T2##W(VECT_VAR(vector, T1, W, N), \
17 VECT_VAR(vector2, T1, W, N)); \
18 vst1##Q##_##T2##W(VECT_VAR(result, T1, W, N), VECT_VAR(vector_res, T1, W, N))
19
20 #define TEST_BINARY_OP(INSN, Q, T1, T2, W, N) \
21 TEST_BINARY_OP1(INSN, Q, T1, T2, W, N) \
22
23 DECL_VARIABLE_ALL_VARIANTS(vector);
24 DECL_VARIABLE_ALL_VARIANTS(vector2);
25 DECL_VARIABLE_ALL_VARIANTS(vector_res);
26
27 clean_results ();
28
29 /* Initialize input "vector" from "buffer". */
30 TEST_MACRO_ALL_VARIANTS_2_5(VLOAD, vector, buffer);
31 #ifdef HAS_FLOAT16_VARIANT
32 VLOAD(vector, buffer, , float, f, 16, 4);
33 VLOAD(vector, buffer, q, float, f, 16, 8);
34 #endif
35 #ifdef HAS_FLOAT_VARIANT
36 VLOAD(vector, buffer, , float, f, 32, 2);
37 VLOAD(vector, buffer, q, float, f, 32, 4);
38 #endif
39
40 /* Choose init value arbitrarily, will be used as comparison value. */
41 VDUP(vector2, , int, s, 8, 8, -13);
42 VDUP(vector2, , int, s, 16, 4, -14);
43 VDUP(vector2, , int, s, 32, 2, -16);
44 VDUP(vector2, , uint, u, 8, 8, 0xf3);
45 VDUP(vector2, , uint, u, 16, 4, 0xfff1);
46 VDUP(vector2, , uint, u, 32, 2, 0xfffffff0);
47 VDUP(vector2, q, int, s, 8, 16, -12);
48 VDUP(vector2, q, int, s, 16, 8, -13);
49 VDUP(vector2, q, int, s, 32, 4, -15);
50 VDUP(vector2, q, uint, u, 8, 16, 0xf9);
51 VDUP(vector2, q, uint, u, 16, 8, 0xfff2);
52 VDUP(vector2, q, uint, u, 32, 4, 0xfffffff1);
53 #ifdef HAS_FLOAT16_VARIANT
54 VDUP(vector2, , float, f, 16, 4, -15.5f);
55 VDUP(vector2, q, float, f, 16, 8, -14.5f);
56 #endif
57 #ifdef HAS_FLOAT_VARIANT
58 VDUP(vector2, , float, f, 32, 2, -15.5f);
59 VDUP(vector2, q, float, f, 32, 4, -14.5f);
60 #endif
61
62 #ifdef HAS_FLOAT16_VARIANT
63 #define FLOAT16_VARIANT(MACRO, VAR) \
64 MACRO(VAR, , float, f, 16, 4); \
65 MACRO(VAR, q, float, f, 16, 8);
66 #else
67 #define FLOAT16_VARIANT(MACRO, VAR)
68 #endif
69
70 #ifdef HAS_FLOAT_VARIANT
71 #define FLOAT_VARIANT(MACRO, VAR) \
72 MACRO(VAR, , float, f, 32, 2); \
73 MACRO(VAR, q, float, f, 32, 4);
74 #else
75 #define FLOAT_VARIANT(MACRO, VAR)
76 #endif
77
78 #define TEST_MACRO_NO64BIT_VARIANT_1_5(MACRO, VAR) \
79 MACRO(VAR, , int, s, 8, 8); \
80 MACRO(VAR, , int, s, 16, 4); \
81 MACRO(VAR, , int, s, 32, 2); \
82 MACRO(VAR, , uint, u, 8, 8); \
83 MACRO(VAR, , uint, u, 16, 4); \
84 MACRO(VAR, , uint, u, 32, 2); \
85 MACRO(VAR, q, int, s, 8, 16); \
86 MACRO(VAR, q, int, s, 16, 8); \
87 MACRO(VAR, q, int, s, 32, 4); \
88 MACRO(VAR, q, uint, u, 8, 16); \
89 MACRO(VAR, q, uint, u, 16, 8); \
90 MACRO(VAR, q, uint, u, 32, 4); \
91 FLOAT_VARIANT(MACRO, VAR); \
92 FLOAT16_VARIANT(MACRO, VAR);
93
94 /* Apply a binary operator named INSN_NAME. */
95 TEST_MACRO_NO64BIT_VARIANT_1_5(TEST_BINARY_OP, INSN_NAME);
96
97 CHECK(TEST_MSG, int, 8, 8, PRIx8, expected, "");
98 CHECK(TEST_MSG, int, 16, 4, PRIx16, expected, "");
99 CHECK(TEST_MSG, int, 32, 2, PRIx32, expected, "");
100 CHECK(TEST_MSG, uint, 8, 8, PRIx8, expected, "");
101 CHECK(TEST_MSG, uint, 16, 4, PRIx16, expected, "");
102 CHECK(TEST_MSG, uint, 32, 2, PRIx32, expected, "");
103 CHECK(TEST_MSG, int, 8, 16, PRIx8, expected, "");
104 CHECK(TEST_MSG, int, 16, 8, PRIx16, expected, "");
105 CHECK(TEST_MSG, int, 32, 4, PRIx32, expected, "");
106 CHECK(TEST_MSG, uint, 8, 16, PRIx8, expected, "");
107 CHECK(TEST_MSG, uint, 16, 8, PRIx16, expected, "");
108 CHECK(TEST_MSG, uint, 32, 4, PRIx32, expected, "");
109
110 #ifdef HAS_FLOAT16_VARIANT
111 CHECK_FP(TEST_MSG, float, 16, 4, PRIx16, expected, "");
112 CHECK_FP(TEST_MSG, float, 16, 8, PRIx16, expected, "");
113
114 /* Extra FP tests with special values (NaN, ....) */
115 VDUP(vector, q, float, f, 16, 8, 1.0f);
116 VDUP(vector2, q, float, f, 16, 8, NAN);
117 TEST_BINARY_OP(INSN_NAME, q, float, f, 16, 8);
118 CHECK_FP(TEST_MSG, float, 16, 8, PRIx16, expected_nan, " FP special (NaN)");
119
120 VDUP(vector, q, float, f, 16, 8, -NAN);
121 VDUP(vector2, q, float, f, 16, 8, 1.0f);
122 TEST_BINARY_OP(INSN_NAME, q, float, f, 16, 8);
123 CHECK_FP(TEST_MSG, float, 16, 8, PRIx16, expected_mnan, " FP special (-NaN)");
124
125 VDUP(vector, q, float, f, 16, 8, 1.0f);
126 VDUP(vector2, q, float, f, 16, 8, HUGE_VALF);
127 TEST_BINARY_OP(INSN_NAME, q, float, f, 16, 8);
128 CHECK_FP(TEST_MSG, float, 16, 8, PRIx16, expected_inf, " FP special (inf)");
129
130 VDUP(vector, q, float, f, 16, 8, -HUGE_VALF);
131 VDUP(vector2, q, float, f, 16, 8, 1.0f);
132 TEST_BINARY_OP(INSN_NAME, q, float, f, 16, 8);
133 CHECK_FP(TEST_MSG, float, 16, 8, PRIx16, expected_minf, " FP special (-inf)");
134
135 VDUP(vector, q, float, f, 16, 8, 0.0f);
136 VDUP(vector2, q, float, f, 16, 8, -0.0f);
137 TEST_BINARY_OP(INSN_NAME, q, float, f, 16, 8);
138 CHECK_FP(TEST_MSG, float, 16, 8, PRIx16, expected_zero1, " FP special (-0.0)");
139
140 VDUP(vector, q, float, f, 16, 8, -0.0f);
141 VDUP(vector2, q, float, f, 16, 8, 0.0f);
142 TEST_BINARY_OP(INSN_NAME, q, float, f, 16, 8);
143 CHECK_FP(TEST_MSG, float, 16, 8, PRIx16, expected_zero2, " FP special (-0.0)");
144 #endif
145
146 #ifdef HAS_FLOAT_VARIANT
147 CHECK_FP(TEST_MSG, float, 32, 2, PRIx32, expected, "");
148 CHECK_FP(TEST_MSG, float, 32, 4, PRIx32, expected, "");
149
150 /* Extra FP tests with special values (NaN, ....) */
151 VDUP(vector, q, float, f, 32, 4, 1.0f);
152 VDUP(vector2, q, float, f, 32, 4, NAN);
153 TEST_BINARY_OP(INSN_NAME, q, float, f, 32, 4);
154 CHECK_FP(TEST_MSG, float, 32, 4, PRIx32, expected_nan, " FP special (NaN)");
155
156 VDUP(vector, q, float, f, 32, 4, -NAN);
157 VDUP(vector2, q, float, f, 32, 4, 1.0f);
158 TEST_BINARY_OP(INSN_NAME, q, float, f, 32, 4);
159 CHECK_FP(TEST_MSG, float, 32, 4, PRIx32, expected_mnan, " FP special (-NaN)");
160
161 VDUP(vector, q, float, f, 32, 4, 1.0f);
162 VDUP(vector2, q, float, f, 32, 4, HUGE_VALF);
163 TEST_BINARY_OP(INSN_NAME, q, float, f, 32, 4);
164 CHECK_FP(TEST_MSG, float, 32, 4, PRIx32, expected_inf, " FP special (inf)");
165
166 VDUP(vector, q, float, f, 32, 4, -HUGE_VALF);
167 VDUP(vector2, q, float, f, 32, 4, 1.0f);
168 TEST_BINARY_OP(INSN_NAME, q, float, f, 32, 4);
169 CHECK_FP(TEST_MSG, float, 32, 4, PRIx32, expected_minf, " FP special (-inf)");
170
171 VDUP(vector, q, float, f, 32, 4, 0.0f);
172 VDUP(vector2, q, float, f, 32, 4, -0.0f);
173 TEST_BINARY_OP(INSN_NAME, q, float, f, 32, 4);
174 CHECK_FP(TEST_MSG, float, 32, 4, PRIx32, expected_zero1, " FP special (-0.0)");
175
176 VDUP(vector, q, float, f, 32, 4, -0.0f);
177 VDUP(vector2, q, float, f, 32, 4, 0.0f);
178 TEST_BINARY_OP(INSN_NAME, q, float, f, 32, 4);
179 CHECK_FP(TEST_MSG, float, 32, 4, PRIx32, expected_zero2, " FP special (-0.0)");
180 #endif
181 }
182
183 int main (void)
184 {
185 FNNAME (INSN_NAME) ();
186 return 0;
187 }