Debian Codegraph @

gcc/testsuite/gcc.target/loongarch/pr122097.c

raw
1 /* { dg-do compile } */
2 /* { dg-options "-O3 -mabi=lp64d -mlsx" } */
3
4 typedef long unsigned int size_t;
5 typedef unsigned char simde__mmask8;
6 typedef long simde__m128i __attribute__ ((__aligned__ ((16))))
7 __attribute__ ((__vector_size__ (16))) __attribute__ ((__may_alias__));
8 typedef union
9 {
10
11 __attribute__ ((__aligned__ ((16)))) long i64
12 __attribute__ ((__vector_size__ (16))) __attribute__ ((__may_alias__));
13 } simde__m128i_private;
14 typedef double simde_float64;
15 typedef simde_float64 simde__m128d __attribute__ ((__aligned__ ((16))))
16 __attribute__ ((__vector_size__ (16))) __attribute__ ((__may_alias__));
17 typedef long int int_fast32_t;
18 typedef union
19 {
20
21 __attribute__ ((__aligned__ ((16)))) int_fast32_t i32f
22 __attribute__ ((__vector_size__ (16))) __attribute__ ((__may_alias__));
23 __attribute__ ((__aligned__ ((16)))) long i64
24 __attribute__ ((__vector_size__ (16))) __attribute__ ((__may_alias__));
25 __attribute__ ((__aligned__ ((16)))) simde_float64 f64
26 __attribute__ ((__vector_size__ (16))) __attribute__ ((__may_alias__));
27 } simde__m128d_private;
28 __attribute__ ((__always_inline__)) inline static simde__m128d
29 simde__m128d_from_private (simde__m128d_private v)
30 {
31 simde__m128d r;
32 __builtin_memcpy (&r, &v, sizeof (r));
33 return r;
34 }
35
36 __attribute__ ((__always_inline__)) inline static simde__m128d
37 simde_mm_set_pd (simde_float64 e1, simde_float64 e0)
38 {
39
40 simde__m128d_private r_;
41 r_.f64[0] = e0;
42 r_.f64[1] = e1;
43
44 return simde__m128d_from_private (r_);
45 }
46 __attribute__ ((__always_inline__)) inline static simde__m128i
47 simde_mm_castpd_si128 (simde__m128d a)
48 {
49 simde__m128i r;
50 __builtin_memcpy (&r, &a, sizeof (a));
51 return r;
52 }
53
54 __attribute__ ((__always_inline__)) inline static simde__m128i
55 simde__m128i_from_private (simde__m128i_private v)
56 {
57 simde__m128i r;
58 __builtin_memcpy (&r, &v, sizeof (r));
59 return r;
60 }
61
62 __attribute__ ((__always_inline__)) inline static simde__m128i_private
63 simde__m128i_to_private (simde__m128i v)
64 {
65 simde__m128i_private r;
66 __builtin_memcpy (&r, &v, sizeof (r));
67 return r;
68 }
69 __attribute__ ((__always_inline__)) inline static simde__m128d
70 simde_mm_castsi128_pd (simde__m128i a)
71 {
72 simde__m128d r;
73 __builtin_memcpy (&r, &a, sizeof (a));
74 return r;
75 }
76
77 __attribute__ ((__always_inline__)) inline static simde__m128i
78 simde_mm_mask_mov_epi64 (simde__m128i src, simde__mmask8 k, simde__m128i a)
79 {
80
81 simde__m128i_private src_ = simde__m128i_to_private (src),
82 a_ = simde__m128i_to_private (a), r_;
83
84 for (size_t i = 0; i < (sizeof (r_.i64) / sizeof (r_.i64[0])); i++)
85 {
86 r_.i64[i] = ((k >> i) & 1) ? a_.i64[i] : src_.i64[i];
87 }
88
89 return simde__m128i_from_private (r_);
90 }
91
92 __attribute__ ((__always_inline__)) inline static simde__m128d
93 simde_mm_mask_mov_pd (simde__m128d src, simde__mmask8 k, simde__m128d a)
94 {
95 return simde_mm_castsi128_pd (simde_mm_mask_mov_epi64 (
96 simde_mm_castpd_si128 (src), k, simde_mm_castpd_si128 (a)));
97 }
98
99 static double
100 simde_test_f64_precision_to_slop (int precision)
101 {
102 return __builtin_expect (!!(precision == 0x7fffffff), 0)
103 ? 0.0
104 : __builtin_pow (10.0, -((double)(precision)));
105 }
106 __attribute__ ((__always_inline__)) inline static void
107 simde_mm_storeu_pd (simde_float64 *mem_addr, simde__m128d a)
108 {
109
110 __builtin_memcpy (mem_addr, &a, sizeof (a));
111 }
112 int simde_test_equal_f64 (simde_float64 a, simde_float64 b,
113 simde_float64 slop);
114 void simde_test_debug_printf_ (const char *format, ...);
115 static int
116 simde_assert_equal_vf64_ (size_t vec_len, simde_float64 const a[(vec_len)],
117 simde_float64 const b[(vec_len)], simde_float64 slop,
118 const char *filename, int line, const char *astr,
119 const char *bstr)
120 {
121 for (size_t i = 0; i < vec_len; i++)
122 {
123 if (__builtin_expect (!!(!simde_test_equal_f64 (a[i], b[i], slop)), 0))
124 {
125 simde_test_debug_printf_ (
126 "%s:%d: assertion failed: %s[%zu] ~= %s[%zu] (%f ~= %f)\n",
127 filename, line, astr, i, bstr, i, ((double)(a[i])),
128 ((double)(b[i])));
129 return 1;
130 }
131 }
132 return 0;
133 }
134 static int
135 simde_test_x86_assert_equal_f64x2_ (simde__m128d a, simde__m128d b,
136 simde_float64 slop, const char *filename,
137 int line, const char *astr,
138 const char *bstr)
139 {
140 simde_float64 a_[sizeof (a) / sizeof (simde_float64)],
141 b_[sizeof (a) / sizeof (simde_float64)];
142 simde_mm_storeu_pd (a_, a);
143 simde_mm_storeu_pd (b_, b);
144 return simde_assert_equal_vf64_ (sizeof (a_) / sizeof (a_[0]), a_, b_, slop,
145 filename, line, astr, bstr);
146 }
147 __attribute__ ((__always_inline__)) inline static simde__m128d_private
148 simde__m128d_to_private (simde__m128d v)
149 {
150 simde__m128d_private r;
151 __builtin_memcpy (&r, &v, sizeof (r));
152 return r;
153 }
154 __attribute__ ((__always_inline__)) inline static simde__m128d
155 simde_mm_min_pd (simde__m128d a, simde__m128d b)
156 {
157
158 simde__m128d_private r_, a_ = simde__m128d_to_private (a),
159 b_ = simde__m128d_to_private (b);
160
161 for (size_t i = 0; i < (sizeof (r_.f64) / sizeof (r_.f64[0])); i++)
162 {
163 r_.f64[i] = (a_.f64[i] < b_.f64[i]) ? a_.f64[i] : b_.f64[i];
164 }
165
166 return simde__m128d_from_private (r_);
167 }
168
169 __attribute__ ((__always_inline__)) inline static simde__m128d
170 simde_mm_max_pd (simde__m128d a, simde__m128d b)
171 {
172
173 simde__m128d_private r_, a_ = simde__m128d_to_private (a),
174 b_ = simde__m128d_to_private (b);
175
176 for (size_t i = 0; i < (sizeof (r_.f64) / sizeof (r_.f64[0])); i++)
177 {
178 r_.f64[i] = (a_.f64[i] > b_.f64[i]) ? a_.f64[i] : b_.f64[i];
179 }
180
181 return simde__m128d_from_private (r_);
182 }
183
184 __attribute__ ((__always_inline__)) inline static simde__m128d
185 simde_x_mm_abs_pd (simde__m128d a)
186 {
187
188 simde__m128d_private r_, a_ = simde__m128d_to_private (a);
189 for (size_t i = 0; i < (sizeof (r_.f64) / sizeof (r_.f64[0])); i++)
190 {
191 r_.f64[i] = __builtin_fabs (a_.f64[i]);
192 }
193
194 return simde__m128d_from_private (r_);
195 }
196 __attribute__ ((__always_inline__)) inline static simde__m128d
197 simde_mm_cmple_pd (simde__m128d a, simde__m128d b)
198 {
199
200 simde__m128d_private r_, a_ = simde__m128d_to_private (a),
201 b_ = simde__m128d_to_private (b);
202
203 r_.i64 = ((__typeof__ (r_.i64))((a_.f64 <= b_.f64)));
204 return simde__m128d_from_private (r_);
205 }
206
207 __attribute__ ((__always_inline__)) inline static simde__m128d
208 simde_x_mm_select_pd (simde__m128d a, simde__m128d b, simde__m128d mask)
209 {
210 simde__m128d_private r_, a_ = simde__m128d_to_private (a),
211 b_ = simde__m128d_to_private (b),
212 mask_ = simde__m128d_to_private (mask);
213
214 r_.i64 = a_.i64 ^ ((a_.i64 ^ b_.i64) & mask_.i64);
215 return simde__m128d_from_private (r_);
216 }
217 simde__m128d simde_mm_cmpge_pd (simde__m128d a, simde__m128d b);
218
219 simde__m128d
220 simde_x_mm_copysign_pd (simde__m128d dest, simde__m128d src)
221 {
222 simde__m128d_private r_, dest_ = simde__m128d_to_private (dest),
223 src_ = simde__m128d_to_private (src);
224 for (size_t i = 0; i < (sizeof (r_.f64) / sizeof (r_.f64[0])); i++)
225 {
226 r_.f64[i] = __builtin_copysign (dest_.f64[i], src_.f64[i]);
227 }
228
229 return simde__m128d_from_private (r_);
230 }
231 simde__m128d simde_mm_or_pd (simde__m128d a, simde__m128d b);
232
233 simde__m128d simde_mm_set1_pd (simde_float64 a);
234
235 __attribute__ ((__always_inline__)) inline static simde__m128d
236 simde_mm_range_pd (simde__m128d a, simde__m128d b, int imm8)
237 {
238 simde__m128d r;
239
240 r = simde_x_mm_select_pd (
241 b, a, simde_mm_cmple_pd (simde_x_mm_abs_pd (a), simde_x_mm_abs_pd (b)));
242
243 r = simde_x_mm_copysign_pd (r, a);
244
245 return r;
246 }
247 int
248 test_simde_mm_mask_range_pd (void)
249 {
250
251 simde__m128d src, a, b, e, r;
252
253 src = simde_mm_set_pd (-2.92, -85.39);
254 a = simde_mm_set_pd (-47.59, -122.31);
255 b = simde_mm_set_pd (877.42, 69.15);
256 e = simde_mm_set_pd (-47.59, -69.15);
257 r = simde_mm_mask_mov_pd (src, 143, simde_mm_range_pd (a, b, 2));
258 do
259 {
260 if (simde_test_x86_assert_equal_f64x2_ (
261 r, e, simde_test_f64_precision_to_slop (1),
262 "../test/x86/avx512/range.c", 1454, "r", "e"))
263 {
264 return 1;
265 }
266 }
267 while (0);
268
269 return 0;
270 }