1 /* SPDX-License-Identifier: MIT
2 *
3 * Permission is hereby granted, free of charge, to any person
4 * obtaining a copy of this software and associated documentation
5 * files (the "Software"), to deal in the Software without
6 * restriction, including without limitation the rights to use, copy,
7 * modify, merge, publish, distribute, sublicense, and/or sell copies
8 * of the Software, and to permit persons to whom the Software is
9 * furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice shall be
12 * included in all copies or substantial portions of the Software.
13 *
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
15 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
16 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
17 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
18 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
19 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
20 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 * SOFTWARE.
22 *
23 * Copyright:
24 * 2020 Evan Nemerson <evan@nemerson.com>
25 * 2020 Sean Maher <seanptmaher@gmail.com> (Copyright owned by Google, LLC)
26 */
27
28
29 #if !defined(SIMDE_ARM_NEON_REINTERPRET_H)
30 #define SIMDE_ARM_NEON_REINTERPRET_H
31
32 #include "types.h"
33
34 HEDLEY_DIAGNOSTIC_PUSH
35 SIMDE_DISABLE_UNWANTED_DIAGNOSTICS
36 SIMDE_BEGIN_DECLS_
37
38 SIMDE_FUNCTION_ATTRIBUTES
39 simde_int8x8_t
simde_vreinterpret_s8_s16(simde_int16x4_t a)40 simde_vreinterpret_s8_s16(simde_int16x4_t a) {
41 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
42 return vreinterpret_s8_s16(a);
43 #else
44 simde_int8x8_private r_;
45 simde_int16x4_private a_ = simde_int16x4_to_private(a);
46 simde_memcpy(&r_, &a_, sizeof(r_));
47 return simde_int8x8_from_private(r_);
48 #endif
49 }
50 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
51 #undef vreinterpret_s8_s16
52 #define vreinterpret_s8_s16(a) simde_vreinterpret_s8_s16(a)
53 #endif
54
55 SIMDE_FUNCTION_ATTRIBUTES
56 simde_int8x8_t
simde_vreinterpret_s8_s32(simde_int32x2_t a)57 simde_vreinterpret_s8_s32(simde_int32x2_t a) {
58 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
59 return vreinterpret_s8_s32(a);
60 #else
61 simde_int8x8_private r_;
62 simde_int32x2_private a_ = simde_int32x2_to_private(a);
63 simde_memcpy(&r_, &a_, sizeof(r_));
64 return simde_int8x8_from_private(r_);
65 #endif
66 }
67 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
68 #undef vreinterpret_s8_s32
69 #define vreinterpret_s8_s32(a) simde_vreinterpret_s8_s32(a)
70 #endif
71
72 SIMDE_FUNCTION_ATTRIBUTES
73 simde_int8x8_t
simde_vreinterpret_s8_s64(simde_int64x1_t a)74 simde_vreinterpret_s8_s64(simde_int64x1_t a) {
75 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
76 return vreinterpret_s8_s64(a);
77 #else
78 simde_int8x8_private r_;
79 simde_int64x1_private a_ = simde_int64x1_to_private(a);
80 simde_memcpy(&r_, &a_, sizeof(r_));
81 return simde_int8x8_from_private(r_);
82 #endif
83 }
84 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
85 #undef vreinterpret_s8_s64
86 #define vreinterpret_s8_s64(a) simde_vreinterpret_s8_s64(a)
87 #endif
88
89 SIMDE_FUNCTION_ATTRIBUTES
90 simde_int8x8_t
simde_vreinterpret_s8_u8(simde_uint8x8_t a)91 simde_vreinterpret_s8_u8(simde_uint8x8_t a) {
92 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
93 return vreinterpret_s8_u8(a);
94 #else
95 simde_int8x8_private r_;
96 simde_uint8x8_private a_ = simde_uint8x8_to_private(a);
97 simde_memcpy(&r_, &a_, sizeof(r_));
98 return simde_int8x8_from_private(r_);
99 #endif
100 }
101 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
102 #undef vreinterpret_s8_u8
103 #define vreinterpret_s8_u8(a) simde_vreinterpret_s8_u8(a)
104 #endif
105
106 SIMDE_FUNCTION_ATTRIBUTES
107 simde_int8x8_t
simde_vreinterpret_s8_u16(simde_uint16x4_t a)108 simde_vreinterpret_s8_u16(simde_uint16x4_t a) {
109 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
110 return vreinterpret_s8_u16(a);
111 #else
112 simde_int8x8_private r_;
113 simde_uint16x4_private a_ = simde_uint16x4_to_private(a);
114 simde_memcpy(&r_, &a_, sizeof(r_));
115 return simde_int8x8_from_private(r_);
116 #endif
117 }
118 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
119 #undef vreinterpret_s8_u16
120 #define vreinterpret_s8_u16(a) simde_vreinterpret_s8_u16(a)
121 #endif
122
123 SIMDE_FUNCTION_ATTRIBUTES
124 simde_int8x8_t
simde_vreinterpret_s8_u32(simde_uint32x2_t a)125 simde_vreinterpret_s8_u32(simde_uint32x2_t a) {
126 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
127 return vreinterpret_s8_u32(a);
128 #else
129 simde_int8x8_private r_;
130 simde_uint32x2_private a_ = simde_uint32x2_to_private(a);
131 simde_memcpy(&r_, &a_, sizeof(r_));
132 return simde_int8x8_from_private(r_);
133 #endif
134 }
135 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
136 #undef vreinterpret_s8_u32
137 #define vreinterpret_s8_u32(a) simde_vreinterpret_s8_u32(a)
138 #endif
139
140 SIMDE_FUNCTION_ATTRIBUTES
141 simde_int8x8_t
simde_vreinterpret_s8_u64(simde_uint64x1_t a)142 simde_vreinterpret_s8_u64(simde_uint64x1_t a) {
143 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
144 return vreinterpret_s8_u64(a);
145 #else
146 simde_int8x8_private r_;
147 simde_uint64x1_private a_ = simde_uint64x1_to_private(a);
148 simde_memcpy(&r_, &a_, sizeof(r_));
149 return simde_int8x8_from_private(r_);
150 #endif
151 }
152 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
153 #undef vreinterpret_s8_u64
154 #define vreinterpret_s8_u64(a) simde_vreinterpret_s8_u64(a)
155 #endif
156
157 SIMDE_FUNCTION_ATTRIBUTES
158 simde_int8x8_t
simde_vreinterpret_s8_f32(simde_float32x2_t a)159 simde_vreinterpret_s8_f32(simde_float32x2_t a) {
160 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
161 return vreinterpret_s8_f32(a);
162 #else
163 simde_int8x8_private r_;
164 simde_float32x2_private a_ = simde_float32x2_to_private(a);
165 simde_memcpy(&r_, &a_, sizeof(r_));
166 return simde_int8x8_from_private(r_);
167 #endif
168 }
169 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
170 #undef vreinterpret_s8_f32
171 #define vreinterpret_s8_f32(a) simde_vreinterpret_s8_f32(a)
172 #endif
173
174 SIMDE_FUNCTION_ATTRIBUTES
175 simde_int8x8_t
simde_vreinterpret_s8_f64(simde_float64x1_t a)176 simde_vreinterpret_s8_f64(simde_float64x1_t a) {
177 #if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
178 return vreinterpret_s8_f64(a);
179 #else
180 simde_int8x8_private r_;
181 simde_float64x1_private a_ = simde_float64x1_to_private(a);
182 simde_memcpy(&r_, &a_, sizeof(r_));
183 return simde_int8x8_from_private(r_);
184 #endif
185 }
186 #if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
187 #undef vreinterpret_s8_f64
188 #define vreinterpret_s8_f64(a) simde_vreinterpret_s8_f64(a)
189 #endif
190
191 SIMDE_FUNCTION_ATTRIBUTES
192 simde_int8x16_t
simde_vreinterpretq_s8_s16(simde_int16x8_t a)193 simde_vreinterpretq_s8_s16(simde_int16x8_t a) {
194 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
195 return vreinterpretq_s8_s16(a);
196 #else
197 simde_int8x16_private r_;
198 simde_int16x8_private a_ = simde_int16x8_to_private(a);
199 simde_memcpy(&r_, &a_, sizeof(r_));
200 return simde_int8x16_from_private(r_);
201 #endif
202 }
203 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
204 #undef vreinterpretq_s8_s16
205 #define vreinterpretq_s8_s16(a) simde_vreinterpretq_s8_s16(a)
206 #endif
207
208 SIMDE_FUNCTION_ATTRIBUTES
209 simde_int8x16_t
simde_vreinterpretq_s8_s32(simde_int32x4_t a)210 simde_vreinterpretq_s8_s32(simde_int32x4_t a) {
211 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
212 return vreinterpretq_s8_s32(a);
213 #else
214 simde_int8x16_private r_;
215 simde_int32x4_private a_ = simde_int32x4_to_private(a);
216 simde_memcpy(&r_, &a_, sizeof(r_));
217 return simde_int8x16_from_private(r_);
218 #endif
219 }
220 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
221 #undef vreinterpretq_s8_s32
222 #define vreinterpretq_s8_s32(a) simde_vreinterpretq_s8_s32(a)
223 #endif
224
225 SIMDE_FUNCTION_ATTRIBUTES
226 simde_int8x16_t
simde_vreinterpretq_s8_s64(simde_int64x2_t a)227 simde_vreinterpretq_s8_s64(simde_int64x2_t a) {
228 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
229 return vreinterpretq_s8_s64(a);
230 #else
231 simde_int8x16_private r_;
232 simde_int64x2_private a_ = simde_int64x2_to_private(a);
233 simde_memcpy(&r_, &a_, sizeof(r_));
234 return simde_int8x16_from_private(r_);
235 #endif
236 }
237 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
238 #undef vreinterpretq_s8_s64
239 #define vreinterpretq_s8_s64(a) simde_vreinterpretq_s8_s64(a)
240 #endif
241
242 SIMDE_FUNCTION_ATTRIBUTES
243 simde_int8x16_t
simde_vreinterpretq_s8_u8(simde_uint8x16_t a)244 simde_vreinterpretq_s8_u8(simde_uint8x16_t a) {
245 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
246 return vreinterpretq_s8_u8(a);
247 #else
248 simde_int8x16_private r_;
249 simde_uint8x16_private a_ = simde_uint8x16_to_private(a);
250 simde_memcpy(&r_, &a_, sizeof(r_));
251 return simde_int8x16_from_private(r_);
252 #endif
253 }
254 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
255 #undef vreinterpretq_s8_u8
256 #define vreinterpretq_s8_u8(a) simde_vreinterpretq_s8_u8(a)
257 #endif
258
259 SIMDE_FUNCTION_ATTRIBUTES
260 simde_int8x16_t
simde_vreinterpretq_s8_u16(simde_uint16x8_t a)261 simde_vreinterpretq_s8_u16(simde_uint16x8_t a) {
262 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
263 return vreinterpretq_s8_u16(a);
264 #else
265 simde_int8x16_private r_;
266 simde_uint16x8_private a_ = simde_uint16x8_to_private(a);
267 simde_memcpy(&r_, &a_, sizeof(r_));
268 return simde_int8x16_from_private(r_);
269 #endif
270 }
271 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
272 #undef vreinterpretq_s8_u16
273 #define vreinterpretq_s8_u16(a) simde_vreinterpretq_s8_u16(a)
274 #endif
275
276 SIMDE_FUNCTION_ATTRIBUTES
277 simde_int8x16_t
simde_vreinterpretq_s8_u32(simde_uint32x4_t a)278 simde_vreinterpretq_s8_u32(simde_uint32x4_t a) {
279 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
280 return vreinterpretq_s8_u32(a);
281 #else
282 simde_int8x16_private r_;
283 simde_uint32x4_private a_ = simde_uint32x4_to_private(a);
284 simde_memcpy(&r_, &a_, sizeof(r_));
285 return simde_int8x16_from_private(r_);
286 #endif
287 }
288 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
289 #undef vreinterpretq_s8_u32
290 #define vreinterpretq_s8_u32(a) simde_vreinterpretq_s8_u32(a)
291 #endif
292
293 SIMDE_FUNCTION_ATTRIBUTES
294 simde_int8x16_t
simde_vreinterpretq_s8_u64(simde_uint64x2_t a)295 simde_vreinterpretq_s8_u64(simde_uint64x2_t a) {
296 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
297 return vreinterpretq_s8_u64(a);
298 #else
299 simde_int8x16_private r_;
300 simde_uint64x2_private a_ = simde_uint64x2_to_private(a);
301 simde_memcpy(&r_, &a_, sizeof(r_));
302 return simde_int8x16_from_private(r_);
303 #endif
304 }
305 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
306 #undef vreinterpretq_s8_u64
307 #define vreinterpretq_s8_u64(a) simde_vreinterpretq_s8_u64(a)
308 #endif
309
310 SIMDE_FUNCTION_ATTRIBUTES
311 simde_int8x16_t
simde_vreinterpretq_s8_f32(simde_float32x4_t a)312 simde_vreinterpretq_s8_f32(simde_float32x4_t a) {
313 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
314 return vreinterpretq_s8_f32(a);
315 #else
316 simde_int8x16_private r_;
317 simde_float32x4_private a_ = simde_float32x4_to_private(a);
318 simde_memcpy(&r_, &a_, sizeof(r_));
319 return simde_int8x16_from_private(r_);
320 #endif
321 }
322 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
323 #undef vreinterpretq_s8_f32
324 #define vreinterpretq_s8_f32(a) simde_vreinterpretq_s8_f32(a)
325 #endif
326
327 SIMDE_FUNCTION_ATTRIBUTES
328 simde_int8x16_t
simde_vreinterpretq_s8_f64(simde_float64x2_t a)329 simde_vreinterpretq_s8_f64(simde_float64x2_t a) {
330 #if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
331 return vreinterpretq_s8_f64(a);
332 #else
333 simde_int8x16_private r_;
334 simde_float64x2_private a_ = simde_float64x2_to_private(a);
335 simde_memcpy(&r_, &a_, sizeof(r_));
336 return simde_int8x16_from_private(r_);
337 #endif
338 }
339 #if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
340 #undef vreinterpretq_s8_f64
341 #define vreinterpretq_s8_f64(a) simde_vreinterpretq_s8_f64(a)
342 #endif
343
344 SIMDE_FUNCTION_ATTRIBUTES
345 simde_int16x4_t
simde_vreinterpret_s16_s8(simde_int8x8_t a)346 simde_vreinterpret_s16_s8(simde_int8x8_t a) {
347 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
348 return vreinterpret_s16_s8(a);
349 #else
350 simde_int16x4_private r_;
351 simde_int8x8_private a_ = simde_int8x8_to_private(a);
352 simde_memcpy(&r_, &a_, sizeof(r_));
353 return simde_int16x4_from_private(r_);
354 #endif
355 }
356 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
357 #undef vreinterpret_s16_s8
358 #define vreinterpret_s16_s8(a) simde_vreinterpret_s16_s8(a)
359 #endif
360
361 SIMDE_FUNCTION_ATTRIBUTES
362 simde_int16x4_t
simde_vreinterpret_s16_s32(simde_int32x2_t a)363 simde_vreinterpret_s16_s32(simde_int32x2_t a) {
364 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
365 return vreinterpret_s16_s32(a);
366 #else
367 simde_int16x4_private r_;
368 simde_int32x2_private a_ = simde_int32x2_to_private(a);
369 simde_memcpy(&r_, &a_, sizeof(r_));
370 return simde_int16x4_from_private(r_);
371 #endif
372 }
373 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
374 #undef vreinterpret_s16_s32
375 #define vreinterpret_s16_s32(a) simde_vreinterpret_s16_s32(a)
376 #endif
377
378 SIMDE_FUNCTION_ATTRIBUTES
379 simde_int16x4_t
simde_vreinterpret_s16_s64(simde_int64x1_t a)380 simde_vreinterpret_s16_s64(simde_int64x1_t a) {
381 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
382 return vreinterpret_s16_s64(a);
383 #else
384 simde_int16x4_private r_;
385 simde_int64x1_private a_ = simde_int64x1_to_private(a);
386 simde_memcpy(&r_, &a_, sizeof(r_));
387 return simde_int16x4_from_private(r_);
388 #endif
389 }
390 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
391 #undef vreinterpret_s16_s64
392 #define vreinterpret_s16_s64(a) simde_vreinterpret_s16_s64(a)
393 #endif
394
395 SIMDE_FUNCTION_ATTRIBUTES
396 simde_int16x4_t
simde_vreinterpret_s16_u8(simde_uint8x8_t a)397 simde_vreinterpret_s16_u8(simde_uint8x8_t a) {
398 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
399 return vreinterpret_s16_u8(a);
400 #else
401 simde_int16x4_private r_;
402 simde_uint8x8_private a_ = simde_uint8x8_to_private(a);
403 simde_memcpy(&r_, &a_, sizeof(r_));
404 return simde_int16x4_from_private(r_);
405 #endif
406 }
407 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
408 #undef vreinterpret_s16_u8
409 #define vreinterpret_s16_u8(a) simde_vreinterpret_s16_u8(a)
410 #endif
411
412 SIMDE_FUNCTION_ATTRIBUTES
413 simde_int16x4_t
simde_vreinterpret_s16_u16(simde_uint16x4_t a)414 simde_vreinterpret_s16_u16(simde_uint16x4_t a) {
415 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
416 return vreinterpret_s16_u16(a);
417 #else
418 simde_int16x4_private r_;
419 simde_uint16x4_private a_ = simde_uint16x4_to_private(a);
420 simde_memcpy(&r_, &a_, sizeof(r_));
421 return simde_int16x4_from_private(r_);
422 #endif
423 }
424 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
425 #undef vreinterpret_s16_u16
426 #define vreinterpret_s16_u16(a) simde_vreinterpret_s16_u16(a)
427 #endif
428
429 SIMDE_FUNCTION_ATTRIBUTES
430 simde_int16x4_t
simde_vreinterpret_s16_u32(simde_uint32x2_t a)431 simde_vreinterpret_s16_u32(simde_uint32x2_t a) {
432 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
433 return vreinterpret_s16_u32(a);
434 #else
435 simde_int16x4_private r_;
436 simde_uint32x2_private a_ = simde_uint32x2_to_private(a);
437 simde_memcpy(&r_, &a_, sizeof(r_));
438 return simde_int16x4_from_private(r_);
439 #endif
440 }
441 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
442 #undef vreinterpret_s16_u32
443 #define vreinterpret_s16_u32(a) simde_vreinterpret_s16_u32(a)
444 #endif
445
446 SIMDE_FUNCTION_ATTRIBUTES
447 simde_int16x4_t
simde_vreinterpret_s16_u64(simde_uint64x1_t a)448 simde_vreinterpret_s16_u64(simde_uint64x1_t a) {
449 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
450 return vreinterpret_s16_u64(a);
451 #else
452 simde_int16x4_private r_;
453 simde_uint64x1_private a_ = simde_uint64x1_to_private(a);
454 simde_memcpy(&r_, &a_, sizeof(r_));
455 return simde_int16x4_from_private(r_);
456 #endif
457 }
458 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
459 #undef vreinterpret_s16_u64
460 #define vreinterpret_s16_u64(a) simde_vreinterpret_s16_u64(a)
461 #endif
462
463 SIMDE_FUNCTION_ATTRIBUTES
464 simde_int16x4_t
simde_vreinterpret_s16_f32(simde_float32x2_t a)465 simde_vreinterpret_s16_f32(simde_float32x2_t a) {
466 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
467 return vreinterpret_s16_f32(a);
468 #else
469 simde_int16x4_private r_;
470 simde_float32x2_private a_ = simde_float32x2_to_private(a);
471 simde_memcpy(&r_, &a_, sizeof(r_));
472 return simde_int16x4_from_private(r_);
473 #endif
474 }
475 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
476 #undef vreinterpret_s16_f32
477 #define vreinterpret_s16_f32(a) simde_vreinterpret_s16_f32(a)
478 #endif
479
480 SIMDE_FUNCTION_ATTRIBUTES
481 simde_int16x4_t
simde_vreinterpret_s16_f64(simde_float64x1_t a)482 simde_vreinterpret_s16_f64(simde_float64x1_t a) {
483 #if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
484 return vreinterpret_s16_f64(a);
485 #else
486 simde_int16x4_private r_;
487 simde_float64x1_private a_ = simde_float64x1_to_private(a);
488 simde_memcpy(&r_, &a_, sizeof(r_));
489 return simde_int16x4_from_private(r_);
490 #endif
491 }
492 #if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
493 #undef vreinterpret_s16_f64
494 #define vreinterpret_s16_f64(a) simde_vreinterpret_s16_f64(a)
495 #endif
496
497 SIMDE_FUNCTION_ATTRIBUTES
498 simde_int16x8_t
simde_vreinterpretq_s16_s8(simde_int8x16_t a)499 simde_vreinterpretq_s16_s8(simde_int8x16_t a) {
500 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
501 return vreinterpretq_s16_s8(a);
502 #else
503 simde_int16x8_private r_;
504 simde_int8x16_private a_ = simde_int8x16_to_private(a);
505 simde_memcpy(&r_, &a_, sizeof(r_));
506 return simde_int16x8_from_private(r_);
507 #endif
508 }
509 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
510 #undef vreinterpretq_s16_s8
511 #define vreinterpretq_s16_s8(a) simde_vreinterpretq_s16_s8(a)
512 #endif
513
514 SIMDE_FUNCTION_ATTRIBUTES
515 simde_int16x8_t
simde_vreinterpretq_s16_s32(simde_int32x4_t a)516 simde_vreinterpretq_s16_s32(simde_int32x4_t a) {
517 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
518 return vreinterpretq_s16_s32(a);
519 #else
520 simde_int16x8_private r_;
521 simde_int32x4_private a_ = simde_int32x4_to_private(a);
522 simde_memcpy(&r_, &a_, sizeof(r_));
523 return simde_int16x8_from_private(r_);
524 #endif
525 }
526 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
527 #undef vreinterpretq_s16_s32
528 #define vreinterpretq_s16_s32(a) simde_vreinterpretq_s16_s32(a)
529 #endif
530
531 SIMDE_FUNCTION_ATTRIBUTES
532 simde_int16x8_t
simde_vreinterpretq_s16_s64(simde_int64x2_t a)533 simde_vreinterpretq_s16_s64(simde_int64x2_t a) {
534 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
535 return vreinterpretq_s16_s64(a);
536 #else
537 simde_int16x8_private r_;
538 simde_int64x2_private a_ = simde_int64x2_to_private(a);
539 simde_memcpy(&r_, &a_, sizeof(r_));
540 return simde_int16x8_from_private(r_);
541 #endif
542 }
543 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
544 #undef vreinterpretq_s16_s64
545 #define vreinterpretq_s16_s64(a) simde_vreinterpretq_s16_s64(a)
546 #endif
547
548 SIMDE_FUNCTION_ATTRIBUTES
549 simde_int16x8_t
simde_vreinterpretq_s16_u8(simde_uint8x16_t a)550 simde_vreinterpretq_s16_u8(simde_uint8x16_t a) {
551 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
552 return vreinterpretq_s16_u8(a);
553 #else
554 simde_int16x8_private r_;
555 simde_uint8x16_private a_ = simde_uint8x16_to_private(a);
556 simde_memcpy(&r_, &a_, sizeof(r_));
557 return simde_int16x8_from_private(r_);
558 #endif
559 }
560 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
561 #undef vreinterpretq_s16_u8
562 #define vreinterpretq_s16_u8(a) simde_vreinterpretq_s16_u8(a)
563 #endif
564
565 SIMDE_FUNCTION_ATTRIBUTES
566 simde_int16x8_t
simde_vreinterpretq_s16_u16(simde_uint16x8_t a)567 simde_vreinterpretq_s16_u16(simde_uint16x8_t a) {
568 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
569 return vreinterpretq_s16_u16(a);
570 #else
571 simde_int16x8_private r_;
572 simde_uint16x8_private a_ = simde_uint16x8_to_private(a);
573 simde_memcpy(&r_, &a_, sizeof(r_));
574 return simde_int16x8_from_private(r_);
575 #endif
576 }
577 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
578 #undef vreinterpretq_s16_u16
579 #define vreinterpretq_s16_u16(a) simde_vreinterpretq_s16_u16(a)
580 #endif
581
582 SIMDE_FUNCTION_ATTRIBUTES
583 simde_int16x8_t
simde_vreinterpretq_s16_u32(simde_uint32x4_t a)584 simde_vreinterpretq_s16_u32(simde_uint32x4_t a) {
585 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
586 return vreinterpretq_s16_u32(a);
587 #else
588 simde_int16x8_private r_;
589 simde_uint32x4_private a_ = simde_uint32x4_to_private(a);
590 simde_memcpy(&r_, &a_, sizeof(r_));
591 return simde_int16x8_from_private(r_);
592 #endif
593 }
594 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
595 #undef vreinterpretq_s16_u32
596 #define vreinterpretq_s16_u32(a) simde_vreinterpretq_s16_u32(a)
597 #endif
598
599 SIMDE_FUNCTION_ATTRIBUTES
600 simde_int16x8_t
simde_vreinterpretq_s16_u64(simde_uint64x2_t a)601 simde_vreinterpretq_s16_u64(simde_uint64x2_t a) {
602 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
603 return vreinterpretq_s16_u64(a);
604 #else
605 simde_int16x8_private r_;
606 simde_uint64x2_private a_ = simde_uint64x2_to_private(a);
607 simde_memcpy(&r_, &a_, sizeof(r_));
608 return simde_int16x8_from_private(r_);
609 #endif
610 }
611 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
612 #undef vreinterpretq_s16_u64
613 #define vreinterpretq_s16_u64(a) simde_vreinterpretq_s16_u64(a)
614 #endif
615
616 SIMDE_FUNCTION_ATTRIBUTES
617 simde_int16x8_t
simde_vreinterpretq_s16_f32(simde_float32x4_t a)618 simde_vreinterpretq_s16_f32(simde_float32x4_t a) {
619 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
620 return vreinterpretq_s16_f32(a);
621 #else
622 simde_int16x8_private r_;
623 simde_float32x4_private a_ = simde_float32x4_to_private(a);
624 simde_memcpy(&r_, &a_, sizeof(r_));
625 return simde_int16x8_from_private(r_);
626 #endif
627 }
628 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
629 #undef vreinterpretq_s16_f32
630 #define vreinterpretq_s16_f32(a) simde_vreinterpretq_s16_f32(a)
631 #endif
632
633 SIMDE_FUNCTION_ATTRIBUTES
634 simde_int16x8_t
simde_vreinterpretq_s16_f64(simde_float64x2_t a)635 simde_vreinterpretq_s16_f64(simde_float64x2_t a) {
636 #if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
637 return vreinterpretq_s16_f64(a);
638 #else
639 simde_int16x8_private r_;
640 simde_float64x2_private a_ = simde_float64x2_to_private(a);
641 simde_memcpy(&r_, &a_, sizeof(r_));
642 return simde_int16x8_from_private(r_);
643 #endif
644 }
645 #if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
646 #undef vreinterpretq_s16_f64
647 #define vreinterpretq_s16_f64(a) simde_vreinterpretq_s16_f64(a)
648 #endif
649
650 SIMDE_FUNCTION_ATTRIBUTES
651 simde_int32x2_t
simde_vreinterpret_s32_s8(simde_int8x8_t a)652 simde_vreinterpret_s32_s8(simde_int8x8_t a) {
653 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
654 return vreinterpret_s32_s8(a);
655 #else
656 simde_int32x2_private r_;
657 simde_int8x8_private a_ = simde_int8x8_to_private(a);
658 simde_memcpy(&r_, &a_, sizeof(r_));
659 return simde_int32x2_from_private(r_);
660 #endif
661 }
662 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
663 #undef vreinterpret_s32_s8
664 #define vreinterpret_s32_s8(a) simde_vreinterpret_s32_s8(a)
665 #endif
666
667 SIMDE_FUNCTION_ATTRIBUTES
668 simde_int32x2_t
simde_vreinterpret_s32_s16(simde_int16x4_t a)669 simde_vreinterpret_s32_s16(simde_int16x4_t a) {
670 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
671 return vreinterpret_s32_s16(a);
672 #else
673 simde_int32x2_private r_;
674 simde_int16x4_private a_ = simde_int16x4_to_private(a);
675 simde_memcpy(&r_, &a_, sizeof(r_));
676 return simde_int32x2_from_private(r_);
677 #endif
678 }
679 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
680 #undef vreinterpret_s32_s16
681 #define vreinterpret_s32_s16(a) simde_vreinterpret_s32_s16(a)
682 #endif
683
684 SIMDE_FUNCTION_ATTRIBUTES
685 simde_int32x2_t
simde_vreinterpret_s32_s64(simde_int64x1_t a)686 simde_vreinterpret_s32_s64(simde_int64x1_t a) {
687 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
688 return vreinterpret_s32_s64(a);
689 #else
690 simde_int32x2_private r_;
691 simde_int64x1_private a_ = simde_int64x1_to_private(a);
692 simde_memcpy(&r_, &a_, sizeof(r_));
693 return simde_int32x2_from_private(r_);
694 #endif
695 }
696 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
697 #undef vreinterpret_s32_s64
698 #define vreinterpret_s32_s64(a) simde_vreinterpret_s32_s64(a)
699 #endif
700
701 SIMDE_FUNCTION_ATTRIBUTES
702 simde_int32x2_t
simde_vreinterpret_s32_u8(simde_uint8x8_t a)703 simde_vreinterpret_s32_u8(simde_uint8x8_t a) {
704 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
705 return vreinterpret_s32_u8(a);
706 #else
707 simde_int32x2_private r_;
708 simde_uint8x8_private a_ = simde_uint8x8_to_private(a);
709 simde_memcpy(&r_, &a_, sizeof(r_));
710 return simde_int32x2_from_private(r_);
711 #endif
712 }
713 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
714 #undef vreinterpret_s32_u8
715 #define vreinterpret_s32_u8(a) simde_vreinterpret_s32_u8(a)
716 #endif
717
718 SIMDE_FUNCTION_ATTRIBUTES
719 simde_int32x2_t
simde_vreinterpret_s32_u16(simde_uint16x4_t a)720 simde_vreinterpret_s32_u16(simde_uint16x4_t a) {
721 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
722 return vreinterpret_s32_u16(a);
723 #else
724 simde_int32x2_private r_;
725 simde_uint16x4_private a_ = simde_uint16x4_to_private(a);
726 simde_memcpy(&r_, &a_, sizeof(r_));
727 return simde_int32x2_from_private(r_);
728 #endif
729 }
730 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
731 #undef vreinterpret_s32_u16
732 #define vreinterpret_s32_u16(a) simde_vreinterpret_s32_u16(a)
733 #endif
734
735 SIMDE_FUNCTION_ATTRIBUTES
736 simde_int32x2_t
simde_vreinterpret_s32_u32(simde_uint32x2_t a)737 simde_vreinterpret_s32_u32(simde_uint32x2_t a) {
738 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
739 return vreinterpret_s32_u32(a);
740 #else
741 simde_int32x2_private r_;
742 simde_uint32x2_private a_ = simde_uint32x2_to_private(a);
743 simde_memcpy(&r_, &a_, sizeof(r_));
744 return simde_int32x2_from_private(r_);
745 #endif
746 }
747 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
748 #undef vreinterpret_s32_u32
749 #define vreinterpret_s32_u32(a) simde_vreinterpret_s32_u32(a)
750 #endif
751
752 SIMDE_FUNCTION_ATTRIBUTES
753 simde_int32x2_t
simde_vreinterpret_s32_u64(simde_uint64x1_t a)754 simde_vreinterpret_s32_u64(simde_uint64x1_t a) {
755 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
756 return vreinterpret_s32_u64(a);
757 #else
758 simde_int32x2_private r_;
759 simde_uint64x1_private a_ = simde_uint64x1_to_private(a);
760 simde_memcpy(&r_, &a_, sizeof(r_));
761 return simde_int32x2_from_private(r_);
762 #endif
763 }
764 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
765 #undef vreinterpret_s32_u64
766 #define vreinterpret_s32_u64(a) simde_vreinterpret_s32_u64(a)
767 #endif
768
769 SIMDE_FUNCTION_ATTRIBUTES
770 simde_int32x2_t
simde_vreinterpret_s32_f32(simde_float32x2_t a)771 simde_vreinterpret_s32_f32(simde_float32x2_t a) {
772 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
773 return vreinterpret_s32_f32(a);
774 #else
775 simde_int32x2_private r_;
776 simde_float32x2_private a_ = simde_float32x2_to_private(a);
777 simde_memcpy(&r_, &a_, sizeof(r_));
778 return simde_int32x2_from_private(r_);
779 #endif
780 }
781 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
782 #undef vreinterpret_s32_f32
783 #define vreinterpret_s32_f32(a) simde_vreinterpret_s32_f32(a)
784 #endif
785
786 SIMDE_FUNCTION_ATTRIBUTES
787 simde_int32x2_t
simde_vreinterpret_s32_f64(simde_float64x1_t a)788 simde_vreinterpret_s32_f64(simde_float64x1_t a) {
789 #if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
790 return vreinterpret_s32_f64(a);
791 #else
792 simde_int32x2_private r_;
793 simde_float64x1_private a_ = simde_float64x1_to_private(a);
794 simde_memcpy(&r_, &a_, sizeof(r_));
795 return simde_int32x2_from_private(r_);
796 #endif
797 }
798 #if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
799 #undef vreinterpret_s32_f64
800 #define vreinterpret_s32_f64(a) simde_vreinterpret_s32_f64(a)
801 #endif
802
803 SIMDE_FUNCTION_ATTRIBUTES
804 simde_int32x4_t
simde_vreinterpretq_s32_s8(simde_int8x16_t a)805 simde_vreinterpretq_s32_s8(simde_int8x16_t a) {
806 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
807 return vreinterpretq_s32_s8(a);
808 #else
809 simde_int32x4_private r_;
810 simde_int8x16_private a_ = simde_int8x16_to_private(a);
811 simde_memcpy(&r_, &a_, sizeof(r_));
812 return simde_int32x4_from_private(r_);
813 #endif
814 }
815 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
816 #undef vreinterpretq_s32_s8
817 #define vreinterpretq_s32_s8(a) simde_vreinterpretq_s32_s8(a)
818 #endif
819
820 SIMDE_FUNCTION_ATTRIBUTES
821 simde_int32x4_t
simde_vreinterpretq_s32_s16(simde_int16x8_t a)822 simde_vreinterpretq_s32_s16(simde_int16x8_t a) {
823 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
824 return vreinterpretq_s32_s16(a);
825 #else
826 simde_int32x4_private r_;
827 simde_int16x8_private a_ = simde_int16x8_to_private(a);
828 simde_memcpy(&r_, &a_, sizeof(r_));
829 return simde_int32x4_from_private(r_);
830 #endif
831 }
832 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
833 #undef vreinterpretq_s32_s16
834 #define vreinterpretq_s32_s16(a) simde_vreinterpretq_s32_s16(a)
835 #endif
836
837 SIMDE_FUNCTION_ATTRIBUTES
838 simde_int32x4_t
simde_vreinterpretq_s32_s64(simde_int64x2_t a)839 simde_vreinterpretq_s32_s64(simde_int64x2_t a) {
840 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
841 return vreinterpretq_s32_s64(a);
842 #else
843 simde_int32x4_private r_;
844 simde_int64x2_private a_ = simde_int64x2_to_private(a);
845 simde_memcpy(&r_, &a_, sizeof(r_));
846 return simde_int32x4_from_private(r_);
847 #endif
848 }
849 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
850 #undef vreinterpretq_s32_s64
851 #define vreinterpretq_s32_s64(a) simde_vreinterpretq_s32_s64(a)
852 #endif
853
854 SIMDE_FUNCTION_ATTRIBUTES
855 simde_int32x4_t
simde_vreinterpretq_s32_u8(simde_uint8x16_t a)856 simde_vreinterpretq_s32_u8(simde_uint8x16_t a) {
857 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
858 return vreinterpretq_s32_u8(a);
859 #else
860 simde_int32x4_private r_;
861 simde_uint8x16_private a_ = simde_uint8x16_to_private(a);
862 simde_memcpy(&r_, &a_, sizeof(r_));
863 return simde_int32x4_from_private(r_);
864 #endif
865 }
866 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
867 #undef vreinterpretq_s32_u8
868 #define vreinterpretq_s32_u8(a) simde_vreinterpretq_s32_u8(a)
869 #endif
870
871 SIMDE_FUNCTION_ATTRIBUTES
872 simde_int32x4_t
simde_vreinterpretq_s32_u16(simde_uint16x8_t a)873 simde_vreinterpretq_s32_u16(simde_uint16x8_t a) {
874 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
875 return vreinterpretq_s32_u16(a);
876 #else
877 simde_int32x4_private r_;
878 simde_uint16x8_private a_ = simde_uint16x8_to_private(a);
879 simde_memcpy(&r_, &a_, sizeof(r_));
880 return simde_int32x4_from_private(r_);
881 #endif
882 }
883 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
884 #undef vreinterpretq_s32_u16
885 #define vreinterpretq_s32_u16(a) simde_vreinterpretq_s32_u16(a)
886 #endif
887
888 SIMDE_FUNCTION_ATTRIBUTES
889 simde_int32x4_t
simde_vreinterpretq_s32_u32(simde_uint32x4_t a)890 simde_vreinterpretq_s32_u32(simde_uint32x4_t a) {
891 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
892 return vreinterpretq_s32_u32(a);
893 #else
894 simde_int32x4_private r_;
895 simde_uint32x4_private a_ = simde_uint32x4_to_private(a);
896 simde_memcpy(&r_, &a_, sizeof(r_));
897 return simde_int32x4_from_private(r_);
898 #endif
899 }
900 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
901 #undef vreinterpretq_s32_u32
902 #define vreinterpretq_s32_u32(a) simde_vreinterpretq_s32_u32(a)
903 #endif
904
905 SIMDE_FUNCTION_ATTRIBUTES
906 simde_int32x4_t
simde_vreinterpretq_s32_u64(simde_uint64x2_t a)907 simde_vreinterpretq_s32_u64(simde_uint64x2_t a) {
908 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
909 return vreinterpretq_s32_u64(a);
910 #else
911 simde_int32x4_private r_;
912 simde_uint64x2_private a_ = simde_uint64x2_to_private(a);
913 simde_memcpy(&r_, &a_, sizeof(r_));
914 return simde_int32x4_from_private(r_);
915 #endif
916 }
917 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
918 #undef vreinterpretq_s32_u64
919 #define vreinterpretq_s32_u64(a) simde_vreinterpretq_s32_u64(a)
920 #endif
921
922 SIMDE_FUNCTION_ATTRIBUTES
923 simde_int32x4_t
simde_vreinterpretq_s32_f32(simde_float32x4_t a)924 simde_vreinterpretq_s32_f32(simde_float32x4_t a) {
925 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
926 return vreinterpretq_s32_f32(a);
927 #else
928 simde_int32x4_private r_;
929 simde_float32x4_private a_ = simde_float32x4_to_private(a);
930 simde_memcpy(&r_, &a_, sizeof(r_));
931 return simde_int32x4_from_private(r_);
932 #endif
933 }
934 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
935 #undef vreinterpretq_s32_f32
936 #define vreinterpretq_s32_f32(a) simde_vreinterpretq_s32_f32(a)
937 #endif
938
939 SIMDE_FUNCTION_ATTRIBUTES
940 simde_int32x4_t
simde_vreinterpretq_s32_f64(simde_float64x2_t a)941 simde_vreinterpretq_s32_f64(simde_float64x2_t a) {
942 #if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
943 return vreinterpretq_s32_f64(a);
944 #else
945 simde_int32x4_private r_;
946 simde_float64x2_private a_ = simde_float64x2_to_private(a);
947 simde_memcpy(&r_, &a_, sizeof(r_));
948 return simde_int32x4_from_private(r_);
949 #endif
950 }
951 #if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
952 #undef vreinterpretq_s32_f64
953 #define vreinterpretq_s32_f64(a) simde_vreinterpretq_s32_f64(a)
954 #endif
955
956 SIMDE_FUNCTION_ATTRIBUTES
957 simde_int64x1_t
simde_vreinterpret_s64_s8(simde_int8x8_t a)958 simde_vreinterpret_s64_s8(simde_int8x8_t a) {
959 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
960 return vreinterpret_s64_s8(a);
961 #else
962 simde_int64x1_private r_;
963 simde_int8x8_private a_ = simde_int8x8_to_private(a);
964 simde_memcpy(&r_, &a_, sizeof(r_));
965 return simde_int64x1_from_private(r_);
966 #endif
967 }
968 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
969 #undef vreinterpret_s64_s8
970 #define vreinterpret_s64_s8(a) simde_vreinterpret_s64_s8(a)
971 #endif
972
973 SIMDE_FUNCTION_ATTRIBUTES
974 simde_int64x1_t
simde_vreinterpret_s64_s16(simde_int16x4_t a)975 simde_vreinterpret_s64_s16(simde_int16x4_t a) {
976 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
977 return vreinterpret_s64_s16(a);
978 #else
979 simde_int64x1_private r_;
980 simde_int16x4_private a_ = simde_int16x4_to_private(a);
981 simde_memcpy(&r_, &a_, sizeof(r_));
982 return simde_int64x1_from_private(r_);
983 #endif
984 }
985 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
986 #undef vreinterpret_s64_s16
987 #define vreinterpret_s64_s16(a) simde_vreinterpret_s64_s16(a)
988 #endif
989
990 SIMDE_FUNCTION_ATTRIBUTES
991 simde_int64x1_t
simde_vreinterpret_s64_s32(simde_int32x2_t a)992 simde_vreinterpret_s64_s32(simde_int32x2_t a) {
993 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
994 return vreinterpret_s64_s32(a);
995 #else
996 simde_int64x1_private r_;
997 simde_int32x2_private a_ = simde_int32x2_to_private(a);
998 simde_memcpy(&r_, &a_, sizeof(r_));
999 return simde_int64x1_from_private(r_);
1000 #endif
1001 }
1002 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
1003 #undef vreinterpret_s64_s32
1004 #define vreinterpret_s64_s32(a) simde_vreinterpret_s64_s32(a)
1005 #endif
1006
1007 SIMDE_FUNCTION_ATTRIBUTES
1008 simde_int64x1_t
simde_vreinterpret_s64_u8(simde_uint8x8_t a)1009 simde_vreinterpret_s64_u8(simde_uint8x8_t a) {
1010 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
1011 return vreinterpret_s64_u8(a);
1012 #else
1013 simde_int64x1_private r_;
1014 simde_uint8x8_private a_ = simde_uint8x8_to_private(a);
1015 simde_memcpy(&r_, &a_, sizeof(r_));
1016 return simde_int64x1_from_private(r_);
1017 #endif
1018 }
1019 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
1020 #undef vreinterpret_s64_u8
1021 #define vreinterpret_s64_u8(a) simde_vreinterpret_s64_u8(a)
1022 #endif
1023
1024 SIMDE_FUNCTION_ATTRIBUTES
1025 simde_int64x1_t
simde_vreinterpret_s64_u16(simde_uint16x4_t a)1026 simde_vreinterpret_s64_u16(simde_uint16x4_t a) {
1027 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
1028 return vreinterpret_s64_u16(a);
1029 #else
1030 simde_int64x1_private r_;
1031 simde_uint16x4_private a_ = simde_uint16x4_to_private(a);
1032 simde_memcpy(&r_, &a_, sizeof(r_));
1033 return simde_int64x1_from_private(r_);
1034 #endif
1035 }
1036 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
1037 #undef vreinterpret_s64_u16
1038 #define vreinterpret_s64_u16(a) simde_vreinterpret_s64_u16(a)
1039 #endif
1040
1041 SIMDE_FUNCTION_ATTRIBUTES
1042 simde_int64x1_t
simde_vreinterpret_s64_u32(simde_uint32x2_t a)1043 simde_vreinterpret_s64_u32(simde_uint32x2_t a) {
1044 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
1045 return vreinterpret_s64_u32(a);
1046 #else
1047 simde_int64x1_private r_;
1048 simde_uint32x2_private a_ = simde_uint32x2_to_private(a);
1049 simde_memcpy(&r_, &a_, sizeof(r_));
1050 return simde_int64x1_from_private(r_);
1051 #endif
1052 }
1053 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
1054 #undef vreinterpret_s64_u32
1055 #define vreinterpret_s64_u32(a) simde_vreinterpret_s64_u32(a)
1056 #endif
1057
1058 SIMDE_FUNCTION_ATTRIBUTES
1059 simde_int64x1_t
simde_vreinterpret_s64_u64(simde_uint64x1_t a)1060 simde_vreinterpret_s64_u64(simde_uint64x1_t a) {
1061 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
1062 return vreinterpret_s64_u64(a);
1063 #else
1064 simde_int64x1_private r_;
1065 simde_uint64x1_private a_ = simde_uint64x1_to_private(a);
1066 simde_memcpy(&r_, &a_, sizeof(r_));
1067 return simde_int64x1_from_private(r_);
1068 #endif
1069 }
1070 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
1071 #undef vreinterpret_s64_u64
1072 #define vreinterpret_s64_u64(a) simde_vreinterpret_s64_u64(a)
1073 #endif
1074
1075 SIMDE_FUNCTION_ATTRIBUTES
1076 simde_int64x1_t
simde_vreinterpret_s64_f32(simde_float32x2_t a)1077 simde_vreinterpret_s64_f32(simde_float32x2_t a) {
1078 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
1079 return vreinterpret_s64_f32(a);
1080 #else
1081 simde_int64x1_private r_;
1082 simde_float32x2_private a_ = simde_float32x2_to_private(a);
1083 simde_memcpy(&r_, &a_, sizeof(r_));
1084 return simde_int64x1_from_private(r_);
1085 #endif
1086 }
1087 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
1088 #undef vreinterpret_s64_f32
1089 #define vreinterpret_s64_f32(a) simde_vreinterpret_s64_f32(a)
1090 #endif
1091
1092 SIMDE_FUNCTION_ATTRIBUTES
1093 simde_int64x1_t
simde_vreinterpret_s64_f64(simde_float64x1_t a)1094 simde_vreinterpret_s64_f64(simde_float64x1_t a) {
1095 #if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
1096 return vreinterpret_s64_f64(a);
1097 #else
1098 simde_int64x1_private r_;
1099 simde_float64x1_private a_ = simde_float64x1_to_private(a);
1100 simde_memcpy(&r_, &a_, sizeof(r_));
1101 return simde_int64x1_from_private(r_);
1102 #endif
1103 }
1104 #if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
1105 #undef vreinterpret_s64_f64
1106 #define vreinterpret_s64_f64(a) simde_vreinterpret_s64_f64(a)
1107 #endif
1108
1109 SIMDE_FUNCTION_ATTRIBUTES
1110 simde_int64x2_t
simde_vreinterpretq_s64_s8(simde_int8x16_t a)1111 simde_vreinterpretq_s64_s8(simde_int8x16_t a) {
1112 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
1113 return vreinterpretq_s64_s8(a);
1114 #else
1115 simde_int64x2_private r_;
1116 simde_int8x16_private a_ = simde_int8x16_to_private(a);
1117 simde_memcpy(&r_, &a_, sizeof(r_));
1118 return simde_int64x2_from_private(r_);
1119 #endif
1120 }
1121 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
1122 #undef vreinterpretq_s64_s8
1123 #define vreinterpretq_s64_s8(a) simde_vreinterpretq_s64_s8(a)
1124 #endif
1125
1126 SIMDE_FUNCTION_ATTRIBUTES
1127 simde_int64x2_t
simde_vreinterpretq_s64_s16(simde_int16x8_t a)1128 simde_vreinterpretq_s64_s16(simde_int16x8_t a) {
1129 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
1130 return vreinterpretq_s64_s16(a);
1131 #else
1132 simde_int64x2_private r_;
1133 simde_int16x8_private a_ = simde_int16x8_to_private(a);
1134 simde_memcpy(&r_, &a_, sizeof(r_));
1135 return simde_int64x2_from_private(r_);
1136 #endif
1137 }
1138 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
1139 #undef vreinterpretq_s64_s16
1140 #define vreinterpretq_s64_s16(a) simde_vreinterpretq_s64_s16(a)
1141 #endif
1142
1143 SIMDE_FUNCTION_ATTRIBUTES
1144 simde_int64x2_t
simde_vreinterpretq_s64_s32(simde_int32x4_t a)1145 simde_vreinterpretq_s64_s32(simde_int32x4_t a) {
1146 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
1147 return vreinterpretq_s64_s32(a);
1148 #else
1149 simde_int64x2_private r_;
1150 simde_int32x4_private a_ = simde_int32x4_to_private(a);
1151 simde_memcpy(&r_, &a_, sizeof(r_));
1152 return simde_int64x2_from_private(r_);
1153 #endif
1154 }
1155 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
1156 #undef vreinterpretq_s64_s32
1157 #define vreinterpretq_s64_s32(a) simde_vreinterpretq_s64_s32(a)
1158 #endif
1159
1160 SIMDE_FUNCTION_ATTRIBUTES
1161 simde_int64x2_t
simde_vreinterpretq_s64_u8(simde_uint8x16_t a)1162 simde_vreinterpretq_s64_u8(simde_uint8x16_t a) {
1163 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
1164 return vreinterpretq_s64_u8(a);
1165 #else
1166 simde_int64x2_private r_;
1167 simde_uint8x16_private a_ = simde_uint8x16_to_private(a);
1168 simde_memcpy(&r_, &a_, sizeof(r_));
1169 return simde_int64x2_from_private(r_);
1170 #endif
1171 }
1172 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
1173 #undef vreinterpretq_s64_u8
1174 #define vreinterpretq_s64_u8(a) simde_vreinterpretq_s64_u8(a)
1175 #endif
1176
1177 SIMDE_FUNCTION_ATTRIBUTES
1178 simde_int64x2_t
simde_vreinterpretq_s64_u16(simde_uint16x8_t a)1179 simde_vreinterpretq_s64_u16(simde_uint16x8_t a) {
1180 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
1181 return vreinterpretq_s64_u16(a);
1182 #else
1183 simde_int64x2_private r_;
1184 simde_uint16x8_private a_ = simde_uint16x8_to_private(a);
1185 simde_memcpy(&r_, &a_, sizeof(r_));
1186 return simde_int64x2_from_private(r_);
1187 #endif
1188 }
1189 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
1190 #undef vreinterpretq_s64_u16
1191 #define vreinterpretq_s64_u16(a) simde_vreinterpretq_s64_u16(a)
1192 #endif
1193
1194 SIMDE_FUNCTION_ATTRIBUTES
1195 simde_int64x2_t
simde_vreinterpretq_s64_u32(simde_uint32x4_t a)1196 simde_vreinterpretq_s64_u32(simde_uint32x4_t a) {
1197 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
1198 return vreinterpretq_s64_u32(a);
1199 #else
1200 simde_int64x2_private r_;
1201 simde_uint32x4_private a_ = simde_uint32x4_to_private(a);
1202 simde_memcpy(&r_, &a_, sizeof(r_));
1203 return simde_int64x2_from_private(r_);
1204 #endif
1205 }
1206 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
1207 #undef vreinterpretq_s64_u32
1208 #define vreinterpretq_s64_u32(a) simde_vreinterpretq_s64_u32(a)
1209 #endif
1210
1211 SIMDE_FUNCTION_ATTRIBUTES
1212 simde_int64x2_t
simde_vreinterpretq_s64_u64(simde_uint64x2_t a)1213 simde_vreinterpretq_s64_u64(simde_uint64x2_t a) {
1214 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
1215 return vreinterpretq_s64_u64(a);
1216 #else
1217 simde_int64x2_private r_;
1218 simde_uint64x2_private a_ = simde_uint64x2_to_private(a);
1219 simde_memcpy(&r_, &a_, sizeof(r_));
1220 return simde_int64x2_from_private(r_);
1221 #endif
1222 }
1223 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
1224 #undef vreinterpretq_s64_u64
1225 #define vreinterpretq_s64_u64(a) simde_vreinterpretq_s64_u64(a)
1226 #endif
1227
1228 SIMDE_FUNCTION_ATTRIBUTES
1229 simde_int64x2_t
simde_vreinterpretq_s64_f32(simde_float32x4_t a)1230 simde_vreinterpretq_s64_f32(simde_float32x4_t a) {
1231 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
1232 return vreinterpretq_s64_f32(a);
1233 #else
1234 simde_int64x2_private r_;
1235 simde_float32x4_private a_ = simde_float32x4_to_private(a);
1236 simde_memcpy(&r_, &a_, sizeof(r_));
1237 return simde_int64x2_from_private(r_);
1238 #endif
1239 }
1240 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
1241 #undef vreinterpretq_s64_f32
1242 #define vreinterpretq_s64_f32(a) simde_vreinterpretq_s64_f32(a)
1243 #endif
1244
1245 SIMDE_FUNCTION_ATTRIBUTES
1246 simde_int64x2_t
simde_vreinterpretq_s64_f64(simde_float64x2_t a)1247 simde_vreinterpretq_s64_f64(simde_float64x2_t a) {
1248 #if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
1249 return vreinterpretq_s64_f64(a);
1250 #else
1251 simde_int64x2_private r_;
1252 simde_float64x2_private a_ = simde_float64x2_to_private(a);
1253 simde_memcpy(&r_, &a_, sizeof(r_));
1254 return simde_int64x2_from_private(r_);
1255 #endif
1256 }
1257 #if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
1258 #undef vreinterpretq_s64_f64
1259 #define vreinterpretq_s64_f64(a) simde_vreinterpretq_s64_f64(a)
1260 #endif
1261
1262 SIMDE_FUNCTION_ATTRIBUTES
1263 simde_uint8x8_t
simde_vreinterpret_u8_s8(simde_int8x8_t a)1264 simde_vreinterpret_u8_s8(simde_int8x8_t a) {
1265 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
1266 return vreinterpret_u8_s8(a);
1267 #else
1268 simde_uint8x8_private r_;
1269 simde_int8x8_private a_ = simde_int8x8_to_private(a);
1270 simde_memcpy(&r_, &a_, sizeof(r_));
1271 return simde_uint8x8_from_private(r_);
1272 #endif
1273 }
1274 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
1275 #undef vreinterpret_u8_s8
1276 #define vreinterpret_u8_s8(a) simde_vreinterpret_u8_s8(a)
1277 #endif
1278
1279 SIMDE_FUNCTION_ATTRIBUTES
1280 simde_uint8x8_t
simde_vreinterpret_u8_s16(simde_int16x4_t a)1281 simde_vreinterpret_u8_s16(simde_int16x4_t a) {
1282 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
1283 return vreinterpret_u8_s16(a);
1284 #else
1285 simde_uint8x8_private r_;
1286 simde_int16x4_private a_ = simde_int16x4_to_private(a);
1287 simde_memcpy(&r_, &a_, sizeof(r_));
1288 return simde_uint8x8_from_private(r_);
1289 #endif
1290 }
1291 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
1292 #undef vreinterpret_u8_s16
1293 #define vreinterpret_u8_s16(a) simde_vreinterpret_u8_s16(a)
1294 #endif
1295
1296 SIMDE_FUNCTION_ATTRIBUTES
1297 simde_uint8x8_t
simde_vreinterpret_u8_s32(simde_int32x2_t a)1298 simde_vreinterpret_u8_s32(simde_int32x2_t a) {
1299 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
1300 return vreinterpret_u8_s32(a);
1301 #else
1302 simde_uint8x8_private r_;
1303 simde_int32x2_private a_ = simde_int32x2_to_private(a);
1304 simde_memcpy(&r_, &a_, sizeof(r_));
1305 return simde_uint8x8_from_private(r_);
1306 #endif
1307 }
1308 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
1309 #undef vreinterpret_u8_s32
1310 #define vreinterpret_u8_s32(a) simde_vreinterpret_u8_s32(a)
1311 #endif
1312
1313 SIMDE_FUNCTION_ATTRIBUTES
1314 simde_uint8x8_t
simde_vreinterpret_u8_s64(simde_int64x1_t a)1315 simde_vreinterpret_u8_s64(simde_int64x1_t a) {
1316 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
1317 return vreinterpret_u8_s64(a);
1318 #else
1319 simde_uint8x8_private r_;
1320 simde_int64x1_private a_ = simde_int64x1_to_private(a);
1321 simde_memcpy(&r_, &a_, sizeof(r_));
1322 return simde_uint8x8_from_private(r_);
1323 #endif
1324 }
1325 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
1326 #undef vreinterpret_u8_s64
1327 #define vreinterpret_u8_s64(a) simde_vreinterpret_u8_s64(a)
1328 #endif
1329
1330 SIMDE_FUNCTION_ATTRIBUTES
1331 simde_uint8x8_t
simde_vreinterpret_u8_u16(simde_uint16x4_t a)1332 simde_vreinterpret_u8_u16(simde_uint16x4_t a) {
1333 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
1334 return vreinterpret_u8_u16(a);
1335 #else
1336 simde_uint8x8_private r_;
1337 simde_uint16x4_private a_ = simde_uint16x4_to_private(a);
1338 simde_memcpy(&r_, &a_, sizeof(r_));
1339 return simde_uint8x8_from_private(r_);
1340 #endif
1341 }
1342 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
1343 #undef vreinterpret_u8_u16
1344 #define vreinterpret_u8_u16(a) simde_vreinterpret_u8_u16(a)
1345 #endif
1346
1347 SIMDE_FUNCTION_ATTRIBUTES
1348 simde_uint8x8_t
simde_vreinterpret_u8_u32(simde_uint32x2_t a)1349 simde_vreinterpret_u8_u32(simde_uint32x2_t a) {
1350 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
1351 return vreinterpret_u8_u32(a);
1352 #else
1353 simde_uint8x8_private r_;
1354 simde_uint32x2_private a_ = simde_uint32x2_to_private(a);
1355 simde_memcpy(&r_, &a_, sizeof(r_));
1356 return simde_uint8x8_from_private(r_);
1357 #endif
1358 }
1359 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
1360 #undef vreinterpret_u8_u32
1361 #define vreinterpret_u8_u32(a) simde_vreinterpret_u8_u32(a)
1362 #endif
1363
1364 SIMDE_FUNCTION_ATTRIBUTES
1365 simde_uint8x8_t
simde_vreinterpret_u8_u64(simde_uint64x1_t a)1366 simde_vreinterpret_u8_u64(simde_uint64x1_t a) {
1367 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
1368 return vreinterpret_u8_u64(a);
1369 #else
1370 simde_uint8x8_private r_;
1371 simde_uint64x1_private a_ = simde_uint64x1_to_private(a);
1372 simde_memcpy(&r_, &a_, sizeof(r_));
1373 return simde_uint8x8_from_private(r_);
1374 #endif
1375 }
1376 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
1377 #undef vreinterpret_u8_u64
1378 #define vreinterpret_u8_u64(a) simde_vreinterpret_u8_u64(a)
1379 #endif
1380
1381 SIMDE_FUNCTION_ATTRIBUTES
1382 simde_uint8x8_t
simde_vreinterpret_u8_f32(simde_float32x2_t a)1383 simde_vreinterpret_u8_f32(simde_float32x2_t a) {
1384 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
1385 return vreinterpret_u8_f32(a);
1386 #else
1387 simde_uint8x8_private r_;
1388 simde_float32x2_private a_ = simde_float32x2_to_private(a);
1389 simde_memcpy(&r_, &a_, sizeof(r_));
1390 return simde_uint8x8_from_private(r_);
1391 #endif
1392 }
1393 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
1394 #undef vreinterpret_u8_f32
1395 #define vreinterpret_u8_f32(a) simde_vreinterpret_u8_f32(a)
1396 #endif
1397
1398 SIMDE_FUNCTION_ATTRIBUTES
1399 simde_uint8x8_t
simde_vreinterpret_u8_f64(simde_float64x1_t a)1400 simde_vreinterpret_u8_f64(simde_float64x1_t a) {
1401 #if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
1402 return vreinterpret_u8_f64(a);
1403 #else
1404 simde_uint8x8_private r_;
1405 simde_float64x1_private a_ = simde_float64x1_to_private(a);
1406 simde_memcpy(&r_, &a_, sizeof(r_));
1407 return simde_uint8x8_from_private(r_);
1408 #endif
1409 }
1410 #if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
1411 #undef vreinterpret_u8_f64
1412 #define vreinterpret_u8_f64(a) simde_vreinterpret_u8_f64(a)
1413 #endif
1414
1415 SIMDE_FUNCTION_ATTRIBUTES
1416 simde_uint8x16_t
simde_vreinterpretq_u8_s8(simde_int8x16_t a)1417 simde_vreinterpretq_u8_s8(simde_int8x16_t a) {
1418 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
1419 return vreinterpretq_u8_s8(a);
1420 #else
1421 simde_uint8x16_private r_;
1422 simde_int8x16_private a_ = simde_int8x16_to_private(a);
1423 simde_memcpy(&r_, &a_, sizeof(r_));
1424 return simde_uint8x16_from_private(r_);
1425 #endif
1426 }
1427 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
1428 #undef vreinterpretq_u8_s8
1429 #define vreinterpretq_u8_s8(a) simde_vreinterpretq_u8_s8(a)
1430 #endif
1431
1432 SIMDE_FUNCTION_ATTRIBUTES
1433 simde_uint8x16_t
simde_vreinterpretq_u8_s16(simde_int16x8_t a)1434 simde_vreinterpretq_u8_s16(simde_int16x8_t a) {
1435 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
1436 return vreinterpretq_u8_s16(a);
1437 #else
1438 simde_uint8x16_private r_;
1439 simde_int16x8_private a_ = simde_int16x8_to_private(a);
1440 simde_memcpy(&r_, &a_, sizeof(r_));
1441 return simde_uint8x16_from_private(r_);
1442 #endif
1443 }
1444 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
1445 #undef vreinterpretq_u8_s16
1446 #define vreinterpretq_u8_s16(a) simde_vreinterpretq_u8_s16(a)
1447 #endif
1448
1449 SIMDE_FUNCTION_ATTRIBUTES
1450 simde_uint8x16_t
simde_vreinterpretq_u8_s32(simde_int32x4_t a)1451 simde_vreinterpretq_u8_s32(simde_int32x4_t a) {
1452 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
1453 return vreinterpretq_u8_s32(a);
1454 #else
1455 simde_uint8x16_private r_;
1456 simde_int32x4_private a_ = simde_int32x4_to_private(a);
1457 simde_memcpy(&r_, &a_, sizeof(r_));
1458 return simde_uint8x16_from_private(r_);
1459 #endif
1460 }
1461 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
1462 #undef vreinterpretq_u8_s32
1463 #define vreinterpretq_u8_s32(a) simde_vreinterpretq_u8_s32(a)
1464 #endif
1465
1466 SIMDE_FUNCTION_ATTRIBUTES
1467 simde_uint8x16_t
simde_vreinterpretq_u8_s64(simde_int64x2_t a)1468 simde_vreinterpretq_u8_s64(simde_int64x2_t a) {
1469 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
1470 return vreinterpretq_u8_s64(a);
1471 #else
1472 simde_uint8x16_private r_;
1473 simde_int64x2_private a_ = simde_int64x2_to_private(a);
1474 simde_memcpy(&r_, &a_, sizeof(r_));
1475 return simde_uint8x16_from_private(r_);
1476 #endif
1477 }
1478 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
1479 #undef vreinterpretq_u8_s64
1480 #define vreinterpretq_u8_s64(a) simde_vreinterpretq_u8_s64(a)
1481 #endif
1482
1483 SIMDE_FUNCTION_ATTRIBUTES
1484 simde_uint8x16_t
simde_vreinterpretq_u8_u16(simde_uint16x8_t a)1485 simde_vreinterpretq_u8_u16(simde_uint16x8_t a) {
1486 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
1487 return vreinterpretq_u8_u16(a);
1488 #else
1489 simde_uint8x16_private r_;
1490 simde_uint16x8_private a_ = simde_uint16x8_to_private(a);
1491 simde_memcpy(&r_, &a_, sizeof(r_));
1492 return simde_uint8x16_from_private(r_);
1493 #endif
1494 }
1495 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
1496 #undef vreinterpretq_u8_u16
1497 #define vreinterpretq_u8_u16(a) simde_vreinterpretq_u8_u16(a)
1498 #endif
1499
1500 SIMDE_FUNCTION_ATTRIBUTES
1501 simde_uint8x16_t
simde_vreinterpretq_u8_u32(simde_uint32x4_t a)1502 simde_vreinterpretq_u8_u32(simde_uint32x4_t a) {
1503 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
1504 return vreinterpretq_u8_u32(a);
1505 #else
1506 simde_uint8x16_private r_;
1507 simde_uint32x4_private a_ = simde_uint32x4_to_private(a);
1508 simde_memcpy(&r_, &a_, sizeof(r_));
1509 return simde_uint8x16_from_private(r_);
1510 #endif
1511 }
1512 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
1513 #undef vreinterpretq_u8_u32
1514 #define vreinterpretq_u8_u32(a) simde_vreinterpretq_u8_u32(a)
1515 #endif
1516
1517 SIMDE_FUNCTION_ATTRIBUTES
1518 simde_uint8x16_t
simde_vreinterpretq_u8_u64(simde_uint64x2_t a)1519 simde_vreinterpretq_u8_u64(simde_uint64x2_t a) {
1520 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
1521 return vreinterpretq_u8_u64(a);
1522 #else
1523 simde_uint8x16_private r_;
1524 simde_uint64x2_private a_ = simde_uint64x2_to_private(a);
1525 simde_memcpy(&r_, &a_, sizeof(r_));
1526 return simde_uint8x16_from_private(r_);
1527 #endif
1528 }
1529 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
1530 #undef vreinterpretq_u8_u64
1531 #define vreinterpretq_u8_u64(a) simde_vreinterpretq_u8_u64(a)
1532 #endif
1533
1534 SIMDE_FUNCTION_ATTRIBUTES
1535 simde_uint8x16_t
simde_vreinterpretq_u8_f32(simde_float32x4_t a)1536 simde_vreinterpretq_u8_f32(simde_float32x4_t a) {
1537 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
1538 return vreinterpretq_u8_f32(a);
1539 #else
1540 simde_uint8x16_private r_;
1541 simde_float32x4_private a_ = simde_float32x4_to_private(a);
1542 simde_memcpy(&r_, &a_, sizeof(r_));
1543 return simde_uint8x16_from_private(r_);
1544 #endif
1545 }
1546 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
1547 #undef vreinterpretq_u8_f32
1548 #define vreinterpretq_u8_f32(a) simde_vreinterpretq_u8_f32(a)
1549 #endif
1550
1551 SIMDE_FUNCTION_ATTRIBUTES
1552 simde_uint8x16_t
simde_vreinterpretq_u8_f64(simde_float64x2_t a)1553 simde_vreinterpretq_u8_f64(simde_float64x2_t a) {
1554 #if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
1555 return vreinterpretq_u8_f64(a);
1556 #else
1557 simde_uint8x16_private r_;
1558 simde_float64x2_private a_ = simde_float64x2_to_private(a);
1559 simde_memcpy(&r_, &a_, sizeof(r_));
1560 return simde_uint8x16_from_private(r_);
1561 #endif
1562 }
1563 #if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
1564 #undef vreinterpretq_u8_f64
1565 #define vreinterpretq_u8_f64(a) simde_vreinterpretq_u8_f64(a)
1566 #endif
1567
1568 SIMDE_FUNCTION_ATTRIBUTES
1569 simde_uint16x4_t
simde_vreinterpret_u16_s8(simde_int8x8_t a)1570 simde_vreinterpret_u16_s8(simde_int8x8_t a) {
1571 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
1572 return vreinterpret_u16_s8(a);
1573 #else
1574 simde_uint16x4_private r_;
1575 simde_int8x8_private a_ = simde_int8x8_to_private(a);
1576 simde_memcpy(&r_, &a_, sizeof(r_));
1577 return simde_uint16x4_from_private(r_);
1578 #endif
1579 }
1580 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
1581 #undef vreinterpret_u16_s8
1582 #define vreinterpret_u16_s8(a) simde_vreinterpret_u16_s8(a)
1583 #endif
1584
1585 SIMDE_FUNCTION_ATTRIBUTES
1586 simde_uint16x4_t
simde_vreinterpret_u16_s16(simde_int16x4_t a)1587 simde_vreinterpret_u16_s16(simde_int16x4_t a) {
1588 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
1589 return vreinterpret_u16_s16(a);
1590 #else
1591 simde_uint16x4_private r_;
1592 simde_int16x4_private a_ = simde_int16x4_to_private(a);
1593 simde_memcpy(&r_, &a_, sizeof(r_));
1594 return simde_uint16x4_from_private(r_);
1595 #endif
1596 }
1597 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
1598 #undef vreinterpret_u16_s16
1599 #define vreinterpret_u16_s16(a) simde_vreinterpret_u16_s16(a)
1600 #endif
1601
1602 SIMDE_FUNCTION_ATTRIBUTES
1603 simde_uint16x4_t
simde_vreinterpret_u16_s32(simde_int32x2_t a)1604 simde_vreinterpret_u16_s32(simde_int32x2_t a) {
1605 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
1606 return vreinterpret_u16_s32(a);
1607 #else
1608 simde_uint16x4_private r_;
1609 simde_int32x2_private a_ = simde_int32x2_to_private(a);
1610 simde_memcpy(&r_, &a_, sizeof(r_));
1611 return simde_uint16x4_from_private(r_);
1612 #endif
1613 }
1614 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
1615 #undef vreinterpret_u16_s32
1616 #define vreinterpret_u16_s32(a) simde_vreinterpret_u16_s32(a)
1617 #endif
1618
1619 SIMDE_FUNCTION_ATTRIBUTES
1620 simde_uint16x4_t
simde_vreinterpret_u16_s64(simde_int64x1_t a)1621 simde_vreinterpret_u16_s64(simde_int64x1_t a) {
1622 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
1623 return vreinterpret_u16_s64(a);
1624 #else
1625 simde_uint16x4_private r_;
1626 simde_int64x1_private a_ = simde_int64x1_to_private(a);
1627 simde_memcpy(&r_, &a_, sizeof(r_));
1628 return simde_uint16x4_from_private(r_);
1629 #endif
1630 }
1631 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
1632 #undef vreinterpret_u16_s64
1633 #define vreinterpret_u16_s64(a) simde_vreinterpret_u16_s64(a)
1634 #endif
1635
1636 SIMDE_FUNCTION_ATTRIBUTES
1637 simde_uint16x4_t
simde_vreinterpret_u16_u8(simde_uint8x8_t a)1638 simde_vreinterpret_u16_u8(simde_uint8x8_t a) {
1639 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
1640 return vreinterpret_u16_u8(a);
1641 #else
1642 simde_uint16x4_private r_;
1643 simde_uint8x8_private a_ = simde_uint8x8_to_private(a);
1644 simde_memcpy(&r_, &a_, sizeof(r_));
1645 return simde_uint16x4_from_private(r_);
1646 #endif
1647 }
1648 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
1649 #undef vreinterpret_u16_u8
1650 #define vreinterpret_u16_u8(a) simde_vreinterpret_u16_u8(a)
1651 #endif
1652
1653 SIMDE_FUNCTION_ATTRIBUTES
1654 simde_uint16x4_t
simde_vreinterpret_u16_u32(simde_uint32x2_t a)1655 simde_vreinterpret_u16_u32(simde_uint32x2_t a) {
1656 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
1657 return vreinterpret_u16_u32(a);
1658 #else
1659 simde_uint16x4_private r_;
1660 simde_uint32x2_private a_ = simde_uint32x2_to_private(a);
1661 simde_memcpy(&r_, &a_, sizeof(r_));
1662 return simde_uint16x4_from_private(r_);
1663 #endif
1664 }
1665 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
1666 #undef vreinterpret_u16_u32
1667 #define vreinterpret_u16_u32(a) simde_vreinterpret_u16_u32(a)
1668 #endif
1669
1670 SIMDE_FUNCTION_ATTRIBUTES
1671 simde_uint16x4_t
simde_vreinterpret_u16_u64(simde_uint64x1_t a)1672 simde_vreinterpret_u16_u64(simde_uint64x1_t a) {
1673 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
1674 return vreinterpret_u16_u64(a);
1675 #else
1676 simde_uint16x4_private r_;
1677 simde_uint64x1_private a_ = simde_uint64x1_to_private(a);
1678 simde_memcpy(&r_, &a_, sizeof(r_));
1679 return simde_uint16x4_from_private(r_);
1680 #endif
1681 }
1682 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
1683 #undef vreinterpret_u16_u64
1684 #define vreinterpret_u16_u64(a) simde_vreinterpret_u16_u64(a)
1685 #endif
1686
1687 SIMDE_FUNCTION_ATTRIBUTES
1688 simde_uint16x4_t
simde_vreinterpret_u16_f32(simde_float32x2_t a)1689 simde_vreinterpret_u16_f32(simde_float32x2_t a) {
1690 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
1691 return vreinterpret_u16_f32(a);
1692 #else
1693 simde_uint16x4_private r_;
1694 simde_float32x2_private a_ = simde_float32x2_to_private(a);
1695 simde_memcpy(&r_, &a_, sizeof(r_));
1696 return simde_uint16x4_from_private(r_);
1697 #endif
1698 }
1699 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
1700 #undef vreinterpret_u16_f32
1701 #define vreinterpret_u16_f32(a) simde_vreinterpret_u16_f32(a)
1702 #endif
1703
1704 SIMDE_FUNCTION_ATTRIBUTES
1705 simde_uint16x4_t
simde_vreinterpret_u16_f64(simde_float64x1_t a)1706 simde_vreinterpret_u16_f64(simde_float64x1_t a) {
1707 #if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
1708 return vreinterpret_u16_f64(a);
1709 #else
1710 simde_uint16x4_private r_;
1711 simde_float64x1_private a_ = simde_float64x1_to_private(a);
1712 simde_memcpy(&r_, &a_, sizeof(r_));
1713 return simde_uint16x4_from_private(r_);
1714 #endif
1715 }
1716 #if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
1717 #undef vreinterpret_u16_f64
1718 #define vreinterpret_u16_f64(a) simde_vreinterpret_u16_f64(a)
1719 #endif
1720
1721 SIMDE_FUNCTION_ATTRIBUTES
1722 simde_uint16x8_t
simde_vreinterpretq_u16_s8(simde_int8x16_t a)1723 simde_vreinterpretq_u16_s8(simde_int8x16_t a) {
1724 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
1725 return vreinterpretq_u16_s8(a);
1726 #else
1727 simde_uint16x8_private r_;
1728 simde_int8x16_private a_ = simde_int8x16_to_private(a);
1729 simde_memcpy(&r_, &a_, sizeof(r_));
1730 return simde_uint16x8_from_private(r_);
1731 #endif
1732 }
1733 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
1734 #undef vreinterpretq_u16_s8
1735 #define vreinterpretq_u16_s8(a) simde_vreinterpretq_u16_s8(a)
1736 #endif
1737
1738 SIMDE_FUNCTION_ATTRIBUTES
1739 simde_uint16x8_t
simde_vreinterpretq_u16_s16(simde_int16x8_t a)1740 simde_vreinterpretq_u16_s16(simde_int16x8_t a) {
1741 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
1742 return vreinterpretq_u16_s16(a);
1743 #else
1744 simde_uint16x8_private r_;
1745 simde_int16x8_private a_ = simde_int16x8_to_private(a);
1746 simde_memcpy(&r_, &a_, sizeof(r_));
1747 return simde_uint16x8_from_private(r_);
1748 #endif
1749 }
1750 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
1751 #undef vreinterpretq_u16_s16
1752 #define vreinterpretq_u16_s16(a) simde_vreinterpretq_u16_s16(a)
1753 #endif
1754
1755 SIMDE_FUNCTION_ATTRIBUTES
1756 simde_uint16x8_t
simde_vreinterpretq_u16_s32(simde_int32x4_t a)1757 simde_vreinterpretq_u16_s32(simde_int32x4_t a) {
1758 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
1759 return vreinterpretq_u16_s32(a);
1760 #else
1761 simde_uint16x8_private r_;
1762 simde_int32x4_private a_ = simde_int32x4_to_private(a);
1763 simde_memcpy(&r_, &a_, sizeof(r_));
1764 return simde_uint16x8_from_private(r_);
1765 #endif
1766 }
1767 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
1768 #undef vreinterpretq_u16_s32
1769 #define vreinterpretq_u16_s32(a) simde_vreinterpretq_u16_s32(a)
1770 #endif
1771
1772 SIMDE_FUNCTION_ATTRIBUTES
1773 simde_uint16x8_t
simde_vreinterpretq_u16_s64(simde_int64x2_t a)1774 simde_vreinterpretq_u16_s64(simde_int64x2_t a) {
1775 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
1776 return vreinterpretq_u16_s64(a);
1777 #else
1778 simde_uint16x8_private r_;
1779 simde_int64x2_private a_ = simde_int64x2_to_private(a);
1780 simde_memcpy(&r_, &a_, sizeof(r_));
1781 return simde_uint16x8_from_private(r_);
1782 #endif
1783 }
1784 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
1785 #undef vreinterpretq_u16_s64
1786 #define vreinterpretq_u16_s64(a) simde_vreinterpretq_u16_s64(a)
1787 #endif
1788
1789 SIMDE_FUNCTION_ATTRIBUTES
1790 simde_uint16x8_t
simde_vreinterpretq_u16_u8(simde_uint8x16_t a)1791 simde_vreinterpretq_u16_u8(simde_uint8x16_t a) {
1792 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
1793 return vreinterpretq_u16_u8(a);
1794 #else
1795 simde_uint16x8_private r_;
1796 simde_uint8x16_private a_ = simde_uint8x16_to_private(a);
1797 simde_memcpy(&r_, &a_, sizeof(r_));
1798 return simde_uint16x8_from_private(r_);
1799 #endif
1800 }
1801 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
1802 #undef vreinterpretq_u16_u8
1803 #define vreinterpretq_u16_u8(a) simde_vreinterpretq_u16_u8(a)
1804 #endif
1805
1806 SIMDE_FUNCTION_ATTRIBUTES
1807 simde_uint16x8_t
simde_vreinterpretq_u16_u32(simde_uint32x4_t a)1808 simde_vreinterpretq_u16_u32(simde_uint32x4_t a) {
1809 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
1810 return vreinterpretq_u16_u32(a);
1811 #else
1812 simde_uint16x8_private r_;
1813 simde_uint32x4_private a_ = simde_uint32x4_to_private(a);
1814 simde_memcpy(&r_, &a_, sizeof(r_));
1815 return simde_uint16x8_from_private(r_);
1816 #endif
1817 }
1818 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
1819 #undef vreinterpretq_u16_u32
1820 #define vreinterpretq_u16_u32(a) simde_vreinterpretq_u16_u32(a)
1821 #endif
1822
1823 SIMDE_FUNCTION_ATTRIBUTES
1824 simde_uint16x8_t
simde_vreinterpretq_u16_u64(simde_uint64x2_t a)1825 simde_vreinterpretq_u16_u64(simde_uint64x2_t a) {
1826 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
1827 return vreinterpretq_u16_u64(a);
1828 #else
1829 simde_uint16x8_private r_;
1830 simde_uint64x2_private a_ = simde_uint64x2_to_private(a);
1831 simde_memcpy(&r_, &a_, sizeof(r_));
1832 return simde_uint16x8_from_private(r_);
1833 #endif
1834 }
1835 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
1836 #undef vreinterpretq_u16_u64
1837 #define vreinterpretq_u16_u64(a) simde_vreinterpretq_u16_u64(a)
1838 #endif
1839
1840 SIMDE_FUNCTION_ATTRIBUTES
1841 simde_uint16x8_t
simde_vreinterpretq_u16_f32(simde_float32x4_t a)1842 simde_vreinterpretq_u16_f32(simde_float32x4_t a) {
1843 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
1844 return vreinterpretq_u16_f32(a);
1845 #else
1846 simde_uint16x8_private r_;
1847 simde_float32x4_private a_ = simde_float32x4_to_private(a);
1848 simde_memcpy(&r_, &a_, sizeof(r_));
1849 return simde_uint16x8_from_private(r_);
1850 #endif
1851 }
1852 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
1853 #undef vreinterpretq_u16_f32
1854 #define vreinterpretq_u16_f32(a) simde_vreinterpretq_u16_f32(a)
1855 #endif
1856
1857 SIMDE_FUNCTION_ATTRIBUTES
1858 simde_uint16x8_t
simde_vreinterpretq_u16_f64(simde_float64x2_t a)1859 simde_vreinterpretq_u16_f64(simde_float64x2_t a) {
1860 #if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
1861 return vreinterpretq_u16_f64(a);
1862 #else
1863 simde_uint16x8_private r_;
1864 simde_float64x2_private a_ = simde_float64x2_to_private(a);
1865 simde_memcpy(&r_, &a_, sizeof(r_));
1866 return simde_uint16x8_from_private(r_);
1867 #endif
1868 }
1869 #if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
1870 #undef vreinterpretq_u16_f64
1871 #define vreinterpretq_u16_f64(a) simde_vreinterpretq_u16_f64(a)
1872 #endif
1873
1874 SIMDE_FUNCTION_ATTRIBUTES
1875 simde_uint32x2_t
simde_vreinterpret_u32_s8(simde_int8x8_t a)1876 simde_vreinterpret_u32_s8(simde_int8x8_t a) {
1877 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
1878 return vreinterpret_u32_s8(a);
1879 #else
1880 simde_uint32x2_private r_;
1881 simde_int8x8_private a_ = simde_int8x8_to_private(a);
1882 simde_memcpy(&r_, &a_, sizeof(r_));
1883 return simde_uint32x2_from_private(r_);
1884 #endif
1885 }
1886 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
1887 #undef vreinterpret_u32_s8
1888 #define vreinterpret_u32_s8(a) simde_vreinterpret_u32_s8(a)
1889 #endif
1890
1891 SIMDE_FUNCTION_ATTRIBUTES
1892 simde_uint32x2_t
simde_vreinterpret_u32_s16(simde_int16x4_t a)1893 simde_vreinterpret_u32_s16(simde_int16x4_t a) {
1894 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
1895 return vreinterpret_u32_s16(a);
1896 #else
1897 simde_uint32x2_private r_;
1898 simde_int16x4_private a_ = simde_int16x4_to_private(a);
1899 simde_memcpy(&r_, &a_, sizeof(r_));
1900 return simde_uint32x2_from_private(r_);
1901 #endif
1902 }
1903 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
1904 #undef vreinterpret_u32_s16
1905 #define vreinterpret_u32_s16(a) simde_vreinterpret_u32_s16(a)
1906 #endif
1907
1908 SIMDE_FUNCTION_ATTRIBUTES
1909 simde_uint32x2_t
simde_vreinterpret_u32_s32(simde_int32x2_t a)1910 simde_vreinterpret_u32_s32(simde_int32x2_t a) {
1911 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
1912 return vreinterpret_u32_s32(a);
1913 #else
1914 simde_uint32x2_private r_;
1915 simde_int32x2_private a_ = simde_int32x2_to_private(a);
1916 simde_memcpy(&r_, &a_, sizeof(r_));
1917 return simde_uint32x2_from_private(r_);
1918 #endif
1919 }
1920 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
1921 #undef vreinterpret_u32_s32
1922 #define vreinterpret_u32_s32(a) simde_vreinterpret_u32_s32(a)
1923 #endif
1924
1925 SIMDE_FUNCTION_ATTRIBUTES
1926 simde_uint32x2_t
simde_vreinterpret_u32_s64(simde_int64x1_t a)1927 simde_vreinterpret_u32_s64(simde_int64x1_t a) {
1928 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
1929 return vreinterpret_u32_s64(a);
1930 #else
1931 simde_uint32x2_private r_;
1932 simde_int64x1_private a_ = simde_int64x1_to_private(a);
1933 simde_memcpy(&r_, &a_, sizeof(r_));
1934 return simde_uint32x2_from_private(r_);
1935 #endif
1936 }
1937 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
1938 #undef vreinterpret_u32_s64
1939 #define vreinterpret_u32_s64(a) simde_vreinterpret_u32_s64(a)
1940 #endif
1941
1942 SIMDE_FUNCTION_ATTRIBUTES
1943 simde_uint32x2_t
simde_vreinterpret_u32_u8(simde_uint8x8_t a)1944 simde_vreinterpret_u32_u8(simde_uint8x8_t a) {
1945 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
1946 return vreinterpret_u32_u8(a);
1947 #else
1948 simde_uint32x2_private r_;
1949 simde_uint8x8_private a_ = simde_uint8x8_to_private(a);
1950 simde_memcpy(&r_, &a_, sizeof(r_));
1951 return simde_uint32x2_from_private(r_);
1952 #endif
1953 }
1954 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
1955 #undef vreinterpret_u32_u8
1956 #define vreinterpret_u32_u8(a) simde_vreinterpret_u32_u8(a)
1957 #endif
1958
1959 SIMDE_FUNCTION_ATTRIBUTES
1960 simde_uint32x2_t
simde_vreinterpret_u32_u16(simde_uint16x4_t a)1961 simde_vreinterpret_u32_u16(simde_uint16x4_t a) {
1962 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
1963 return vreinterpret_u32_u16(a);
1964 #else
1965 simde_uint32x2_private r_;
1966 simde_uint16x4_private a_ = simde_uint16x4_to_private(a);
1967 simde_memcpy(&r_, &a_, sizeof(r_));
1968 return simde_uint32x2_from_private(r_);
1969 #endif
1970 }
1971 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
1972 #undef vreinterpret_u32_u16
1973 #define vreinterpret_u32_u16(a) simde_vreinterpret_u32_u16(a)
1974 #endif
1975
1976 SIMDE_FUNCTION_ATTRIBUTES
1977 simde_uint32x2_t
simde_vreinterpret_u32_u64(simde_uint64x1_t a)1978 simde_vreinterpret_u32_u64(simde_uint64x1_t a) {
1979 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
1980 return vreinterpret_u32_u64(a);
1981 #else
1982 simde_uint32x2_private r_;
1983 simde_uint64x1_private a_ = simde_uint64x1_to_private(a);
1984 simde_memcpy(&r_, &a_, sizeof(r_));
1985 return simde_uint32x2_from_private(r_);
1986 #endif
1987 }
1988 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
1989 #undef vreinterpret_u32_u64
1990 #define vreinterpret_u32_u64(a) simde_vreinterpret_u32_u64(a)
1991 #endif
1992
1993 SIMDE_FUNCTION_ATTRIBUTES
1994 simde_uint32x2_t
simde_vreinterpret_u32_f32(simde_float32x2_t a)1995 simde_vreinterpret_u32_f32(simde_float32x2_t a) {
1996 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
1997 return vreinterpret_u32_f32(a);
1998 #else
1999 simde_uint32x2_private r_;
2000 simde_float32x2_private a_ = simde_float32x2_to_private(a);
2001 simde_memcpy(&r_, &a_, sizeof(r_));
2002 return simde_uint32x2_from_private(r_);
2003 #endif
2004 }
2005 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
2006 #undef vreinterpret_u32_f32
2007 #define vreinterpret_u32_f32(a) simde_vreinterpret_u32_f32(a)
2008 #endif
2009
2010 SIMDE_FUNCTION_ATTRIBUTES
2011 simde_uint32x2_t
simde_vreinterpret_u32_f64(simde_float64x1_t a)2012 simde_vreinterpret_u32_f64(simde_float64x1_t a) {
2013 #if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
2014 return vreinterpret_u32_f64(a);
2015 #else
2016 simde_uint32x2_private r_;
2017 simde_float64x1_private a_ = simde_float64x1_to_private(a);
2018 simde_memcpy(&r_, &a_, sizeof(r_));
2019 return simde_uint32x2_from_private(r_);
2020 #endif
2021 }
2022 #if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
2023 #undef vreinterpret_u32_f64
2024 #define vreinterpret_u32_f64(a) simde_vreinterpret_u32_f64(a)
2025 #endif
2026
2027 SIMDE_FUNCTION_ATTRIBUTES
2028 simde_uint32x4_t
simde_vreinterpretq_u32_s8(simde_int8x16_t a)2029 simde_vreinterpretq_u32_s8(simde_int8x16_t a) {
2030 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
2031 return vreinterpretq_u32_s8(a);
2032 #else
2033 simde_uint32x4_private r_;
2034 simde_int8x16_private a_ = simde_int8x16_to_private(a);
2035 simde_memcpy(&r_, &a_, sizeof(r_));
2036 return simde_uint32x4_from_private(r_);
2037 #endif
2038 }
2039 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
2040 #undef vreinterpretq_u32_s8
2041 #define vreinterpretq_u32_s8(a) simde_vreinterpretq_u32_s8(a)
2042 #endif
2043
2044 SIMDE_FUNCTION_ATTRIBUTES
2045 simde_uint32x4_t
simde_vreinterpretq_u32_s16(simde_int16x8_t a)2046 simde_vreinterpretq_u32_s16(simde_int16x8_t a) {
2047 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
2048 return vreinterpretq_u32_s16(a);
2049 #else
2050 simde_uint32x4_private r_;
2051 simde_int16x8_private a_ = simde_int16x8_to_private(a);
2052 simde_memcpy(&r_, &a_, sizeof(r_));
2053 return simde_uint32x4_from_private(r_);
2054 #endif
2055 }
2056 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
2057 #undef vreinterpretq_u32_s16
2058 #define vreinterpretq_u32_s16(a) simde_vreinterpretq_u32_s16(a)
2059 #endif
2060
2061 SIMDE_FUNCTION_ATTRIBUTES
2062 simde_uint32x4_t
simde_vreinterpretq_u32_s32(simde_int32x4_t a)2063 simde_vreinterpretq_u32_s32(simde_int32x4_t a) {
2064 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
2065 return vreinterpretq_u32_s32(a);
2066 #else
2067 simde_uint32x4_private r_;
2068 simde_int32x4_private a_ = simde_int32x4_to_private(a);
2069 simde_memcpy(&r_, &a_, sizeof(r_));
2070 return simde_uint32x4_from_private(r_);
2071 #endif
2072 }
2073 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
2074 #undef vreinterpretq_u32_s32
2075 #define vreinterpretq_u32_s32(a) simde_vreinterpretq_u32_s32(a)
2076 #endif
2077
2078 SIMDE_FUNCTION_ATTRIBUTES
2079 simde_uint32x4_t
simde_vreinterpretq_u32_s64(simde_int64x2_t a)2080 simde_vreinterpretq_u32_s64(simde_int64x2_t a) {
2081 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
2082 return vreinterpretq_u32_s64(a);
2083 #else
2084 simde_uint32x4_private r_;
2085 simde_int64x2_private a_ = simde_int64x2_to_private(a);
2086 simde_memcpy(&r_, &a_, sizeof(r_));
2087 return simde_uint32x4_from_private(r_);
2088 #endif
2089 }
2090 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
2091 #undef vreinterpretq_u32_s64
2092 #define vreinterpretq_u32_s64(a) simde_vreinterpretq_u32_s64(a)
2093 #endif
2094
2095 SIMDE_FUNCTION_ATTRIBUTES
2096 simde_uint32x4_t
simde_vreinterpretq_u32_u8(simde_uint8x16_t a)2097 simde_vreinterpretq_u32_u8(simde_uint8x16_t a) {
2098 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
2099 return vreinterpretq_u32_u8(a);
2100 #else
2101 simde_uint32x4_private r_;
2102 simde_uint8x16_private a_ = simde_uint8x16_to_private(a);
2103 simde_memcpy(&r_, &a_, sizeof(r_));
2104 return simde_uint32x4_from_private(r_);
2105 #endif
2106 }
2107 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
2108 #undef vreinterpretq_u32_u8
2109 #define vreinterpretq_u32_u8(a) simde_vreinterpretq_u32_u8(a)
2110 #endif
2111
2112 SIMDE_FUNCTION_ATTRIBUTES
2113 simde_uint32x4_t
simde_vreinterpretq_u32_u16(simde_uint16x8_t a)2114 simde_vreinterpretq_u32_u16(simde_uint16x8_t a) {
2115 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
2116 return vreinterpretq_u32_u16(a);
2117 #else
2118 simde_uint32x4_private r_;
2119 simde_uint16x8_private a_ = simde_uint16x8_to_private(a);
2120 simde_memcpy(&r_, &a_, sizeof(r_));
2121 return simde_uint32x4_from_private(r_);
2122 #endif
2123 }
2124 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
2125 #undef vreinterpretq_u32_u16
2126 #define vreinterpretq_u32_u16(a) simde_vreinterpretq_u32_u16(a)
2127 #endif
2128
2129 SIMDE_FUNCTION_ATTRIBUTES
2130 simde_uint32x4_t
simde_vreinterpretq_u32_u64(simde_uint64x2_t a)2131 simde_vreinterpretq_u32_u64(simde_uint64x2_t a) {
2132 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
2133 return vreinterpretq_u32_u64(a);
2134 #else
2135 simde_uint32x4_private r_;
2136 simde_uint64x2_private a_ = simde_uint64x2_to_private(a);
2137 simde_memcpy(&r_, &a_, sizeof(r_));
2138 return simde_uint32x4_from_private(r_);
2139 #endif
2140 }
2141 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
2142 #undef vreinterpretq_u32_u64
2143 #define vreinterpretq_u32_u64(a) simde_vreinterpretq_u32_u64(a)
2144 #endif
2145
2146 SIMDE_FUNCTION_ATTRIBUTES
2147 simde_uint32x4_t
simde_vreinterpretq_u32_f32(simde_float32x4_t a)2148 simde_vreinterpretq_u32_f32(simde_float32x4_t a) {
2149 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
2150 return vreinterpretq_u32_f32(a);
2151 #else
2152 simde_uint32x4_private r_;
2153 simde_float32x4_private a_ = simde_float32x4_to_private(a);
2154 simde_memcpy(&r_, &a_, sizeof(r_));
2155 return simde_uint32x4_from_private(r_);
2156 #endif
2157 }
2158 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
2159 #undef vreinterpretq_u32_f32
2160 #define vreinterpretq_u32_f32(a) simde_vreinterpretq_u32_f32(a)
2161 #endif
2162
2163 SIMDE_FUNCTION_ATTRIBUTES
2164 simde_uint32x4_t
simde_vreinterpretq_u32_f64(simde_float64x2_t a)2165 simde_vreinterpretq_u32_f64(simde_float64x2_t a) {
2166 #if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
2167 return vreinterpretq_u32_f64(a);
2168 #else
2169 simde_uint32x4_private r_;
2170 simde_float64x2_private a_ = simde_float64x2_to_private(a);
2171 simde_memcpy(&r_, &a_, sizeof(r_));
2172 return simde_uint32x4_from_private(r_);
2173 #endif
2174 }
2175 #if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
2176 #undef vreinterpretq_u32_f64
2177 #define vreinterpretq_u32_f64(a) simde_vreinterpretq_u32_f64(a)
2178 #endif
2179
2180 SIMDE_FUNCTION_ATTRIBUTES
2181 simde_uint64x1_t
simde_vreinterpret_u64_s8(simde_int8x8_t a)2182 simde_vreinterpret_u64_s8(simde_int8x8_t a) {
2183 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
2184 return vreinterpret_u64_s8(a);
2185 #else
2186 simde_uint64x1_private r_;
2187 simde_int8x8_private a_ = simde_int8x8_to_private(a);
2188 simde_memcpy(&r_, &a_, sizeof(r_));
2189 return simde_uint64x1_from_private(r_);
2190 #endif
2191 }
2192 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
2193 #undef vreinterpret_u64_s8
2194 #define vreinterpret_u64_s8(a) simde_vreinterpret_u64_s8(a)
2195 #endif
2196
2197 SIMDE_FUNCTION_ATTRIBUTES
2198 simde_uint64x1_t
simde_vreinterpret_u64_s16(simde_int16x4_t a)2199 simde_vreinterpret_u64_s16(simde_int16x4_t a) {
2200 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
2201 return vreinterpret_u64_s16(a);
2202 #else
2203 simde_uint64x1_private r_;
2204 simde_int16x4_private a_ = simde_int16x4_to_private(a);
2205 simde_memcpy(&r_, &a_, sizeof(r_));
2206 return simde_uint64x1_from_private(r_);
2207 #endif
2208 }
2209 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
2210 #undef vreinterpret_u64_s16
2211 #define vreinterpret_u64_s16(a) simde_vreinterpret_u64_s16(a)
2212 #endif
2213
2214 SIMDE_FUNCTION_ATTRIBUTES
2215 simde_uint64x1_t
simde_vreinterpret_u64_s32(simde_int32x2_t a)2216 simde_vreinterpret_u64_s32(simde_int32x2_t a) {
2217 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
2218 return vreinterpret_u64_s32(a);
2219 #else
2220 simde_uint64x1_private r_;
2221 simde_int32x2_private a_ = simde_int32x2_to_private(a);
2222 simde_memcpy(&r_, &a_, sizeof(r_));
2223 return simde_uint64x1_from_private(r_);
2224 #endif
2225 }
2226 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
2227 #undef vreinterpret_u64_s32
2228 #define vreinterpret_u64_s32(a) simde_vreinterpret_u64_s32(a)
2229 #endif
2230
2231 SIMDE_FUNCTION_ATTRIBUTES
2232 simde_uint64x1_t
simde_vreinterpret_u64_s64(simde_int64x1_t a)2233 simde_vreinterpret_u64_s64(simde_int64x1_t a) {
2234 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
2235 return vreinterpret_u64_s64(a);
2236 #else
2237 simde_uint64x1_private r_;
2238 simde_int64x1_private a_ = simde_int64x1_to_private(a);
2239 simde_memcpy(&r_, &a_, sizeof(r_));
2240 return simde_uint64x1_from_private(r_);
2241 #endif
2242 }
2243 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
2244 #undef vreinterpret_u64_s64
2245 #define vreinterpret_u64_s64(a) simde_vreinterpret_u64_s64(a)
2246 #endif
2247
2248 SIMDE_FUNCTION_ATTRIBUTES
2249 simde_uint64x1_t
simde_vreinterpret_u64_u8(simde_uint8x8_t a)2250 simde_vreinterpret_u64_u8(simde_uint8x8_t a) {
2251 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
2252 return vreinterpret_u64_u8(a);
2253 #else
2254 simde_uint64x1_private r_;
2255 simde_uint8x8_private a_ = simde_uint8x8_to_private(a);
2256 simde_memcpy(&r_, &a_, sizeof(r_));
2257 return simde_uint64x1_from_private(r_);
2258 #endif
2259 }
2260 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
2261 #undef vreinterpret_u64_u8
2262 #define vreinterpret_u64_u8(a) simde_vreinterpret_u64_u8(a)
2263 #endif
2264
2265 SIMDE_FUNCTION_ATTRIBUTES
2266 simde_uint64x1_t
simde_vreinterpret_u64_u16(simde_uint16x4_t a)2267 simde_vreinterpret_u64_u16(simde_uint16x4_t a) {
2268 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
2269 return vreinterpret_u64_u16(a);
2270 #else
2271 simde_uint64x1_private r_;
2272 simde_uint16x4_private a_ = simde_uint16x4_to_private(a);
2273 simde_memcpy(&r_, &a_, sizeof(r_));
2274 return simde_uint64x1_from_private(r_);
2275 #endif
2276 }
2277 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
2278 #undef vreinterpret_u64_u16
2279 #define vreinterpret_u64_u16(a) simde_vreinterpret_u64_u16(a)
2280 #endif
2281
2282 SIMDE_FUNCTION_ATTRIBUTES
2283 simde_uint64x1_t
simde_vreinterpret_u64_u32(simde_uint32x2_t a)2284 simde_vreinterpret_u64_u32(simde_uint32x2_t a) {
2285 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
2286 return vreinterpret_u64_u32(a);
2287 #else
2288 simde_uint64x1_private r_;
2289 simde_uint32x2_private a_ = simde_uint32x2_to_private(a);
2290 simde_memcpy(&r_, &a_, sizeof(r_));
2291 return simde_uint64x1_from_private(r_);
2292 #endif
2293 }
2294 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
2295 #undef vreinterpret_u64_u32
2296 #define vreinterpret_u64_u32(a) simde_vreinterpret_u64_u32(a)
2297 #endif
2298
2299 SIMDE_FUNCTION_ATTRIBUTES
2300 simde_uint64x1_t
simde_vreinterpret_u64_f32(simde_float32x2_t a)2301 simde_vreinterpret_u64_f32(simde_float32x2_t a) {
2302 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
2303 return vreinterpret_u64_f32(a);
2304 #else
2305 simde_uint64x1_private r_;
2306 simde_float32x2_private a_ = simde_float32x2_to_private(a);
2307 simde_memcpy(&r_, &a_, sizeof(r_));
2308 return simde_uint64x1_from_private(r_);
2309 #endif
2310 }
2311 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
2312 #undef vreinterpret_u64_f32
2313 #define vreinterpret_u64_f32(a) simde_vreinterpret_u64_f32(a)
2314 #endif
2315
2316 SIMDE_FUNCTION_ATTRIBUTES
2317 simde_uint64x1_t
simde_vreinterpret_u64_f64(simde_float64x1_t a)2318 simde_vreinterpret_u64_f64(simde_float64x1_t a) {
2319 #if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
2320 return vreinterpret_u64_f64(a);
2321 #else
2322 simde_uint64x1_private r_;
2323 simde_float64x1_private a_ = simde_float64x1_to_private(a);
2324 simde_memcpy(&r_, &a_, sizeof(r_));
2325 return simde_uint64x1_from_private(r_);
2326 #endif
2327 }
2328 #if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
2329 #undef vreinterpret_u64_f64
2330 #define vreinterpret_u64_f64(a) simde_vreinterpret_u64_f64(a)
2331 #endif
2332
2333 SIMDE_FUNCTION_ATTRIBUTES
2334 simde_uint64x2_t
simde_vreinterpretq_u64_s8(simde_int8x16_t a)2335 simde_vreinterpretq_u64_s8(simde_int8x16_t a) {
2336 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
2337 return vreinterpretq_u64_s8(a);
2338 #else
2339 simde_uint64x2_private r_;
2340 simde_int8x16_private a_ = simde_int8x16_to_private(a);
2341 simde_memcpy(&r_, &a_, sizeof(r_));
2342 return simde_uint64x2_from_private(r_);
2343 #endif
2344 }
2345 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
2346 #undef vreinterpretq_u64_s8
2347 #define vreinterpretq_u64_s8(a) simde_vreinterpretq_u64_s8(a)
2348 #endif
2349
2350 SIMDE_FUNCTION_ATTRIBUTES
2351 simde_uint64x2_t
simde_vreinterpretq_u64_s16(simde_int16x8_t a)2352 simde_vreinterpretq_u64_s16(simde_int16x8_t a) {
2353 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
2354 return vreinterpretq_u64_s16(a);
2355 #else
2356 simde_uint64x2_private r_;
2357 simde_int16x8_private a_ = simde_int16x8_to_private(a);
2358 simde_memcpy(&r_, &a_, sizeof(r_));
2359 return simde_uint64x2_from_private(r_);
2360 #endif
2361 }
2362 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
2363 #undef vreinterpretq_u64_s16
2364 #define vreinterpretq_u64_s16(a) simde_vreinterpretq_u64_s16(a)
2365 #endif
2366
2367 SIMDE_FUNCTION_ATTRIBUTES
2368 simde_uint64x2_t
simde_vreinterpretq_u64_s32(simde_int32x4_t a)2369 simde_vreinterpretq_u64_s32(simde_int32x4_t a) {
2370 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
2371 return vreinterpretq_u64_s32(a);
2372 #else
2373 simde_uint64x2_private r_;
2374 simde_int32x4_private a_ = simde_int32x4_to_private(a);
2375 simde_memcpy(&r_, &a_, sizeof(r_));
2376 return simde_uint64x2_from_private(r_);
2377 #endif
2378 }
2379 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
2380 #undef vreinterpretq_u64_s32
2381 #define vreinterpretq_u64_s32(a) simde_vreinterpretq_u64_s32(a)
2382 #endif
2383
2384 SIMDE_FUNCTION_ATTRIBUTES
2385 simde_uint64x2_t
simde_vreinterpretq_u64_s64(simde_int64x2_t a)2386 simde_vreinterpretq_u64_s64(simde_int64x2_t a) {
2387 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
2388 return vreinterpretq_u64_s64(a);
2389 #else
2390 simde_uint64x2_private r_;
2391 simde_int64x2_private a_ = simde_int64x2_to_private(a);
2392 simde_memcpy(&r_, &a_, sizeof(r_));
2393 return simde_uint64x2_from_private(r_);
2394 #endif
2395 }
2396 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
2397 #undef vreinterpretq_u64_s64
2398 #define vreinterpretq_u64_s64(a) simde_vreinterpretq_u64_s64(a)
2399 #endif
2400
2401 SIMDE_FUNCTION_ATTRIBUTES
2402 simde_uint64x2_t
simde_vreinterpretq_u64_u8(simde_uint8x16_t a)2403 simde_vreinterpretq_u64_u8(simde_uint8x16_t a) {
2404 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
2405 return vreinterpretq_u64_u8(a);
2406 #else
2407 simde_uint64x2_private r_;
2408 simde_uint8x16_private a_ = simde_uint8x16_to_private(a);
2409 simde_memcpy(&r_, &a_, sizeof(r_));
2410 return simde_uint64x2_from_private(r_);
2411 #endif
2412 }
2413 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
2414 #undef vreinterpretq_u64_u8
2415 #define vreinterpretq_u64_u8(a) simde_vreinterpretq_u64_u8(a)
2416 #endif
2417
2418 SIMDE_FUNCTION_ATTRIBUTES
2419 simde_uint64x2_t
simde_vreinterpretq_u64_u16(simde_uint16x8_t a)2420 simde_vreinterpretq_u64_u16(simde_uint16x8_t a) {
2421 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
2422 return vreinterpretq_u64_u16(a);
2423 #else
2424 simde_uint64x2_private r_;
2425 simde_uint16x8_private a_ = simde_uint16x8_to_private(a);
2426 simde_memcpy(&r_, &a_, sizeof(r_));
2427 return simde_uint64x2_from_private(r_);
2428 #endif
2429 }
2430 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
2431 #undef vreinterpretq_u64_u16
2432 #define vreinterpretq_u64_u16(a) simde_vreinterpretq_u64_u16(a)
2433 #endif
2434
2435 SIMDE_FUNCTION_ATTRIBUTES
2436 simde_uint64x2_t
simde_vreinterpretq_u64_u32(simde_uint32x4_t a)2437 simde_vreinterpretq_u64_u32(simde_uint32x4_t a) {
2438 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
2439 return vreinterpretq_u64_u32(a);
2440 #else
2441 simde_uint64x2_private r_;
2442 simde_uint32x4_private a_ = simde_uint32x4_to_private(a);
2443 simde_memcpy(&r_, &a_, sizeof(r_));
2444 return simde_uint64x2_from_private(r_);
2445 #endif
2446 }
2447 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
2448 #undef vreinterpretq_u64_u32
2449 #define vreinterpretq_u64_u32(a) simde_vreinterpretq_u64_u32(a)
2450 #endif
2451
2452 SIMDE_FUNCTION_ATTRIBUTES
2453 simde_uint64x2_t
simde_vreinterpretq_u64_f32(simde_float32x4_t a)2454 simde_vreinterpretq_u64_f32(simde_float32x4_t a) {
2455 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
2456 return vreinterpretq_u64_f32(a);
2457 #else
2458 simde_uint64x2_private r_;
2459 simde_float32x4_private a_ = simde_float32x4_to_private(a);
2460 simde_memcpy(&r_, &a_, sizeof(r_));
2461 return simde_uint64x2_from_private(r_);
2462 #endif
2463 }
2464 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
2465 #undef vreinterpretq_u64_f32
2466 #define vreinterpretq_u64_f32(a) simde_vreinterpretq_u64_f32(a)
2467 #endif
2468
2469 SIMDE_FUNCTION_ATTRIBUTES
2470 simde_uint64x2_t
simde_vreinterpretq_u64_f64(simde_float64x2_t a)2471 simde_vreinterpretq_u64_f64(simde_float64x2_t a) {
2472 #if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
2473 return vreinterpretq_u64_f64(a);
2474 #else
2475 simde_uint64x2_private r_;
2476 simde_float64x2_private a_ = simde_float64x2_to_private(a);
2477 simde_memcpy(&r_, &a_, sizeof(r_));
2478 return simde_uint64x2_from_private(r_);
2479 #endif
2480 }
2481 #if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
2482 #undef vreinterpretq_u64_f64
2483 #define vreinterpretq_u64_f64(a) simde_vreinterpretq_u64_f64(a)
2484 #endif
2485
2486 SIMDE_FUNCTION_ATTRIBUTES
2487 simde_float32x2_t
simde_vreinterpret_f32_s8(simde_int8x8_t a)2488 simde_vreinterpret_f32_s8(simde_int8x8_t a) {
2489 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
2490 return vreinterpret_f32_s8(a);
2491 #else
2492 simde_float32x2_private r_;
2493 simde_int8x8_private a_ = simde_int8x8_to_private(a);
2494 simde_memcpy(&r_, &a_, sizeof(r_));
2495 return simde_float32x2_from_private(r_);
2496 #endif
2497 }
2498 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
2499 #undef vreinterpret_f32_s8
2500 #define vreinterpret_f32_s8(a) simde_vreinterpret_f32_s8(a)
2501 #endif
2502
2503 SIMDE_FUNCTION_ATTRIBUTES
2504 simde_float32x2_t
simde_vreinterpret_f32_s16(simde_int16x4_t a)2505 simde_vreinterpret_f32_s16(simde_int16x4_t a) {
2506 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
2507 return vreinterpret_f32_s16(a);
2508 #else
2509 simde_float32x2_private r_;
2510 simde_int16x4_private a_ = simde_int16x4_to_private(a);
2511 simde_memcpy(&r_, &a_, sizeof(r_));
2512 return simde_float32x2_from_private(r_);
2513 #endif
2514 }
2515 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
2516 #undef vreinterpret_f32_s16
2517 #define vreinterpret_f32_s16(a) simde_vreinterpret_f32_s16(a)
2518 #endif
2519
2520 SIMDE_FUNCTION_ATTRIBUTES
2521 simde_float32x2_t
simde_vreinterpret_f32_s32(simde_int32x2_t a)2522 simde_vreinterpret_f32_s32(simde_int32x2_t a) {
2523 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
2524 return vreinterpret_f32_s32(a);
2525 #else
2526 simde_float32x2_private r_;
2527 simde_int32x2_private a_ = simde_int32x2_to_private(a);
2528 simde_memcpy(&r_, &a_, sizeof(r_));
2529 return simde_float32x2_from_private(r_);
2530 #endif
2531 }
2532 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
2533 #undef vreinterpret_f32_s32
2534 #define vreinterpret_f32_s32(a) simde_vreinterpret_f32_s32(a)
2535 #endif
2536
2537 SIMDE_FUNCTION_ATTRIBUTES
2538 simde_float32x2_t
simde_vreinterpret_f32_s64(simde_int64x1_t a)2539 simde_vreinterpret_f32_s64(simde_int64x1_t a) {
2540 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
2541 return vreinterpret_f32_s64(a);
2542 #else
2543 simde_float32x2_private r_;
2544 simde_int64x1_private a_ = simde_int64x1_to_private(a);
2545 simde_memcpy(&r_, &a_, sizeof(r_));
2546 return simde_float32x2_from_private(r_);
2547 #endif
2548 }
2549 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
2550 #undef vreinterpret_f32_s64
2551 #define vreinterpret_f32_s64(a) simde_vreinterpret_f32_s64(a)
2552 #endif
2553
2554 SIMDE_FUNCTION_ATTRIBUTES
2555 simde_float32x2_t
simde_vreinterpret_f32_u8(simde_uint8x8_t a)2556 simde_vreinterpret_f32_u8(simde_uint8x8_t a) {
2557 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
2558 return vreinterpret_f32_u8(a);
2559 #else
2560 simde_float32x2_private r_;
2561 simde_uint8x8_private a_ = simde_uint8x8_to_private(a);
2562 simde_memcpy(&r_, &a_, sizeof(r_));
2563 return simde_float32x2_from_private(r_);
2564 #endif
2565 }
2566 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
2567 #undef vreinterpret_f32_u8
2568 #define vreinterpret_f32_u8(a) simde_vreinterpret_f32_u8(a)
2569 #endif
2570
2571 SIMDE_FUNCTION_ATTRIBUTES
2572 simde_float32x2_t
simde_vreinterpret_f32_u16(simde_uint16x4_t a)2573 simde_vreinterpret_f32_u16(simde_uint16x4_t a) {
2574 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
2575 return vreinterpret_f32_u16(a);
2576 #else
2577 simde_float32x2_private r_;
2578 simde_uint16x4_private a_ = simde_uint16x4_to_private(a);
2579 simde_memcpy(&r_, &a_, sizeof(r_));
2580 return simde_float32x2_from_private(r_);
2581 #endif
2582 }
2583 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
2584 #undef vreinterpret_f32_u16
2585 #define vreinterpret_f32_u16(a) simde_vreinterpret_f32_u16(a)
2586 #endif
2587
2588 SIMDE_FUNCTION_ATTRIBUTES
2589 simde_float32x2_t
simde_vreinterpret_f32_u32(simde_uint32x2_t a)2590 simde_vreinterpret_f32_u32(simde_uint32x2_t a) {
2591 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
2592 return vreinterpret_f32_u32(a);
2593 #else
2594 simde_float32x2_private r_;
2595 simde_uint32x2_private a_ = simde_uint32x2_to_private(a);
2596 simde_memcpy(&r_, &a_, sizeof(r_));
2597 return simde_float32x2_from_private(r_);
2598 #endif
2599 }
2600 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
2601 #undef vreinterpret_f32_u32
2602 #define vreinterpret_f32_u32(a) simde_vreinterpret_f32_u32(a)
2603 #endif
2604
2605 SIMDE_FUNCTION_ATTRIBUTES
2606 simde_float32x2_t
simde_vreinterpret_f32_u64(simde_uint64x1_t a)2607 simde_vreinterpret_f32_u64(simde_uint64x1_t a) {
2608 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
2609 return vreinterpret_f32_u64(a);
2610 #else
2611 simde_float32x2_private r_;
2612 simde_uint64x1_private a_ = simde_uint64x1_to_private(a);
2613 simde_memcpy(&r_, &a_, sizeof(r_));
2614 return simde_float32x2_from_private(r_);
2615 #endif
2616 }
2617 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
2618 #undef vreinterpret_f32_u64
2619 #define vreinterpret_f32_u64(a) simde_vreinterpret_f32_u64(a)
2620 #endif
2621
2622 SIMDE_FUNCTION_ATTRIBUTES
2623 simde_float32x2_t
simde_vreinterpret_f32_f64(simde_float64x1_t a)2624 simde_vreinterpret_f32_f64(simde_float64x1_t a) {
2625 #if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
2626 return vreinterpret_f32_f64(a);
2627 #else
2628 simde_float32x2_private r_;
2629 simde_float64x1_private a_ = simde_float64x1_to_private(a);
2630 simde_memcpy(&r_, &a_, sizeof(r_));
2631 return simde_float32x2_from_private(r_);
2632 #endif
2633 }
2634 #if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
2635 #undef vreinterpret_f32_f64
2636 #define vreinterpret_f32_f64(a) simde_vreinterpret_f32_f64(a)
2637 #endif
2638
2639 SIMDE_FUNCTION_ATTRIBUTES
2640 simde_float32x4_t
simde_vreinterpretq_f32_s8(simde_int8x16_t a)2641 simde_vreinterpretq_f32_s8(simde_int8x16_t a) {
2642 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
2643 return vreinterpretq_f32_s8(a);
2644 #else
2645 simde_float32x4_private r_;
2646 simde_int8x16_private a_ = simde_int8x16_to_private(a);
2647 simde_memcpy(&r_, &a_, sizeof(r_));
2648 return simde_float32x4_from_private(r_);
2649 #endif
2650 }
2651 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
2652 #undef vreinterpretq_f32_s8
2653 #define vreinterpretq_f32_s8(a) simde_vreinterpretq_f32_s8(a)
2654 #endif
2655
2656 SIMDE_FUNCTION_ATTRIBUTES
2657 simde_float32x4_t
simde_vreinterpretq_f32_s16(simde_int16x8_t a)2658 simde_vreinterpretq_f32_s16(simde_int16x8_t a) {
2659 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
2660 return vreinterpretq_f32_s16(a);
2661 #else
2662 simde_float32x4_private r_;
2663 simde_int16x8_private a_ = simde_int16x8_to_private(a);
2664 simde_memcpy(&r_, &a_, sizeof(r_));
2665 return simde_float32x4_from_private(r_);
2666 #endif
2667 }
2668 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
2669 #undef vreinterpretq_f32_s16
2670 #define vreinterpretq_f32_s16(a) simde_vreinterpretq_f32_s16(a)
2671 #endif
2672
2673 SIMDE_FUNCTION_ATTRIBUTES
2674 simde_float32x4_t
simde_vreinterpretq_f32_s32(simde_int32x4_t a)2675 simde_vreinterpretq_f32_s32(simde_int32x4_t a) {
2676 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
2677 return vreinterpretq_f32_s32(a);
2678 #else
2679 simde_float32x4_private r_;
2680 simde_int32x4_private a_ = simde_int32x4_to_private(a);
2681 simde_memcpy(&r_, &a_, sizeof(r_));
2682 return simde_float32x4_from_private(r_);
2683 #endif
2684 }
2685 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
2686 #undef vreinterpretq_f32_s32
2687 #define vreinterpretq_f32_s32(a) simde_vreinterpretq_f32_s32(a)
2688 #endif
2689
2690 SIMDE_FUNCTION_ATTRIBUTES
2691 simde_float32x4_t
simde_vreinterpretq_f32_s64(simde_int64x2_t a)2692 simde_vreinterpretq_f32_s64(simde_int64x2_t a) {
2693 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
2694 return vreinterpretq_f32_s64(a);
2695 #else
2696 simde_float32x4_private r_;
2697 simde_int64x2_private a_ = simde_int64x2_to_private(a);
2698 simde_memcpy(&r_, &a_, sizeof(r_));
2699 return simde_float32x4_from_private(r_);
2700 #endif
2701 }
2702 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
2703 #undef vreinterpretq_f32_s64
2704 #define vreinterpretq_f32_s64(a) simde_vreinterpretq_f32_s64(a)
2705 #endif
2706
2707 SIMDE_FUNCTION_ATTRIBUTES
2708 simde_float32x4_t
simde_vreinterpretq_f32_u8(simde_uint8x16_t a)2709 simde_vreinterpretq_f32_u8(simde_uint8x16_t a) {
2710 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
2711 return vreinterpretq_f32_u8(a);
2712 #else
2713 simde_float32x4_private r_;
2714 simde_uint8x16_private a_ = simde_uint8x16_to_private(a);
2715 simde_memcpy(&r_, &a_, sizeof(r_));
2716 return simde_float32x4_from_private(r_);
2717 #endif
2718 }
2719 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
2720 #undef vreinterpretq_f32_u8
2721 #define vreinterpretq_f32_u8(a) simde_vreinterpretq_f32_u8(a)
2722 #endif
2723
2724 SIMDE_FUNCTION_ATTRIBUTES
2725 simde_float32x4_t
simde_vreinterpretq_f32_u16(simde_uint16x8_t a)2726 simde_vreinterpretq_f32_u16(simde_uint16x8_t a) {
2727 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
2728 return vreinterpretq_f32_u16(a);
2729 #else
2730 simde_float32x4_private r_;
2731 simde_uint16x8_private a_ = simde_uint16x8_to_private(a);
2732 simde_memcpy(&r_, &a_, sizeof(r_));
2733 return simde_float32x4_from_private(r_);
2734 #endif
2735 }
2736 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
2737 #undef vreinterpretq_f32_u16
2738 #define vreinterpretq_f32_u16(a) simde_vreinterpretq_f32_u16(a)
2739 #endif
2740
2741 SIMDE_FUNCTION_ATTRIBUTES
2742 simde_float32x4_t
simde_vreinterpretq_f32_u32(simde_uint32x4_t a)2743 simde_vreinterpretq_f32_u32(simde_uint32x4_t a) {
2744 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
2745 return vreinterpretq_f32_u32(a);
2746 #else
2747 simde_float32x4_private r_;
2748 simde_uint32x4_private a_ = simde_uint32x4_to_private(a);
2749 simde_memcpy(&r_, &a_, sizeof(r_));
2750 return simde_float32x4_from_private(r_);
2751 #endif
2752 }
2753 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
2754 #undef vreinterpretq_f32_u32
2755 #define vreinterpretq_f32_u32(a) simde_vreinterpretq_f32_u32(a)
2756 #endif
2757
2758 SIMDE_FUNCTION_ATTRIBUTES
2759 simde_float32x4_t
simde_vreinterpretq_f32_u64(simde_uint64x2_t a)2760 simde_vreinterpretq_f32_u64(simde_uint64x2_t a) {
2761 #if defined(SIMDE_ARM_NEON_A32V7_NATIVE)
2762 return vreinterpretq_f32_u64(a);
2763 #else
2764 simde_float32x4_private r_;
2765 simde_uint64x2_private a_ = simde_uint64x2_to_private(a);
2766 simde_memcpy(&r_, &a_, sizeof(r_));
2767 return simde_float32x4_from_private(r_);
2768 #endif
2769 }
2770 #if defined(SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES)
2771 #undef vreinterpretq_f32_u64
2772 #define vreinterpretq_f32_u64(a) simde_vreinterpretq_f32_u64(a)
2773 #endif
2774
2775 SIMDE_FUNCTION_ATTRIBUTES
2776 simde_float32x4_t
simde_vreinterpretq_f32_f64(simde_float64x2_t a)2777 simde_vreinterpretq_f32_f64(simde_float64x2_t a) {
2778 #if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
2779 return vreinterpretq_f32_f64(a);
2780 #else
2781 simde_float32x4_private r_;
2782 simde_float64x2_private a_ = simde_float64x2_to_private(a);
2783 simde_memcpy(&r_, &a_, sizeof(r_));
2784 return simde_float32x4_from_private(r_);
2785 #endif
2786 }
2787 #if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
2788 #undef vreinterpretq_f32_f64
2789 #define vreinterpretq_f32_f64(a) simde_vreinterpretq_f32_f64(a)
2790 #endif
2791
2792 SIMDE_FUNCTION_ATTRIBUTES
2793 simde_float64x1_t
simde_vreinterpret_f64_s8(simde_int8x8_t a)2794 simde_vreinterpret_f64_s8(simde_int8x8_t a) {
2795 #if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
2796 return vreinterpret_f64_s8(a);
2797 #else
2798 simde_float64x1_private r_;
2799 simde_int8x8_private a_ = simde_int8x8_to_private(a);
2800 simde_memcpy(&r_, &a_, sizeof(r_));
2801 return simde_float64x1_from_private(r_);
2802 #endif
2803 }
2804 #if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
2805 #undef vreinterpret_f64_s8
2806 #define vreinterpret_f64_s8(a) simde_vreinterpret_f64_s8(a)
2807 #endif
2808
2809 SIMDE_FUNCTION_ATTRIBUTES
2810 simde_float64x1_t
simde_vreinterpret_f64_s16(simde_int16x4_t a)2811 simde_vreinterpret_f64_s16(simde_int16x4_t a) {
2812 #if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
2813 return vreinterpret_f64_s16(a);
2814 #else
2815 simde_float64x1_private r_;
2816 simde_int16x4_private a_ = simde_int16x4_to_private(a);
2817 simde_memcpy(&r_, &a_, sizeof(r_));
2818 return simde_float64x1_from_private(r_);
2819 #endif
2820 }
2821 #if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
2822 #undef vreinterpret_f64_s16
2823 #define vreinterpret_f64_s16(a) simde_vreinterpret_f64_s16(a)
2824 #endif
2825
2826 SIMDE_FUNCTION_ATTRIBUTES
2827 simde_float64x1_t
simde_vreinterpret_f64_s32(simde_int32x2_t a)2828 simde_vreinterpret_f64_s32(simde_int32x2_t a) {
2829 #if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
2830 return vreinterpret_f64_s32(a);
2831 #else
2832 simde_float64x1_private r_;
2833 simde_int32x2_private a_ = simde_int32x2_to_private(a);
2834 simde_memcpy(&r_, &a_, sizeof(r_));
2835 return simde_float64x1_from_private(r_);
2836 #endif
2837 }
2838 #if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
2839 #undef vreinterpret_f64_s32
2840 #define vreinterpret_f64_s32(a) simde_vreinterpret_f64_s32(a)
2841 #endif
2842
2843 SIMDE_FUNCTION_ATTRIBUTES
2844 simde_float64x1_t
simde_vreinterpret_f64_s64(simde_int64x1_t a)2845 simde_vreinterpret_f64_s64(simde_int64x1_t a) {
2846 #if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
2847 return vreinterpret_f64_s64(a);
2848 #else
2849 simde_float64x1_private r_;
2850 simde_int64x1_private a_ = simde_int64x1_to_private(a);
2851 simde_memcpy(&r_, &a_, sizeof(r_));
2852 return simde_float64x1_from_private(r_);
2853 #endif
2854 }
2855 #if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
2856 #undef vreinterpret_f64_s64
2857 #define vreinterpret_f64_s64(a) simde_vreinterpret_f64_s64(a)
2858 #endif
2859
2860 SIMDE_FUNCTION_ATTRIBUTES
2861 simde_float64x1_t
simde_vreinterpret_f64_u8(simde_uint8x8_t a)2862 simde_vreinterpret_f64_u8(simde_uint8x8_t a) {
2863 #if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
2864 return vreinterpret_f64_u8(a);
2865 #else
2866 simde_float64x1_private r_;
2867 simde_uint8x8_private a_ = simde_uint8x8_to_private(a);
2868 simde_memcpy(&r_, &a_, sizeof(r_));
2869 return simde_float64x1_from_private(r_);
2870 #endif
2871 }
2872 #if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
2873 #undef vreinterpret_f64_u8
2874 #define vreinterpret_f64_u8(a) simde_vreinterpret_f64_u8(a)
2875 #endif
2876
2877 SIMDE_FUNCTION_ATTRIBUTES
2878 simde_float64x1_t
simde_vreinterpret_f64_u16(simde_uint16x4_t a)2879 simde_vreinterpret_f64_u16(simde_uint16x4_t a) {
2880 #if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
2881 return vreinterpret_f64_u16(a);
2882 #else
2883 simde_float64x1_private r_;
2884 simde_uint16x4_private a_ = simde_uint16x4_to_private(a);
2885 simde_memcpy(&r_, &a_, sizeof(r_));
2886 return simde_float64x1_from_private(r_);
2887 #endif
2888 }
2889 #if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
2890 #undef vreinterpret_f64_u16
2891 #define vreinterpret_f64_u16(a) simde_vreinterpret_f64_u16(a)
2892 #endif
2893
2894 SIMDE_FUNCTION_ATTRIBUTES
2895 simde_float64x1_t
simde_vreinterpret_f64_u32(simde_uint32x2_t a)2896 simde_vreinterpret_f64_u32(simde_uint32x2_t a) {
2897 #if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
2898 return vreinterpret_f64_u32(a);
2899 #else
2900 simde_float64x1_private r_;
2901 simde_uint32x2_private a_ = simde_uint32x2_to_private(a);
2902 simde_memcpy(&r_, &a_, sizeof(r_));
2903 return simde_float64x1_from_private(r_);
2904 #endif
2905 }
2906 #if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
2907 #undef vreinterpret_f64_u32
2908 #define vreinterpret_f64_u32(a) simde_vreinterpret_f64_u32(a)
2909 #endif
2910
2911 SIMDE_FUNCTION_ATTRIBUTES
2912 simde_float64x1_t
simde_vreinterpret_f64_u64(simde_uint64x1_t a)2913 simde_vreinterpret_f64_u64(simde_uint64x1_t a) {
2914 #if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
2915 return vreinterpret_f64_u64(a);
2916 #else
2917 simde_float64x1_private r_;
2918 simde_uint64x1_private a_ = simde_uint64x1_to_private(a);
2919 simde_memcpy(&r_, &a_, sizeof(r_));
2920 return simde_float64x1_from_private(r_);
2921 #endif
2922 }
2923 #if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
2924 #undef vreinterpret_f64_u64
2925 #define vreinterpret_f64_u64(a) simde_vreinterpret_f64_u64(a)
2926 #endif
2927
2928 SIMDE_FUNCTION_ATTRIBUTES
2929 simde_float64x1_t
simde_vreinterpret_f64_f32(simde_float32x2_t a)2930 simde_vreinterpret_f64_f32(simde_float32x2_t a) {
2931 #if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
2932 return vreinterpret_f64_f32(a);
2933 #else
2934 simde_float64x1_private r_;
2935 simde_float32x2_private a_ = simde_float32x2_to_private(a);
2936 simde_memcpy(&r_, &a_, sizeof(r_));
2937 return simde_float64x1_from_private(r_);
2938 #endif
2939 }
2940 #if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
2941 #undef vreinterpret_f64_f32
2942 #define vreinterpret_f64_f32(a) simde_vreinterpret_f64_f32(a)
2943 #endif
2944
2945 SIMDE_FUNCTION_ATTRIBUTES
2946 simde_float64x2_t
simde_vreinterpretq_f64_s8(simde_int8x16_t a)2947 simde_vreinterpretq_f64_s8(simde_int8x16_t a) {
2948 #if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
2949 return vreinterpretq_f64_s8(a);
2950 #else
2951 simde_float64x2_private r_;
2952 simde_int8x16_private a_ = simde_int8x16_to_private(a);
2953 simde_memcpy(&r_, &a_, sizeof(r_));
2954 return simde_float64x2_from_private(r_);
2955 #endif
2956 }
2957 #if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
2958 #undef vreinterpretq_f64_s8
2959 #define vreinterpretq_f64_s8(a) simde_vreinterpretq_f64_s8(a)
2960 #endif
2961
2962 SIMDE_FUNCTION_ATTRIBUTES
2963 simde_float64x2_t
simde_vreinterpretq_f64_s16(simde_int16x8_t a)2964 simde_vreinterpretq_f64_s16(simde_int16x8_t a) {
2965 #if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
2966 return vreinterpretq_f64_s16(a);
2967 #else
2968 simde_float64x2_private r_;
2969 simde_int16x8_private a_ = simde_int16x8_to_private(a);
2970 simde_memcpy(&r_, &a_, sizeof(r_));
2971 return simde_float64x2_from_private(r_);
2972 #endif
2973 }
2974 #if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
2975 #undef vreinterpretq_f64_s16
2976 #define vreinterpretq_f64_s16(a) simde_vreinterpretq_f64_s16(a)
2977 #endif
2978
2979 SIMDE_FUNCTION_ATTRIBUTES
2980 simde_float64x2_t
simde_vreinterpretq_f64_s32(simde_int32x4_t a)2981 simde_vreinterpretq_f64_s32(simde_int32x4_t a) {
2982 #if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
2983 return vreinterpretq_f64_s32(a);
2984 #else
2985 simde_float64x2_private r_;
2986 simde_int32x4_private a_ = simde_int32x4_to_private(a);
2987 simde_memcpy(&r_, &a_, sizeof(r_));
2988 return simde_float64x2_from_private(r_);
2989 #endif
2990 }
2991 #if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
2992 #undef vreinterpretq_f64_s32
2993 #define vreinterpretq_f64_s32(a) simde_vreinterpretq_f64_s32(a)
2994 #endif
2995
2996 SIMDE_FUNCTION_ATTRIBUTES
2997 simde_float64x2_t
simde_vreinterpretq_f64_s64(simde_int64x2_t a)2998 simde_vreinterpretq_f64_s64(simde_int64x2_t a) {
2999 #if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
3000 return vreinterpretq_f64_s64(a);
3001 #else
3002 simde_float64x2_private r_;
3003 simde_int64x2_private a_ = simde_int64x2_to_private(a);
3004 simde_memcpy(&r_, &a_, sizeof(r_));
3005 return simde_float64x2_from_private(r_);
3006 #endif
3007 }
3008 #if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
3009 #undef vreinterpretq_f64_s64
3010 #define vreinterpretq_f64_s64(a) simde_vreinterpretq_f64_s64(a)
3011 #endif
3012
3013 SIMDE_FUNCTION_ATTRIBUTES
3014 simde_float64x2_t
simde_vreinterpretq_f64_u8(simde_uint8x16_t a)3015 simde_vreinterpretq_f64_u8(simde_uint8x16_t a) {
3016 #if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
3017 return vreinterpretq_f64_u8(a);
3018 #else
3019 simde_float64x2_private r_;
3020 simde_uint8x16_private a_ = simde_uint8x16_to_private(a);
3021 simde_memcpy(&r_, &a_, sizeof(r_));
3022 return simde_float64x2_from_private(r_);
3023 #endif
3024 }
3025 #if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
3026 #undef vreinterpretq_f64_u8
3027 #define vreinterpretq_f64_u8(a) simde_vreinterpretq_f64_u8(a)
3028 #endif
3029
3030 SIMDE_FUNCTION_ATTRIBUTES
3031 simde_float64x2_t
simde_vreinterpretq_f64_u16(simde_uint16x8_t a)3032 simde_vreinterpretq_f64_u16(simde_uint16x8_t a) {
3033 #if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
3034 return vreinterpretq_f64_u16(a);
3035 #else
3036 simde_float64x2_private r_;
3037 simde_uint16x8_private a_ = simde_uint16x8_to_private(a);
3038 simde_memcpy(&r_, &a_, sizeof(r_));
3039 return simde_float64x2_from_private(r_);
3040 #endif
3041 }
3042 #if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
3043 #undef vreinterpretq_f64_u16
3044 #define vreinterpretq_f64_u16(a) simde_vreinterpretq_f64_u16(a)
3045 #endif
3046
3047 SIMDE_FUNCTION_ATTRIBUTES
3048 simde_float64x2_t
simde_vreinterpretq_f64_u32(simde_uint32x4_t a)3049 simde_vreinterpretq_f64_u32(simde_uint32x4_t a) {
3050 #if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
3051 return vreinterpretq_f64_u32(a);
3052 #else
3053 simde_float64x2_private r_;
3054 simde_uint32x4_private a_ = simde_uint32x4_to_private(a);
3055 simde_memcpy(&r_, &a_, sizeof(r_));
3056 return simde_float64x2_from_private(r_);
3057 #endif
3058 }
3059 #if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
3060 #undef vreinterpretq_f64_u32
3061 #define vreinterpretq_f64_u32(a) simde_vreinterpretq_f64_u32(a)
3062 #endif
3063
3064 SIMDE_FUNCTION_ATTRIBUTES
3065 simde_float64x2_t
simde_vreinterpretq_f64_u64(simde_uint64x2_t a)3066 simde_vreinterpretq_f64_u64(simde_uint64x2_t a) {
3067 #if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
3068 return vreinterpretq_f64_u64(a);
3069 #else
3070 simde_float64x2_private r_;
3071 simde_uint64x2_private a_ = simde_uint64x2_to_private(a);
3072 simde_memcpy(&r_, &a_, sizeof(r_));
3073 return simde_float64x2_from_private(r_);
3074 #endif
3075 }
3076 #if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
3077 #undef vreinterpretq_f64_u64
3078 #define vreinterpretq_f64_u64(a) simde_vreinterpretq_f64_u64(a)
3079 #endif
3080
3081 SIMDE_FUNCTION_ATTRIBUTES
3082 simde_float64x2_t
simde_vreinterpretq_f64_f32(simde_float32x4_t a)3083 simde_vreinterpretq_f64_f32(simde_float32x4_t a) {
3084 #if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
3085 return vreinterpretq_f64_f32(a);
3086 #else
3087 simde_float64x2_private r_;
3088 simde_float32x4_private a_ = simde_float32x4_to_private(a);
3089 simde_memcpy(&r_, &a_, sizeof(r_));
3090 return simde_float64x2_from_private(r_);
3091 #endif
3092 }
3093 #if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
3094 #undef vreinterpretq_f64_f32
3095 #define vreinterpretq_f64_f32(a) simde_vreinterpretq_f64_f32(a)
3096 #endif
3097
3098 SIMDE_END_DECLS_
3099 HEDLEY_DIAGNOSTIC_POP
3100
3101 #endif
3102