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 */
26
27 #if !defined(SIMDE_ARM_NEON_ADDV_H)
28 #define SIMDE_ARM_NEON_ADDV_H
29
30 #include "types.h"
31
32 HEDLEY_DIAGNOSTIC_PUSH
33 SIMDE_DISABLE_UNWANTED_DIAGNOSTICS
34 SIMDE_BEGIN_DECLS_
35
36 SIMDE_FUNCTION_ATTRIBUTES
37 simde_float32_t
simde_vaddv_f32(simde_float32x2_t a)38 simde_vaddv_f32(simde_float32x2_t a) {
39 simde_float32_t r;
40
41 #if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
42 r = vaddv_f32(a);
43 #else
44 simde_float32x2_private a_ = simde_float32x2_to_private(a);
45
46 r = 0;
47 SIMDE_VECTORIZE_REDUCTION(+:r)
48 for (size_t i = 0 ; i < (sizeof(a_.values) / sizeof(a_.values[0])) ; i++) {
49 r += a_.values[i];
50 }
51 #endif
52
53 return r;
54 }
55 #if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
56 #undef vaddv_f32
57 #define vaddv_f32(v) simde_vaddv_f32(v)
58 #endif
59
60 SIMDE_FUNCTION_ATTRIBUTES
61 int8_t
simde_vaddv_s8(simde_int8x8_t a)62 simde_vaddv_s8(simde_int8x8_t a) {
63 int8_t r;
64
65 #if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
66 r = vaddv_s8(a);
67 #else
68 simde_int8x8_private a_ = simde_int8x8_to_private(a);
69
70 r = 0;
71 SIMDE_VECTORIZE_REDUCTION(+:r)
72 for (size_t i = 0 ; i < (sizeof(a_.values) / sizeof(a_.values[0])) ; i++) {
73 r += a_.values[i];
74 }
75 #endif
76
77 return r;
78 }
79 #if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
80 #undef vaddv_s8
81 #define vaddv_s8(v) simde_vaddv_s8(v)
82 #endif
83
84 SIMDE_FUNCTION_ATTRIBUTES
85 int16_t
simde_vaddv_s16(simde_int16x4_t a)86 simde_vaddv_s16(simde_int16x4_t a) {
87 int16_t r;
88
89 #if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
90 r = vaddv_s16(a);
91 #else
92 simde_int16x4_private a_ = simde_int16x4_to_private(a);
93
94 r = 0;
95 SIMDE_VECTORIZE_REDUCTION(+:r)
96 for (size_t i = 0 ; i < (sizeof(a_.values) / sizeof(a_.values[0])) ; i++) {
97 r += a_.values[i];
98 }
99 #endif
100
101 return r;
102 }
103 #if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
104 #undef vaddv_s16
105 #define vaddv_s16(v) simde_vaddv_s16(v)
106 #endif
107
108 SIMDE_FUNCTION_ATTRIBUTES
109 int32_t
simde_vaddv_s32(simde_int32x2_t a)110 simde_vaddv_s32(simde_int32x2_t a) {
111 int32_t r;
112
113 #if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
114 r = vaddv_s32(a);
115 #else
116 simde_int32x2_private a_ = simde_int32x2_to_private(a);
117
118 r = 0;
119 SIMDE_VECTORIZE_REDUCTION(+:r)
120 for (size_t i = 0 ; i < (sizeof(a_.values) / sizeof(a_.values[0])) ; i++) {
121 r += a_.values[i];
122 }
123 #endif
124
125 return r;
126 }
127 #if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
128 #undef vaddv_s32
129 #define vaddv_s32(v) simde_vaddv_s32(v)
130 #endif
131
132 SIMDE_FUNCTION_ATTRIBUTES
133 uint8_t
simde_vaddv_u8(simde_uint8x8_t a)134 simde_vaddv_u8(simde_uint8x8_t a) {
135 uint8_t r;
136
137 #if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
138 r = vaddv_u8(a);
139 #else
140 simde_uint8x8_private a_ = simde_uint8x8_to_private(a);
141
142 r = 0;
143 SIMDE_VECTORIZE_REDUCTION(+:r)
144 for (size_t i = 0 ; i < (sizeof(a_.values) / sizeof(a_.values[0])) ; i++) {
145 r += a_.values[i];
146 }
147 #endif
148
149 return r;
150 }
151 #if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
152 #undef vaddv_u8
153 #define vaddv_u8(v) simde_vaddv_u8(v)
154 #endif
155
156 SIMDE_FUNCTION_ATTRIBUTES
157 uint16_t
simde_vaddv_u16(simde_uint16x4_t a)158 simde_vaddv_u16(simde_uint16x4_t a) {
159 uint16_t r;
160
161 #if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
162 r = vaddv_u16(a);
163 #else
164 simde_uint16x4_private a_ = simde_uint16x4_to_private(a);
165
166 r = 0;
167 SIMDE_VECTORIZE_REDUCTION(+:r)
168 for (size_t i = 0 ; i < (sizeof(a_.values) / sizeof(a_.values[0])) ; i++) {
169 r += a_.values[i];
170 }
171 #endif
172
173 return r;
174 }
175 #if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
176 #undef vaddv_u16
177 #define vaddv_u16(v) simde_vaddv_u16(v)
178 #endif
179
180 SIMDE_FUNCTION_ATTRIBUTES
181 uint32_t
simde_vaddv_u32(simde_uint32x2_t a)182 simde_vaddv_u32(simde_uint32x2_t a) {
183 uint32_t r;
184
185 #if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
186 r = vaddv_u32(a);
187 #else
188 simde_uint32x2_private a_ = simde_uint32x2_to_private(a);
189
190 r = 0;
191 SIMDE_VECTORIZE_REDUCTION(+:r)
192 for (size_t i = 0 ; i < (sizeof(a_.values) / sizeof(a_.values[0])) ; i++) {
193 r += a_.values[i];
194 }
195 #endif
196
197 return r;
198 }
199 #if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
200 #undef vaddv_u32
201 #define vaddv_u32(v) simde_vaddv_u32(v)
202 #endif
203
204 SIMDE_FUNCTION_ATTRIBUTES
205 simde_float32_t
simde_vaddvq_f32(simde_float32x4_t a)206 simde_vaddvq_f32(simde_float32x4_t a) {
207 simde_float32_t r;
208
209 #if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
210 r = vaddvq_f32(a);
211 #else
212 simde_float32x4_private a_ = simde_float32x4_to_private(a);
213
214 r = 0;
215 SIMDE_VECTORIZE_REDUCTION(+:r)
216 for (size_t i = 0 ; i < (sizeof(a_.values) / sizeof(a_.values[0])) ; i++) {
217 r += a_.values[i];
218 }
219 #endif
220
221 return r;
222 }
223 #if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
224 #undef vaddvq_f32
225 #define vaddvq_f32(v) simde_vaddvq_f32(v)
226 #endif
227
228 SIMDE_FUNCTION_ATTRIBUTES
229 simde_float64_t
simde_vaddvq_f64(simde_float64x2_t a)230 simde_vaddvq_f64(simde_float64x2_t a) {
231 simde_float64_t r;
232
233 #if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
234 r = vaddvq_f64(a);
235 #else
236 simde_float64x2_private a_ = simde_float64x2_to_private(a);
237
238 r = 0;
239 SIMDE_VECTORIZE_REDUCTION(+:r)
240 for (size_t i = 0 ; i < (sizeof(a_.values) / sizeof(a_.values[0])) ; i++) {
241 r += a_.values[i];
242 }
243 #endif
244
245 return r;
246 }
247 #if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
248 #undef vaddvq_f64
249 #define vaddvq_f64(v) simde_vaddvq_f64(v)
250 #endif
251
252 SIMDE_FUNCTION_ATTRIBUTES
253 int8_t
simde_vaddvq_s8(simde_int8x16_t a)254 simde_vaddvq_s8(simde_int8x16_t a) {
255 int8_t r;
256
257 #if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
258 r = vaddvq_s8(a);
259 #else
260 simde_int8x16_private a_ = simde_int8x16_to_private(a);
261
262 r = 0;
263 SIMDE_VECTORIZE_REDUCTION(+:r)
264 for (size_t i = 0 ; i < (sizeof(a_.values) / sizeof(a_.values[0])) ; i++) {
265 r += a_.values[i];
266 }
267 #endif
268
269 return r;
270 }
271 #if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
272 #undef vaddvq_s8
273 #define vaddvq_s8(v) simde_vaddvq_s8(v)
274 #endif
275
276 SIMDE_FUNCTION_ATTRIBUTES
277 int16_t
simde_vaddvq_s16(simde_int16x8_t a)278 simde_vaddvq_s16(simde_int16x8_t a) {
279 int16_t r;
280
281 #if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
282 r = vaddvq_s16(a);
283 #else
284 simde_int16x8_private a_ = simde_int16x8_to_private(a);
285
286 r = 0;
287 SIMDE_VECTORIZE_REDUCTION(+:r)
288 for (size_t i = 0 ; i < (sizeof(a_.values) / sizeof(a_.values[0])) ; i++) {
289 r += a_.values[i];
290 }
291 #endif
292
293 return r;
294 }
295 #if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
296 #undef vaddvq_s16
297 #define vaddvq_s16(v) simde_vaddvq_s16(v)
298 #endif
299
300 SIMDE_FUNCTION_ATTRIBUTES
301 int32_t
simde_vaddvq_s32(simde_int32x4_t a)302 simde_vaddvq_s32(simde_int32x4_t a) {
303 int32_t r;
304
305 #if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
306 r = vaddvq_s32(a);
307 #else
308 simde_int32x4_private a_ = simde_int32x4_to_private(a);
309
310 r = 0;
311 SIMDE_VECTORIZE_REDUCTION(+:r)
312 for (size_t i = 0 ; i < (sizeof(a_.values) / sizeof(a_.values[0])) ; i++) {
313 r += a_.values[i];
314 }
315 #endif
316
317 return r;
318 }
319 #if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
320 #undef vaddvq_s32
321 #define vaddvq_s32(v) simde_vaddvq_s32(v)
322 #endif
323
324 SIMDE_FUNCTION_ATTRIBUTES
325 int64_t
simde_vaddvq_s64(simde_int64x2_t a)326 simde_vaddvq_s64(simde_int64x2_t a) {
327 int64_t r;
328
329 #if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
330 r = vaddvq_s64(a);
331 #else
332 simde_int64x2_private a_ = simde_int64x2_to_private(a);
333
334 r = 0;
335 SIMDE_VECTORIZE_REDUCTION(+:r)
336 for (size_t i = 0 ; i < (sizeof(a_.values) / sizeof(a_.values[0])) ; i++) {
337 r += a_.values[i];
338 }
339 #endif
340
341 return r;
342 }
343 #if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
344 #undef vaddvq_s64
345 #define vaddvq_s64(v) simde_vaddvq_s64(v)
346 #endif
347
348 SIMDE_FUNCTION_ATTRIBUTES
349 uint8_t
simde_vaddvq_u8(simde_uint8x16_t a)350 simde_vaddvq_u8(simde_uint8x16_t a) {
351 uint8_t r;
352
353 #if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
354 r = vaddvq_u8(a);
355 #else
356 simde_uint8x16_private a_ = simde_uint8x16_to_private(a);
357
358 r = 0;
359 SIMDE_VECTORIZE_REDUCTION(+:r)
360 for (size_t i = 0 ; i < (sizeof(a_.values) / sizeof(a_.values[0])) ; i++) {
361 r += a_.values[i];
362 }
363 #endif
364
365 return r;
366 }
367 #if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
368 #undef vaddvq_u8
369 #define vaddvq_u8(v) simde_vaddvq_u8(v)
370 #endif
371
372 SIMDE_FUNCTION_ATTRIBUTES
373 uint16_t
simde_vaddvq_u16(simde_uint16x8_t a)374 simde_vaddvq_u16(simde_uint16x8_t a) {
375 uint16_t r;
376
377 #if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
378 r = vaddvq_u16(a);
379 #else
380 simde_uint16x8_private a_ = simde_uint16x8_to_private(a);
381
382 r = 0;
383 SIMDE_VECTORIZE_REDUCTION(+:r)
384 for (size_t i = 0 ; i < (sizeof(a_.values) / sizeof(a_.values[0])) ; i++) {
385 r += a_.values[i];
386 }
387 #endif
388
389 return r;
390 }
391 #if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
392 #undef vaddvq_u16
393 #define vaddvq_u16(v) simde_vaddvq_u16(v)
394 #endif
395
396 SIMDE_FUNCTION_ATTRIBUTES
397 uint32_t
simde_vaddvq_u32(simde_uint32x4_t a)398 simde_vaddvq_u32(simde_uint32x4_t a) {
399 uint32_t r;
400
401 #if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
402 r = vaddvq_u32(a);
403 #else
404 simde_uint32x4_private a_ = simde_uint32x4_to_private(a);
405
406 r = 0;
407 SIMDE_VECTORIZE_REDUCTION(+:r)
408 for (size_t i = 0 ; i < (sizeof(a_.values) / sizeof(a_.values[0])) ; i++) {
409 r += a_.values[i];
410 }
411 #endif
412
413 return r;
414 }
415 #if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
416 #undef vaddvq_u32
417 #define vaddvq_u32(v) simde_vaddvq_u32(v)
418 #endif
419
420 SIMDE_FUNCTION_ATTRIBUTES
421 uint64_t
simde_vaddvq_u64(simde_uint64x2_t a)422 simde_vaddvq_u64(simde_uint64x2_t a) {
423 uint64_t r;
424
425 #if defined(SIMDE_ARM_NEON_A64V8_NATIVE)
426 r = vaddvq_u64(a);
427 #else
428 simde_uint64x2_private a_ = simde_uint64x2_to_private(a);
429
430 r = 0;
431 SIMDE_VECTORIZE_REDUCTION(+:r)
432 for (size_t i = 0 ; i < (sizeof(a_.values) / sizeof(a_.values[0])) ; i++) {
433 r += a_.values[i];
434 }
435 #endif
436
437 return r;
438 }
439 #if defined(SIMDE_ARM_NEON_A64V8_ENABLE_NATIVE_ALIASES)
440 #undef vaddvq_u64
441 #define vaddvq_u64(v) simde_vaddvq_u64(v)
442 #endif
443
444 SIMDE_END_DECLS_
445 HEDLEY_DIAGNOSTIC_POP
446
447 #endif /* !defined(SIMDE_ARM_NEON_ADDV_H) */
448